Even more optimal Ord implementation for integers

src/libcore/cmp.rs

@@ -638,6 +638,22 @@ impl PartialOrd for Ordering {
  fn partial_cmp(&self, other: &Ordering) -> Option<Ordering> {
  (*self as i32).partial_cmp(&(*other as i32))
  }
+ #[inline]
+ fn lt(&self, other: &Ordering) -> bool {
+ (*self as i32).lt(&(*other as i32))
+ }
+ #[inline]
+ fn le(&self, other: &Ordering) -> bool {
+ (*self as i32).le(&(*other as i32))
+ }
+ #[inline]
+ fn gt(&self, other: &Ordering) -> bool {
+ (*self as i32).gt(&(*other as i32))
+ }
+ #[inline]
+ fn ge(&self, other: &Ordering) -> bool {
+ (*self as i32).ge(&(*other as i32))
+ }
 }
 
 /// Trait for values that can be compared for a sort-order.
@@ -1012,11 +1028,14 @@ mod impls {
  impl Ord for $t {
  #[inline]
  fn cmp(&self, other: &$t) -> Ordering {
- // The order here is important to generate more optimal assembly.
- // See <https://github.com/rust-lang/rust/issues/63758> for more info.
- if *self < *other { Less }
- else if *self == *other { Equal }
- else { Greater }
+ // Like in `signum`, this approach allows the result to be
+ // computed with a simpler subtraction instead of needing a
+ // conditional move (which, as of 2018 x86 hardware, are never
+ // predicted), for a small cycles & code size improvement.
+ // See <https://github.com/rust-lang/rust/pull/64082> for more info.
+ let diff = (*self > *other) as i8 - (*self < *other) as i8;
+ // Sound because Ordering's three variants are {-1, 0, 1}.
+ unsafe { crate::mem::transmute(diff) }
  }
  }
  )*)

src/test/codegen/integer-cmp.rs

@@ -1,5 +1,5 @@
 // This is test for more optimal Ord implementation for integers.
-// See <https://github.com/rust-lang/rust/issues/63758> for more info.
+// See <https://github.com/rust-lang/rust/pull/64082> for more info.
 
 // compile-flags: -C opt-level=3
 
@@ -10,19 +10,59 @@ use std::cmp::Ordering;
 // CHECK-LABEL: @cmp_signed
 #[no_mangle]
 pub fn cmp_signed(a: i64, b: i64) -> Ordering {
+// CHECK: icmp sgt
+// CHECK: zext i1
 // CHECK: icmp slt
-// CHECK: icmp ne
 // CHECK: zext i1
-// CHECK: select i1
+// CHECK: sub nsw
+// CHECK-NOT: select
  a.cmp(&b)
 }
 
 // CHECK-LABEL: @cmp_unsigned
 #[no_mangle]
 pub fn cmp_unsigned(a: u32, b: u32) -> Ordering {
+// CHECK: icmp ugt
+// CHECK: zext i1
 // CHECK: icmp ult
-// CHECK: icmp ne
 // CHECK: zext i1
-// CHECK: select i1
+// CHECK: sub nsw
+// CHECK-NOT: select
  a.cmp(&b)
 }
+
+// CHECK-LABEL: @cmp_signed_lt
+#[no_mangle]
+pub fn cmp_signed_lt(a: &i64, b: &i64) -> bool {
+// CHECK: icmp slt
+// CHECK-NOT: sub
+// CHECK-NOT: select
+ Ord::cmp(a, b) < Ordering::Equal
+}
+
+// CHECK-LABEL: @cmp_unsigned_lt
+#[no_mangle]
+pub fn cmp_unsigned_lt(a: &u32, b: &u32) -> bool {
+// CHECK: icmp ult
+// CHECK-NOT: sub
+// CHECK-NOT: select
+ Ord::cmp(a, b) < Ordering::Equal
+}
+
+// CHECK-LABEL: @cmp_signed_eq
+#[no_mangle]
+pub fn cmp_signed_eq(a: &i64, b: &i64) -> bool {
+// CHECK: icmp eq
+// CHECK-NOT: sub
+// CHECK-NOT: select
+ Ord::cmp(a, b) == Ordering::Equal
+}
+
+// CHECK-LABEL: @cmp_unsigned_eq
+#[no_mangle]
+pub fn cmp_unsigned_eq(a: &u32, b: &u32) -> bool {
+// CHECK: icmp eq
+// CHECK-NOT: sub
+// CHECK-NOT: select
+ Ord::cmp(a, b) == Ordering::Equal
+}