Add a pre-codegen test

Author: saethlin

tests/mir-opt/pre-codegen/derived_partialeq.cmp_has_float.PreCodegen.after.mir

@@ -0,0 +1,51 @@
+// MIR for `cmp_has_float` after PreCodegen
+
+fn cmp_has_float(_1: &HasFloat, _2: &HasFloat) -> bool {
+    debug a => _1;
+    debug b => _2;
+    let mut _0: bool;
+    scope 1 (inlined std::cmp::impls::<impl PartialEq for &HasFloat>::eq) {
+        scope 2 (inlined <HasFloat as PartialEq>::eq) {
+            let mut _3: f32;
+            let mut _4: f32;
+            let mut _5: bool;
+            let mut _6: u32;
+            let mut _7: u32;
+        }
+    }
+
+    bb0: {
+        StorageLive(_5);
+        StorageLive(_3);
+        _3 = copy ((*_1).0: f32);
+        StorageLive(_4);
+        _4 = copy ((*_2).0: f32);
+        _5 = Eq(move _3, move _4);
+        switchInt(move _5) -> [0: bb1, otherwise: bb2];
+    }
+
+    bb1: {
+        StorageDead(_4);
+        StorageDead(_3);
+        _0 = const false;
+        goto -> bb3;
+    }
+
+    bb2: {
+        StorageDead(_4);
+        StorageDead(_3);
+        StorageLive(_6);
+        _6 = copy ((*_1).1: u32);
+        StorageLive(_7);
+        _7 = copy ((*_2).1: u32);
+        _0 = Eq(move _6, move _7);
+        StorageDead(_7);
+        StorageDead(_6);
+        goto -> bb3;
+    }
+
+    bb3: {
+        StorageDead(_5);
+        return;
+    }
+}

tests/mir-opt/pre-codegen/derived_partialeq.cmp_has_padding.PreCodegen.after.mir

@@ -0,0 +1,51 @@
+// MIR for `cmp_has_padding` after PreCodegen
+
+fn cmp_has_padding(_1: &HasPadding, _2: &HasPadding) -> bool {
+    debug a => _1;
+    debug b => _2;
+    let mut _0: bool;
+    scope 1 (inlined std::cmp::impls::<impl PartialEq for &HasPadding>::eq) {
+        scope 2 (inlined <HasPadding as PartialEq>::eq) {
+            let mut _3: u8;
+            let mut _4: u8;
+            let mut _5: bool;
+            let mut _6: u16;
+            let mut _7: u16;
+        }
+    }
+
+    bb0: {
+        StorageLive(_5);
+        StorageLive(_3);
+        _3 = copy ((*_1).0: u8);
+        StorageLive(_4);
+        _4 = copy ((*_2).0: u8);
+        _5 = Eq(move _3, move _4);
+        switchInt(move _5) -> [0: bb1, otherwise: bb2];
+    }
+
+    bb1: {
+        StorageDead(_4);
+        StorageDead(_3);
+        _0 = const false;
+        goto -> bb3;
+    }
+
+    bb2: {
+        StorageDead(_4);
+        StorageDead(_3);
+        StorageLive(_6);
+        _6 = copy ((*_1).1: u16);
+        StorageLive(_7);
+        _7 = copy ((*_2).1: u16);
+        _0 = Eq(move _6, move _7);
+        StorageDead(_7);
+        StorageDead(_6);
+        goto -> bb3;
+    }
+
+    bb3: {
+        StorageDead(_5);
+        return;
+    }
+}

tests/mir-opt/pre-codegen/derived_partialeq.cmp_no_padding.PreCodegen.after.mir

@@ -0,0 +1,19 @@
+// MIR for `cmp_no_padding` after PreCodegen
+
+fn cmp_no_padding(_1: &NoPadding, _2: &NoPadding) -> bool {
+    debug a => _1;
+    debug b => _2;
+    let mut _0: bool;
+    scope 1 (inlined std::cmp::impls::<impl PartialEq for &NoPadding>::eq) {
+        scope 2 (inlined <NoPadding as PartialEq>::eq) {
+        }
+    }
+
+    bb0: {
+        _0 = compare_bitwise::<NoPadding>(move _1, move _2) -> [return: bb1, unwind unreachable];
+    }
+
+    bb1: {
+        return;
+    }
+}

tests/mir-opt/pre-codegen/derived_partialeq.cmp_no_padding_after_opt.PreCodegen.after.mir

