tests: Test for newly corrected alignments on AIX

Author: workingjubilee

tests/ui/layout/reprc-power-alignment.rs

@@ -1,192 +1,226 @@
-//@ check-pass
 //@ compile-flags: --target powerpc64-ibm-aix
 //@ needs-llvm-components: powerpc
 //@ add-minicore
 //@ ignore-backends: gcc
-#![feature(no_core)]
+#![feature(no_core, rustc_attrs)]
 #![no_core]
 #![no_std]
 #![crate_type = "lib"]
 
 extern crate minicore;
 use minicore::*;
 
-#[warn(uses_power_alignment)]
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct Floats {
+pub struct Floats { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     a: f64,
     b: u8,
-    c: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    c: f64,
     d: f32,
 }
 
-pub struct Floats2 {
+#[rustc_layout(align)]
+pub struct Floats2 { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     a: f64,
     b: u32,
     c: f64,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct Floats3 {
+pub struct Floats3 { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     a: f32,
     b: f32,
     c: i64,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct Floats4 {
+pub struct Floats4 { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     a: u64,
     b: u32,
     c: f32,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct Floats5 {
+pub struct Floats5 { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     a: f32,
-    b: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    b: f64,
     c: f32,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct FloatAgg1 {
+pub struct FloatAgg1 { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     x: Floats,
-    y: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    y: f64,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct FloatAgg2 {
+pub struct FloatAgg2 { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     x: i64,
-    y: Floats, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    y: Floats,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct FloatAgg3 {
+pub struct FloatAgg3 { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     x: FloatAgg1,
-    // NOTE: the "power" alignment rule is infectious to nested struct fields.
-    y: FloatAgg2, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
-    z: FloatAgg2, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    y: FloatAgg2,
+    z: FloatAgg2,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct FloatAgg4 {
+pub struct FloatAgg4 { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     x: FloatAgg1,
-    y: FloatAgg2, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    y: FloatAgg2,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct FloatAgg5 {
+pub struct FloatAgg5 { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     x: FloatAgg1,
-    y: FloatAgg2, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
-    z: FloatAgg3, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    y: FloatAgg2,
+    z: FloatAgg3,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct FloatAgg6 {
+pub struct FloatAgg6 { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     x: i64,
-    y: Floats, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    y: Floats,
     z: u8,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct FloatAgg7 {
+pub struct FloatAgg7 { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     x: i64,
-    y: Floats, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    y: Floats,
     z: u8,
     zz: f32,
 }
 
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct A {
+pub struct A { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     d: f64,
 }
+
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct B {
+pub struct B { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     a: A,
     f: f32,
-    d: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    d: f64,
 }
+
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct C {
+pub struct C { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     c: u8,
-    b: B, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    b: B,
 }
+
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct D {
+pub struct D { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     x: f64,
 }
+
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct E {
+pub struct E { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     x: i32,
-    d: D, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    d: D,
 }
+
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct F {
+pub struct F { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     a: u8,
-    b: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    b: f64,
 }
+
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct G {
+pub struct G { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     a: u8,
     b: u8,
-    c: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    c: f64,
     d: f32,
-    e: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    e: f64,
 }
-// Should not warn on #[repr(packed)].
+
+#[rustc_layout(align)]
 #[repr(packed)]
-pub struct H {
+pub struct H { //~ ERROR: align: AbiAlign { abi: Align(1 bytes) }
     a: u8,
     b: u8,
     c: f64,
     d: f32,
     e: f64,
 }
+
+#[rustc_layout(align)]
 #[repr(C, packed)]
-pub struct I {
+pub struct I { //~ ERROR: align: AbiAlign { abi: Align(1 bytes) }
     a: u8,
     b: u8,
     c: f64,
     d: f32,
     e: f64,
 }
+
+
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct J {
+pub struct J { //~ ERROR: align: AbiAlign { abi: Align(1 bytes) }
     a: u8,
     b: I,
 }
-// The lint also ignores diagnosing #[repr(align(n))].
+
+#[rustc_layout(align)]
 #[repr(C, align(8))]
-pub struct K {
+pub struct K { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     a: u8,
     b: u8,
     c: f64,
     d: f32,
     e: f64,
 }
+
+#[rustc_layout(align)]
 #[repr(C)]
-pub struct L {
+pub struct L { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     a: u8,
     b: K,
 }
+
+#[rustc_layout(align)]
 #[repr(C, align(8))]
-pub struct M {
+pub struct M { //~ ERROR: align: AbiAlign { abi: Align(8 bytes) }
     a: u8,
     b: K,
     c: L,
 }
 
-// The lint ignores unions
+#[rustc_layout(align)]
 #[repr(C)]
-pub union Union {
+pub union Union { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     a: f64,
     b: u8,
     c: f64,
     d: f32,
 }
 
-// The lint ignores enums
+
+#[rustc_layout(align)]
 #[repr(C)]
-pub enum Enum {
+pub enum Enum { //~ ERROR: align: AbiAlign { abi: Align(4 bytes) }
     A { a: f64, b: u8, c: f64, d: f32 },
     B,
 }