Respect endianness correctly in CheckEnums test suite

src/tools/compiletest/src/common.rs

@@ -459,6 +459,10 @@ impl Config {
         self.target_cfg().endian == Endian::Big
     }
 
+    pub fn is_little_endian(&self) -> bool {
+        self.target_cfg().endian == Endian::Little
+    }
+
     pub fn get_pointer_width(&self) -> u32 {
         *&self.target_cfg().pointer_width
     }

src/tools/compiletest/src/directive-list.rs

@@ -58,6 +58,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "ignore-elf",
     "ignore-emscripten",
     "ignore-endian-big",
+    "ignore-endian-little",
     "ignore-enzyme",
     "ignore-freebsd",
     "ignore-fuchsia",

src/tools/compiletest/src/directives/cfg.rs

@@ -205,6 +205,11 @@ fn parse_cfg_name_directive<'a>(
         condition: config.is_big_endian(),
         message: "on big-endian targets",
     }
+    condition! {
+        name: "endian-little",
+        condition: config.is_little_endian(),
+        message: "on little-endian targets",
+    }
     condition! {
         name: format!("stage{}", config.stage).as_str(),
         allowed_names: &["stage0", "stage1", "stage2"],

src/tools/compiletest/src/directives/tests.rs

@@ -689,6 +689,22 @@ fn is_big_endian() {
     }
 }
 
+#[test]
+fn is_little_endian() {
+    let endians = [
+        ("x86_64-unknown-linux-gnu", true),
+        ("bpfeb-unknown-none", false),
+        ("m68k-unknown-linux-gnu", false),
+        ("aarch64_be-unknown-linux-gnu", false),
+        ("powerpc64-unknown-linux-gnu", false),
+    ];
+    for (target, is_little) in endians {
+        let config = cfg().target(target).build();
+        assert_eq!(config.is_little_endian(), is_little, "{target} {is_little}");
+        assert_eq!(check_ignore(&config, "//@ ignore-endian-little"), is_little);
+    }
+}
+
 #[test]
 fn pointer_width() {
     let widths = [

tests/ui/mir/enum/convert_non_enum_break_big_endian.rs

@@ -0,0 +1,22 @@
+//@ run-pass
+//@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// little endian.
+//@ ignore-endian-little
+
+#[allow(dead_code)]
+#[repr(u32)]
+enum Foo {
+    A,
+    B,
+}
+
+#[allow(dead_code)]
+struct Bar {
+    a: u16,
+    b: u16,
+}
+
+fn main() {
+    let _val: Foo = unsafe { std::mem::transmute::<_, Foo>(Bar { a: 0, b: 1 }) };
+}

tests/ui/mir/enum/convert_non_enum_break.rs → tests/ui/mir/enum/convert_non_enum_break_little_endian.rs

@@ -1,5 +1,8 @@
 //@ run-fail
 //@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// big endian.
+//@ ignore-endian-big
 //@ error-pattern: trying to construct an enum from an invalid value 0x10000
 
 #[allow(dead_code)]

tests/ui/mir/enum/convert_non_enum_ok_big_endian.rs

@@ -0,0 +1,23 @@
+//@ run-fail
+//@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// little endian.
+//@ ignore-endian-little
+//@ error-pattern: trying to construct an enum from an invalid value
+
+#[allow(dead_code)]
+#[repr(u32)]
+enum Foo {
+    A,
+    B,
+}
+
+#[allow(dead_code)]
+struct Bar {
+    a: u16,
+    b: u16,
+}
+
+fn main() {
+    let _val: Foo = unsafe { std::mem::transmute::<_, Foo>(Bar { a: 1, b: 0 }) };
+}

tests/ui/mir/enum/convert_non_enum_ok.rs → tests/ui/mir/enum/convert_non_enum_ok_little_endian.rs

@@ -1,5 +1,8 @@
 //@ run-pass
 //@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// big endian.
+//@ ignore-endian-big
 
 #[allow(dead_code)]
 #[repr(u32)]

tests/ui/mir/enum/niche_option_tuple_break_big_endian.rs

@@ -0,0 +1,22 @@
+//@ run-pass
+//@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// big endian.
+//@ ignore-endian-little
+
+#[allow(dead_code)]
+enum Foo {
+    A,
+    B,
+}
+
+#[allow(dead_code)]
+struct Bar {
+    a: usize,
+    b: usize,
+}
+
+fn main() {
+    let _val: Option<(usize, Foo)> =
+        unsafe { std::mem::transmute::<_, Option<(usize, Foo)>>(Bar { a: 3, b: 3 }) };
+}

tests/ui/mir/enum/niche_option_tuple_break.rs → tests/ui/mir/enum/niche_option_tuple_break_little_endian.rs

@@ -1,5 +1,8 @@
 //@ run-fail
 //@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// big endian.
+//@ ignore-endian-big
 //@ error-pattern: trying to construct an enum from an invalid value 0x3
 
 #[allow(dead_code)]

tests/ui/mir/enum/with_niche_int_break_big_endian.rs

@@ -0,0 +1,23 @@
+//@ run-pass
+//@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// little endian.
+//@ ignore-endian-little
+
+#[allow(dead_code)]
+#[repr(u16)]
+enum Mix {
+    A,
+    B(u16),
+}
+
+#[allow(dead_code)]
+enum Nested {
+    C(Mix),
+    D,
+    E,
+}
+
+fn main() {
+    let _val: Nested = unsafe { std::mem::transmute::<u32, Nested>(4) };
+}

tests/ui/mir/enum/with_niche_int_break.rs → tests/ui/mir/enum/with_niche_int_break_little_endian.rs

@@ -1,6 +1,9 @@
 //@ run-fail
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value 0x4
+// This test depends on the endianess and has a different behavior on
+// big endian.
+//@ ignore-endian-big
 
 #[allow(dead_code)]
 #[repr(u16)]