@@ -0,0 +1,19 @@
+// MIR for `cmp_no_padding_after_opt` after PreCodegen
+
+fn cmp_no_padding_after_opt(_1: &NoPaddingAfterOpt, _2: &NoPaddingAfterOpt) -> bool {
+    debug a => _1;
+    debug b => _2;
+    let mut _0: bool;
+    scope 1 (inlined std::cmp::impls::<impl PartialEq for &NoPaddingAfterOpt>::eq) {
+        scope 2 (inlined <NoPaddingAfterOpt as PartialEq>::eq) {
+        }
+    }
+
+    bb0: {
+        _0 = compare_bitwise::<NoPaddingAfterOpt>(move _1, move _2) -> [return: bb1, unwind unreachable];
+    }
+
+    bb1: {
+        return;
+    }
+}

tests/mir-opt/pre-codegen/derived_partialeq.cmp_no_padding_array.PreCodegen.after.mir

@@ -0,0 +1,23 @@
+// MIR for `cmp_no_padding_array` after PreCodegen
+
+fn cmp_no_padding_array(_1: &NoPaddingArray, _2: &NoPaddingArray) -> bool {
+    debug a => _1;
+    debug b => _2;
+    let mut _0: bool;
+    scope 1 (inlined std::cmp::impls::<impl PartialEq for &NoPaddingArray>::eq) {
+        scope 2 (inlined <NoPaddingArray as PartialEq>::eq) {
+            scope 3 (inlined array::equality::<impl PartialEq for [u16; 2]>::eq) {
+                scope 4 (inlined <u16 as array::equality::SpecArrayEq<u16, 2>>::spec_eq) {
+                }
+            }
+        }
+    }
+
+    bb0: {
+        _0 = compare_bitwise::<NoPaddingArray>(move _1, move _2) -> [return: bb1, unwind unreachable];
+    }
+
+    bb1: {
+        return;
+    }
+}

tests/mir-opt/pre-codegen/derived_partialeq.rs

@@ -0,0 +1,69 @@
+//@ compile-flags: -O -Zmir-opt-level=2 -Cdebuginfo=0
+
+#![crate_type = "lib"]
+
+#[derive(PartialEq)]
+pub struct NoPadding {
+    x: u16,
+    y: u16,
+}
+
+// CHECK-LABEL: fn cmp_no_padding(
+fn cmp_no_padding(a: &NoPadding, b: &NoPadding) -> bool {
+    // CHECK: compare_bitwise::<NoPadding>(
+    a == b
+}
+// EMIT_MIR derived_partialeq.cmp_no_padding.PreCodegen.after.mir
+
+#[derive(PartialEq)]
+pub struct NoPaddingArray {
+    x: [u16; 2],
+    y: u16,
+}
+
+// CHECK-LABEL: fn cmp_no_padding_array(
+fn cmp_no_padding_array(a: &NoPaddingArray, b: &NoPaddingArray) -> bool {
+    // CHECK: compare_bitwise::<NoPaddingArray>(
+    a == b
+}
+// EMIT_MIR derived_partialeq.cmp_no_padding_array.PreCodegen.after.mir
+
+#[derive(PartialEq)]
+pub struct NoPaddingAfterOpt {
+    x: u8,
+    y: u16,
+    z: u8,
+}
+
+// CHECK-LABEL: fn cmp_no_padding_after_opt(
+fn cmp_no_padding_after_opt(a: &NoPaddingAfterOpt, b: &NoPaddingAfterOpt) -> bool {
+    // CHECK: compare_bitwise::<NoPaddingAfterOpt>(
+    a == b
+}
+// EMIT_MIR derived_partialeq.cmp_no_padding_after_opt.PreCodegen.after.mir
+
+#[derive(PartialEq)]
+pub struct HasPadding {
+    x: u8,
+    y: u16,
+}
+
+// CHECK-LABEL: fn cmp_has_padding(
+fn cmp_has_padding(a: &HasPadding, b: &HasPadding) -> bool {
+    // CHECK-NOT: compare_bitwise
+    a == b
+}
+// EMIT_MIR derived_partialeq.cmp_has_padding.PreCodegen.after.mir
+
+#[derive(PartialEq)]
+pub struct HasFloat {
+    x: f32,
+    y: u32,
+}
+
+// CHECK-LABEL: fn cmp_has_float(
+fn cmp_has_float(a: &HasFloat, b: &HasFloat) -> bool {
+    // CHECK-NOT: compare_bitwise
+    a == b
+}
+// EMIT_MIR derived_partialeq.cmp_has_float.PreCodegen.after.mir