align-byval.rs

// ignore-tidy-linelength
//@ revisions:m68k x86_64-linux x86_64-windows i686-linux i686-windows

//@[m68k] compile-flags: --target m68k-unknown-linux-gnu
//@[m68k] needs-llvm-components: m68k
//@[x86_64-linux] compile-flags: --target x86_64-unknown-linux-gnu
//@[x86_64-linux] needs-llvm-components: x86
//@[x86_64-windows] compile-flags: --target x86_64-pc-windows-msvc
//@[x86_64-windows] needs-llvm-components: x86
//@[i686-linux] compile-flags: --target i686-unknown-linux-gnu
//@[i686-linux] needs-llvm-components: x86
//@[i686-windows] compile-flags: --target i686-pc-windows-msvc
//@[i686-windows] needs-llvm-components: x86

// Tests that `byval` alignment is properly specified (#80127).
// The only targets that use `byval` are m68k, x86-64, and x86.
// Note also that Windows mandates a by-ref ABI here, so it does not use byval.

#![feature(no_core, lang_items)]
#![crate_type = "lib"]
#![no_std]
#![no_core]

#[lang = "sized"]
trait Sized {}
#[lang = "freeze"]
trait Freeze {}
#[lang = "copy"]
trait Copy {}

impl Copy for i32 {}
impl Copy for i64 {}

// This struct can be represented as a pair, so it exercises the OperandValue::Pair
// codepath in `codegen_argument`.
#[repr(C)]
pub struct NaturalAlign1 {
    a: i8,
    b: i8,
}

// This struct cannot be represented as an immediate, so it exercises the OperandValue::Ref
// codepath in `codegen_argument`.
#[repr(C)]
pub struct NaturalAlign2 {
    a: [i16; 16],
    b: i16,
}

#[repr(C)]
#[repr(align(4))]
pub struct ForceAlign4 {
    a: [i8; 16],
    b: i8,
}

// On i686-windows, this is passed on stack using `byval`
#[repr(C)]
pub struct NaturalAlign8 {
    a: i64,
    b: i64,
    c: i64,
}

// On i686-windows, this is passed by reference (because alignment is >4 and requested/forced),
// even though it has the exact same layout as `NaturalAlign8`!
#[repr(C)]
#[repr(align(8))]
pub struct ForceAlign8 {
    a: i64,
    b: i64,
    c: i64,
}

// On i686-windows, this is passed on stack, because requested alignment is <=4.
#[repr(C)]
#[repr(align(4))]
pub struct LowerFA8 {
    a: i64,
    b: i64,
    c: i64,
}

// On i686-windows, this is passed by reference, because it contains a field with
// requested/forced alignment.
#[repr(C)]
pub struct WrappedFA8 {
    a: ForceAlign8,
}

// On i686-windows, this has the same ABI as ForceAlign8, i.e. passed by reference.
#[repr(transparent)]
pub struct TransparentFA8 {
    _0: (),
    a: ForceAlign8,
}

#[repr(C)]
#[repr(align(16))]
pub struct ForceAlign16 {
    a: [i32; 16],
    b: i8,
}

// CHECK-LABEL: @call_na1
#[no_mangle]
pub unsafe fn call_na1(x: NaturalAlign1) {
    // CHECK: start:

    // m68k: [[ALLOCA:%[a-z0-9+]]] = alloca [2 x i8], align 1
    // m68k: call void @natural_align_1({{.*}}byval([2 x i8]) align 1{{.*}} [[ALLOCA]])

    // x86_64-linux: call void @natural_align_1(i16

    // x86_64-windows: call void @natural_align_1(i16

    // i686-linux: [[ALLOCA:%[a-z0-9+]]] = alloca [2 x i8], align 4
    // i686-linux: call void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}} [[ALLOCA]])

    // i686-windows: [[ALLOCA:%[a-z0-9+]]] = alloca [2 x i8], align 4
    // i686-windows: call void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}} [[ALLOCA]])
    natural_align_1(x);
}

// CHECK-LABEL: @call_na2
#[no_mangle]
pub unsafe fn call_na2(x: NaturalAlign2) {
    // CHECK: start:

    // m68k-NEXT: call void @natural_align_2
    // x86_64-linux-NEXT: call void @natural_align_2
    // x86_64-windows-NEXT: call void @natural_align_2

    // i686-linux: [[ALLOCA:%[0-9]+]] = alloca [34 x i8], align 4
    // i686-linux: call void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}} [[ALLOCA]])

    // i686-windows: [[ALLOCA:%[0-9]+]] = alloca [34 x i8], align 4
    // i686-windows: call void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}} [[ALLOCA]])
    natural_align_2(x);
}

// CHECK-LABEL: @call_fa4
#[no_mangle]
pub unsafe fn call_fa4(x: ForceAlign4) {
    // CHECK: start:
    // CHECK-NEXT: call void @force_align_4
    force_align_4(x);
}

// CHECK-LABEL: @call_na8
#[no_mangle]
pub unsafe fn call_na8(x: NaturalAlign8) {
    // CHECK: start:
    // CHECK-NEXT: call void @natural_align_8
    natural_align_8(x);
}

// CHECK-LABEL: @call_fa8
#[no_mangle]
pub unsafe fn call_fa8(x: ForceAlign8) {
    // CHECK: start:
    // CHECK-NEXT: call void @force_align_8
    force_align_8(x);
}

