rust/tests/run-make/extern-fn-explicit-align/test.rs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

62 lines
1.2 KiB
Rust
Raw Normal View History

rustc_target: Add alignment to indirectly-passed by-value types, correcting the alignment of `byval` on x86 in the process. Commit 88e4d2c2918428d55e34cd57c11279ea839c8822 from five years ago removed support for alignment on indirectly-passed arguments because of problems with the `i686-pc-windows-msvc` target. Unfortunately, the `memcpy` optimizations I recently added to LLVM 16 depend on this to forward `memcpy`s. This commit attempts to fix the problems with `byval` parameters on that target and now correctly adds the `align` attribute. The problem is summarized in [this comment] by @eddyb. Briefly, 32-bit x86 has special alignment rules for `byval` parameters: for the most part, their alignment is forced to 4. This is not well-documented anywhere but in the Clang source. I looked at the logic in Clang `TargetInfo.cpp` and tried to replicate it here. The relevant methods in that file are `X86_32ABIInfo::getIndirectResult()` and `X86_32ABIInfo::getTypeStackAlignInBytes()`. The `align` parameter attribute for `byval` parameters in LLVM must match the platform ABI, or miscompilations will occur. Note that this doesn't use the approach suggested by eddyb, because I felt it was overkill to store the alignment in `on_stack` when special handling is really only needed for 32-bit x86. As a side effect, this should fix #80127, because it will make the `align` parameter attribute for `byval` parameters match the platform ABI on LLVM x86-64. [this comment]: https://github.com/rust-lang/rust/pull/80822#issuecomment-829985417
2022-10-31 22:38:40 -05:00
// Issue #80127: Passing structs via FFI should work with explicit alignment.
use std::ffi::CString;
use std::ptr::null_mut;
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(C)]
#[repr(align(16))]
pub struct TwoU64s {
pub a: u64,
pub b: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct BoolAndU32 {
pub a: bool,
pub b: u32,
}
#[link(name = "test", kind = "static")]
extern "C" {
fn many_args(
a: *mut (),
b: *mut (),
c: *const i8,
d: u64,
e: bool,
f: BoolAndU32,
g: *mut (),
h: TwoU64s,
i: *mut (),
j: *mut (),
k: *mut (),
l: *mut (),
m: *const i8,
) -> i32;
}
fn main() {
let two_u64s = TwoU64s { a: 1, b: 2 };
let bool_and_u32 = BoolAndU32 { a: true, b: 3 };
let string = CString::new("Hello world").unwrap();
unsafe {
many_args(
null_mut(),
null_mut(),
null_mut(),
4,
true,
bool_and_u32,
null_mut(),
two_u64s,
null_mut(),
null_mut(),
null_mut(),
null_mut(),
string.as_ptr(),
);
}
}