nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-13 12:36:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use partial_cmp to implement tuple lt/le/ge/gt

Browse Source
This commit is contained in:
Scott McMurray 2023-02-16 23:59:13 -08:00
parent dc37e37329
commit 680e21687d
2 changed files with 40 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
library/core/src/tuple.rs
View File

@ -1,7 +1,7 @@
// See src/libstd/primitive_docs.rs for documentation.
use crate::cmp::Ordering::*;
use crate::cmp::*;
use crate::cmp::Ordering::{self, *};
use crate::mem::transmute;
// Recursive macro for implementing n-ary tuple functions and operations
//
@ -61,19 +61,19 @@ macro_rules! tuple_impls {
}
#[inline]
fn lt(&self, other: &($($T,)+)) -> bool {
lexical_ord!(lt, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
lexical_ord!(lt, Less, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
}
#[inline]
fn le(&self, other: &($($T,)+)) -> bool {
lexical_ord!(le, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
lexical_ord!(le, Less, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
}
#[inline]
fn ge(&self, other: &($($T,)+)) -> bool {
lexical_ord!(ge, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
lexical_ord!(ge, Greater, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
}
#[inline]
fn gt(&self, other: &($($T,)+)) -> bool {
lexical_ord!(gt, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
lexical_ord!(gt, Greater, $( ${ignore(T)} self.${index()}, other.${index()} ),+)
}
}
}
@ -123,16 +123,38 @@ macro_rules! maybe_tuple_doc {
};
}
// Constructs an expression that performs a lexical ordering using method $rel.
#[inline]
const fn ordering_is_some(c: Option<Ordering>, x: Ordering) -> bool {
// FIXME: Just use `==` once that's const-stable on `Option`s.
// This isn't using `match` because that optimizes worse due to
// making a two-step check (`Some` *then* the inner value).
// SAFETY: There's no public guarantee for `Option<Ordering>`,
// but we're core so we know that it's definitely a byte.
unsafe {
let c: i8 = transmute(c);
let x: i8 = transmute(Some(x));
c == x
}
}
// Constructs an expression that performs a lexical ordering using method `$rel`.
// The values are interleaved, so the macro invocation for
// `(a1, a2, a3) < (b1, b2, b3)` would be `lexical_ord!(lt, a1, b1, a2, b2,
// a3, b3)` (and similarly for `lexical_cmp`)
// `(a1, a2, a3) < (b1, b2, b3)` would be `lexical_ord!(lt, opt_is_lt, a1, b1,
// a2, b2, a3, b3)` (and similarly for `lexical_cmp`)
//
// `$ne_rel` is only used to determine the result after checking that they're
// not equal, so `lt` and `le` can both just use `Less`.
macro_rules! lexical_ord {
($rel: ident, $a:expr, $b:expr, $($rest_a:expr, $rest_b:expr),+) => {
if $a != $b { lexical_ord!($rel, $a, $b) }
else { lexical_ord!($rel, $($rest_a, $rest_b),+) }
($rel: ident, $ne_rel: ident, $a:expr, $b:expr, $($rest_a:expr, $rest_b:expr),+) => {{
let c = PartialOrd::partial_cmp(&$a, &$b);
if !ordering_is_some(c, Equal) { ordering_is_some(c, $ne_rel) }
else { lexical_ord!($rel, $ne_rel, $($rest_a, $rest_b),+) }
}};
($rel: ident, $ne_rel: ident, $a:expr, $b:expr) => {
// Use the specific method for the last element
PartialOrd::$rel(&$a, &$b)
};
($rel: ident, $a:expr, $b:expr) => { ($a) . $rel (& $b) };
}
macro_rules! lexical_partial_cmp {

7
tests/codegen/comparison-operators-2-tuple.rs
View File

@ -11,6 +11,9 @@ type TwoTuple = (i16, u16);
//
// The operators are all overridden directly, so should optimize easily.
//
// Yes, the `s[lg]t` is correct for the `[lg]e` version because it's only used
// in the side of the select where we know the values are *not* equal.
//
// CHECK-LABEL: @check_lt_direct
// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
@ -29,7 +32,7 @@ pub fn check_lt_direct(a: TwoTuple, b: TwoTuple) -> bool {
#[no_mangle]
pub fn check_le_direct(a: TwoTuple, b: TwoTuple) -> bool {
// CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
// CHECK-DAG: %[[CMP0:.+]] = icmp sle i16 %[[A0]], %[[B0]]
// CHECK-DAG: %[[CMP0:.+]] = icmp slt i16 %[[A0]], %[[B0]]
// CHECK-DAG: %[[CMP1:.+]] = icmp ule i16 %[[A1]], %[[B1]]
// CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
// CHECK: ret i1 %[[R]]
@ -53,7 +56,7 @@ pub fn check_gt_direct(a: TwoTuple, b: TwoTuple) -> bool {
#[no_mangle]
pub fn check_ge_direct(a: TwoTuple, b: TwoTuple) -> bool {
// CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
// CHECK-DAG: %[[CMP0:.+]] = icmp sge i16 %[[A0]], %[[B0]]
// CHECK-DAG: %[[CMP0:.+]] = icmp sgt i16 %[[A0]], %[[B0]]
// CHECK-DAG: %[[CMP1:.+]] = icmp uge i16 %[[A1]], %[[B1]]
// CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
// CHECK: ret i1 %[[R]]