// CHECK-LABEL: @call_lfa8
#[no_mangle]
pub unsafe fn call_lfa8(x: LowerFA8) {
    // CHECK: start:
    // CHECK-NEXT: call void @lower_fa8
    lower_fa8(x);
}

// CHECK-LABEL: @call_wfa8
#[no_mangle]
pub unsafe fn call_wfa8(x: WrappedFA8) {
    // CHECK: start:
    // CHECK-NEXT: call void @wrapped_fa8
    wrapped_fa8(x);
}

// CHECK-LABEL: @call_tfa8
#[no_mangle]
pub unsafe fn call_tfa8(x: TransparentFA8) {
    // CHECK: start:
    // CHECK-NEXT: call void @transparent_fa8
    transparent_fa8(x);
}

// CHECK-LABEL: @call_fa16
#[no_mangle]
pub unsafe fn call_fa16(x: ForceAlign16) {
    // CHECK: start:
    // CHECK-NEXT: call void @force_align_16
    force_align_16(x);
}

extern "C" {
    // m68k: declare void @natural_align_1({{.*}}byval([2 x i8]) align 1{{.*}})

    // x86_64-linux: declare void @natural_align_1(i16)

    // x86_64-windows: declare void @natural_align_1(i16)

    // i686-linux: declare void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}})

    // i686-windows: declare void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}})
    fn natural_align_1(x: NaturalAlign1);

    // m68k: declare void @natural_align_2({{.*}}byval([34 x i8]) align 2{{.*}})

    // x86_64-linux: declare void @natural_align_2({{.*}}byval([34 x i8]) align 2{{.*}})

    // x86_64-windows: declare void @natural_align_2(
    // x86_64-windows-NOT: byval
    // x86_64-windows-SAME: align 2{{.*}})

    // i686-linux: declare void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}})

    // i686-windows: declare void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}})
    fn natural_align_2(x: NaturalAlign2);

    // m68k: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})

    // x86_64-linux: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})

    // x86_64-windows: declare void @force_align_4(
    // x86_64-windows-NOT: byval
    // x86_64-windows-SAME: align 4{{.*}})

    // i686-linux: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})

    // i686-windows: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
    fn force_align_4(x: ForceAlign4);

    // m68k: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})

    // x86_64-linux: declare void @natural_align_8({{.*}}byval([24 x i8]) align 8{{.*}})

    // x86_64-windows: declare void @natural_align_8(
    // x86_64-windows-NOT: byval
    // x86_64-windows-SAME: align 8{{.*}})

    // i686-linux: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})

    // i686-windows: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
    fn natural_align_8(x: NaturalAlign8);

    // m68k: declare void @force_align_8({{.*}}byval([24 x i8]) align 8{{.*}})

    // x86_64-linux: declare void @force_align_8({{.*}}byval([24 x i8]) align 8{{.*}})

    // x86_64-windows: declare void @force_align_8(
    // x86_64-windows-NOT: byval
    // x86_64-windows-SAME: align 8{{.*}})

    // i686-linux: declare void @force_align_8({{.*}}byval([24 x i8]) align 4{{.*}})

    // i686-windows: declare void @force_align_8(
    // i686-windows-NOT: byval
    // i686-windows-SAME: align 8{{.*}})
    fn force_align_8(x: ForceAlign8);

    // m68k: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})

    // x86_64-linux: declare void @lower_fa8({{.*}}byval([24 x i8]) align 8{{.*}})

    // x86_64-windows: declare void @lower_fa8(
    // x86_64-windows-NOT: byval
    // x86_64-windows-SAME: align 8{{.*}})

    // i686-linux: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})

    // i686-windows: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
    fn lower_fa8(x: LowerFA8);

    // m68k: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 8{{.*}})

    // x86_64-linux: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 8{{.*}})

    // x86_64-windows: declare void @wrapped_fa8(
    // x86_64-windows-NOT: byval
    // x86_64-windows-SAME: align 8{{.*}})

    // i686-linux: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 4{{.*}})

    // i686-windows: declare void @wrapped_fa8(
    // i686-windows-NOT: byval
    // i686-windows-SAME: align 8{{.*}})
    fn wrapped_fa8(x: WrappedFA8);

    // m68k: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 8{{.*}})

    // x86_64-linux: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 8{{.*}})

    // x86_64-windows: declare void @transparent_fa8(
    // x86_64-windows-NOT: byval
    // x86_64-windows-SAME: align 8{{.*}})

    // i686-linux: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 4{{.*}})

    // i686-windows: declare void @transparent_fa8(
    // i686-windows-NOT: byval
    // i686-windows-SAME: align 8{{.*}})
    fn transparent_fa8(x: TransparentFA8);

    // m68k: declare void @force_align_16({{.*}}byval([80 x i8]) align 16{{.*}})

    // x86_64-linux: declare void @force_align_16({{.*}}byval([80 x i8]) align 16{{.*}})

    // x86_64-windows: declare void @force_align_16(
    // x86_64-windows-NOT: byval
    // x86_64-windows-SAME: align 16{{.*}})

    // i686-linux: declare void @force_align_16({{.*}}byval([80 x i8]) align 4{{.*}})

    // i686-windows: declare void @force_align_16(
    // i686-windows-NOT: byval
    // i686-windows-SAME: align 16{{.*}})
    fn force_align_16(x: ForceAlign16);
}