Set attrs.pointee_align when constructing function ABI

Fixes rust-lang#80127

This will require additional testing to see if the old FIXME still
applies

compiler/rustc_target/src/abi/call/mod.rs

@@ -449,9 +449,7 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
  // program-invisible so can't possibly capture
  attrs.set(ArgAttribute::NoAlias).set(ArgAttribute::NoCapture).set(ArgAttribute::NonNull);
  attrs.pointee_size = self.layout.size;
- // FIXME(eddyb) We should be doing this, but at least on
- // i686-pc-windows-msvc, it results in wrong stack offsets.
- // attrs.pointee_align = Some(self.layout.align.abi);
+ attrs.pointee_align = Some(self.layout.align.abi);
 
  let extra_attrs = self.layout.is_unsized().then_some(ArgAttributes::new());
 

src/test/codegen/function-arguments.rs

@@ -54,7 +54,7 @@ pub fn mutable_unsafe_borrow(_: &mut UnsafeInner) {
 pub fn mutable_borrow(_: &mut i32) {
 }
 
-// CHECK: @indirect_struct(%S* noalias nocapture dereferenceable(32) %_1)
+// CHECK: @indirect_struct(%S* noalias nocapture align 4 dereferenceable(32) %_1)
 #[no_mangle]
 pub fn indirect_struct(_: S) {
 }
@@ -73,7 +73,7 @@ pub fn _box(x: Box<i32>) -> Box<i32> {
  x
 }
 
-// CHECK: @struct_return(%S* noalias nocapture sret dereferenceable(32){{( %0)?}})
+// CHECK: @struct_return(%S* noalias nocapture sret align 4 dereferenceable(32){{( %0)?}})
 #[no_mangle]
 pub fn struct_return() -> S {
  S {

src/test/codegen/issue-80127-arg-align.rs

@@ -0,0 +1,63 @@
+// ignore-tidy-linelength
+// only-x86_64
+
+// Regression test for issue 80127
+// Tests that we properly propagate apply a `#[repr(align)]` attribute on a struct
+// to external function definitions involving parameters with that struct type
+
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Debug, Copy, Clone)]
+pub struct bar {
+ pub a: ::std::os::raw::c_ulong,
+ pub b: ::std::os::raw::c_ulong,
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct baz {
+ pub a: bool,
+ pub b: ::std::os::raw::c_uint,
+}
+
+extern "C" {
+ // CHECK: declare i32 @foo_func(i8*, i8*, i8*, i64, i1 zeroext, i64, i8*, %bar* noalias nocapture byval(%bar) align 16 dereferenceable(16), i8*, i8*, i8*, i8*, i8*)
+ pub fn foo_func(
+ a: *mut ::std::os::raw::c_void,
+ b: *mut ::std::os::raw::c_void,
+ c: *const ::std::os::raw::c_char,
+ d: ::std::os::raw::c_ulong,
+ e: bool,
+ f: baz,
+ g: *mut ::std::os::raw::c_void,
+ h: bar,
+ i: *mut ::std::os::raw::c_void,
+ j: *mut ::std::os::raw::c_void,
+ k: *mut ::std::os::raw::c_void,
+ l: *mut ::std::os::raw::c_void,
+ m: *const ::std::os::raw::c_char,
+ ) -> ::std::os::raw::c_int;
+}
+
+fn main() {
+ let f = baz { a: true, b: 67 };
+ let h = bar { a: 0, b: 99 };
+ let m = std::ffi::CString::new("Hello, world").unwrap();
+ unsafe {
+ foo_func(
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ 12,
+ true,
+ f,
+ std::ptr::null_mut(),
+ h,
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ m.as_ptr(),
+ )
+ };
+}

src/test/codegen/packed.rs

@@ -52,7 +52,7 @@ pub struct BigPacked2 {
 #[no_mangle]
 pub fn call_pkd1(f: fn() -> Array) -> BigPacked1 {
 // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca %Array
-// CHECK: call void %{{.*}}(%Array* noalias nocapture sret dereferenceable(32) [[ALLOCA]])
+// CHECK: call void %{{.*}}(%Array* noalias nocapture sret align 4 dereferenceable(32) [[ALLOCA]])
 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 1 %{{.*}}, i8* align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false)
  // check that calls whose destination is a field of a packed struct
  // go through an alloca rather than calling the function with an
@@ -64,7 +64,7 @@ pub fn call_pkd1(f: fn() -> Array) -> BigPacked1 {
 #[no_mangle]
 pub fn call_pkd2(f: fn() -> Array) -> BigPacked2 {
 // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca %Array
-// CHECK: call void %{{.*}}(%Array* noalias nocapture sret dereferenceable(32) [[ALLOCA]])
+// CHECK: call void %{{.*}}(%Array* noalias nocapture sret align 4 dereferenceable(32) [[ALLOCA]])
 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 2 %{{.*}}, i8* align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false)
  // check that calls whose destination is a field of a packed struct
  // go through an alloca rather than calling the function with an