Add Three Codegen Tests

Author: veera-sivarajan

tests/assembly/indexing-with-bools-no-redundant-instructions.rs

@@ -0,0 +1,31 @@
+//@ assembly-output: emit-asm
+//@ only-x86_64
+//@ ignore-sgx Test incompatible with LVI mitigations
+//@ compile-flags: -C opt-level=3
+//! Ensure that indexing a slice with `bool` does not
+//! generate any redundant `jmp` and `and` instructions.
+//! Discovered in issue #123216.
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+fn f(a: u32, b: bool, c: bool, d: &mut [u128; 2]) {
+    // CHECK-LABEL: f:
+    // CHECK: testl  %esi, %esi
+    // CHECK: je
+    // CHECK: xorb   %dl, %dil
+    // CHECK: orb    $1, (%rcx)
+    // CHECK: movzbl %dil, %eax
+    // CHECK: andl   $1, %eax
+    // CHECK: shll   $4, %eax
+    // CHECK: orb    $1, (%rcx,%rax)
+    // CHECK-NOT:     jmp
+    // CHECK-NOT:     andl %dil, $1
+    // CHECK: retq
+    let mut a = a & 1 != 0;
+    if b {
+        a ^= c;
+        d[0] |= 1;
+    }
+    d[a as usize] |= 1;
+}

tests/codegen/nonzero-type-not-zero-on-get.rs

@@ -0,0 +1,20 @@
+//@ compile-flags: -C opt-level=3
+//! Ensure that `.get()` on `std::num::NonZero*` types do not
+//! check for zero equivalency.
+//! Discovered in issue #49572.
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn foo(x: std::num::NonZeroU32) -> bool {
+    // CHECK-LABEL: @foo(
+    // CHECK: ret i1 true
+    x.get() != 0
+}
+
+#[no_mangle]
+pub fn bar(x: std::num::NonZeroI64) -> bool {
+    // CHECK-LABEL: @bar(
+    // CHECK: ret i1 true
+    x.get() != 0
+}

tests/codegen/unreachable-branch-not-generated.rs

@@ -0,0 +1,39 @@
+//@ compile-flags: -C opt-level=3
+//! Ensure that matching on `x % 5` generates an unreachable
+//! branch for values greater than 4.
+//! Discovered in issue #93514.
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub unsafe fn parse0(x: u32) -> u32 {
+    // CHECK-LABEL: i32 @parse0(
+    // CHECK:    [[_2:%.*]] = urem
+    // CHECK-NEXT:    switch i32 [[_2]], label %[[DEFAULT_UNREACHABLE1:.*]] [
+    // CHECK-NEXT:      i32 0
+    // CHECK-NEXT:      i32 1
+    // CHECK-NEXT:      i32 2
+    // CHECK-NEXT:      i32 3
+    // CHECK-NEXT:      i32 4
+    // CHECK-NEXT:    ]
+    // CHECK:       [[DEFAULT_UNREACHABLE1]]:
+    // CHECK-NEXT:    unreachable
+    // CHECK:    ret i32
+    match x % 5 {
+        0 => f1(x),
+        1 => f2(x),
+        2 => f3(x),
+        3 => f4(x),
+        4 => f5(x),
+        _ => eliminate_me(),
+    }
+}
+
+extern "Rust" {
+    fn eliminate_me() -> u32;
+    fn f1(x: u32) -> u32;
+    fn f2(x: u32) -> u32;
+    fn f3(x: u32) -> u32;
+    fn f4(x: u32) -> u32;
+    fn f5(x: u32) -> u32;
+}