rust/tests/codegen/riscv-abi/riscv64-lp64d-abi.rs

//
// compile-flags: -C no-prepopulate-passes
// only-riscv64
// only-linux
#![crate_type = "lib"]

// CHECK: define void @f_fpr_tracking(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, i8 zeroext %i)
#[no_mangle]
pub extern "C" fn f_fpr_tracking(
    a: f64,
    b: f64,
    c: f64,
    d: f64,
    e: f64,
    f: f64,
    g: f64,
    h: f64,
    i: u8,
) {
}

#[repr(C)]
pub struct Double {
    f: f64,
}

#[repr(C)]
pub struct DoubleDouble {
    f: f64,
    g: f64,
}

#[repr(C)]
pub struct DoubleFloat {
    f: f64,
    g: f32,
}

// CHECK: define void @f_double_s_arg(double %0)
#[no_mangle]
pub extern "C" fn f_double_s_arg(a: Double) {}

// CHECK: define double @f_ret_double_s()
#[no_mangle]
pub extern "C" fn f_ret_double_s() -> Double {
    Double { f: 1. }
}

// CHECK: define void @f_double_double_s_arg({ double, double } %0)
#[no_mangle]
pub extern "C" fn f_double_double_s_arg(a: DoubleDouble) {}

// CHECK: define { double, double } @f_ret_double_double_s()
#[no_mangle]
pub extern "C" fn f_ret_double_double_s() -> DoubleDouble {
    DoubleDouble { f: 1., g: 2. }
}

// CHECK: define void @f_double_float_s_arg({ double, float } %0)
#[no_mangle]
pub extern "C" fn f_double_float_s_arg(a: DoubleFloat) {}

// CHECK: define { double, float } @f_ret_double_float_s()
#[no_mangle]
pub extern "C" fn f_ret_double_float_s() -> DoubleFloat {
    DoubleFloat { f: 1., g: 2. }
}

// CHECK: define void @f_double_double_s_arg_insufficient_fprs(double %0, double %1, double %2, double %3, double %4, double %5, double %6, [2 x i64] %7)
#[no_mangle]
pub extern "C" fn f_double_double_s_arg_insufficient_fprs(
    a: f64,
    b: f64,
    c: f64,
    d: f64,
    e: f64,
    f: f64,
    g: f64,
    h: DoubleDouble,
) {
}

#[repr(C)]
pub struct DoubleInt8 {
    f: f64,
    i: i8,
}

#[repr(C)]
pub struct DoubleUInt8 {
    f: f64,
    i: u8,
}

#[repr(C)]
pub struct DoubleInt32 {
    f: f64,
    i: i32,
}

#[repr(C)]
pub struct DoubleInt64 {
    f: f64,
    i: i64,
}

// CHECK: define void @f_double_int8_s_arg({ double, i8 } %0)
#[no_mangle]
pub extern "C" fn f_double_int8_s_arg(a: DoubleInt8) {}

// CHECK: define { double, i8 } @f_ret_double_int8_s()
#[no_mangle]
pub extern "C" fn f_ret_double_int8_s() -> DoubleInt8 {
    DoubleInt8 { f: 1., i: 2 }
}

// CHECK: define void @f_double_int32_s_arg({ double, i32 } %0)
#[no_mangle]
pub extern "C" fn f_double_int32_s_arg(a: DoubleInt32) {}

// CHECK: define { double, i32 } @f_ret_double_int32_s()
#[no_mangle]
pub extern "C" fn f_ret_double_int32_s() -> DoubleInt32 {
    DoubleInt32 { f: 1., i: 2 }
}

// CHECK: define void @f_double_uint8_s_arg({ double, i8 } %0)
#[no_mangle]
pub extern "C" fn f_double_uint8_s_arg(a: DoubleUInt8) {}

// CHECK: define { double, i8 } @f_ret_double_uint8_s()
#[no_mangle]
pub extern "C" fn f_ret_double_uint8_s() -> DoubleUInt8 {
    DoubleUInt8 { f: 1., i: 2 }
}

// CHECK: define void @f_double_int64_s_arg({ double, i64 } %0)
#[no_mangle]
pub extern "C" fn f_double_int64_s_arg(a: DoubleInt64) {}

// CHECK: define { double, i64 } @f_ret_double_int64_s()
#[no_mangle]
pub extern "C" fn f_ret_double_int64_s() -> DoubleInt64 {
    DoubleInt64 { f: 1., i: 2 }
}

// CHECK: define void @f_double_int8_s_arg_insufficient_gprs(i32 signext %a, i32 signext %b, i32 signext %c, i32 signext %d, i32 signext %e, i32 signext %f, i32 signext %g, i32 signext %h, [2 x i64] %0)
#[no_mangle]
pub extern "C" fn f_double_int8_s_arg_insufficient_gprs(
    a: i32,
    b: i32,
    c: i32,
    d: i32,
    e: i32,
    f: i32,
    g: i32,
    h: i32,
    i: DoubleInt8,
) {
}

// CHECK: define void @f_struct_double_int8_insufficient_fprs(float %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, [2 x i64] %8)
#[no_mangle]
pub extern "C" fn f_struct_double_int8_insufficient_fprs(
    a: f32,
    b: f64,
    c: f64,
    d: f64,
    e: f64,
    f: f64,
    g: f64,
    h: f64,
    i: DoubleInt8,
) {
}

#[repr(C)]
pub struct DoubleArr1 {
    a: [f64; 1],
}

// CHECK: define void @f_doublearr1_s_arg(double %0)
#[no_mangle]
pub extern "C" fn f_doublearr1_s_arg(a: DoubleArr1) {}

// CHECK: define double @f_ret_doublearr1_s()
#[no_mangle]
pub extern "C" fn f_ret_doublearr1_s() -> DoubleArr1 {
    DoubleArr1 { a: [1.] }
}

#[repr(C)]
pub struct DoubleArr2 {
    a: [f64; 2],
}

// CHECK: define void @f_doublearr2_s_arg({ double, double } %0)
#[no_mangle]
pub extern "C" fn f_doublearr2_s_arg(a: DoubleArr2) {}

// CHECK: define { double, double } @f_ret_doublearr2_s()
#[no_mangle]
pub extern "C" fn f_ret_doublearr2_s() -> DoubleArr2 {
    DoubleArr2 { a: [1., 2.] }
}

#[repr(C)]
pub struct Tricky1 {
    f: [f64; 1],
}

#[repr(C)]
pub struct DoubleArr2Tricky1 {
    g: [Tricky1; 2],
}

// CHECK: define void @f_doublearr2_tricky1_s_arg({ double, double } %0)
#[no_mangle]
pub extern "C" fn f_doublearr2_tricky1_s_arg(a: DoubleArr2Tricky1) {}

// CHECK: define { double, double } @f_ret_doublearr2_tricky1_s()
#[no_mangle]
pub extern "C" fn f_ret_doublearr2_tricky1_s() -> DoubleArr2Tricky1 {
    DoubleArr2Tricky1 { g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
}

#[repr(C)]
pub struct EmptyStruct {}

#[repr(C)]
pub struct DoubleArr2Tricky2 {
    s: EmptyStruct,
    g: [Tricky1; 2],
}

// CHECK: define void @f_doublearr2_tricky2_s_arg({ double, double } %0)
#[no_mangle]
pub extern "C" fn f_doublearr2_tricky2_s_arg(a: DoubleArr2Tricky2) {}

// CHECK: define { double, double } @f_ret_doublearr2_tricky2_s()
#[no_mangle]
pub extern "C" fn f_ret_doublearr2_tricky2_s() -> DoubleArr2Tricky2 {
    DoubleArr2Tricky2 { s: EmptyStruct {}, g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
}

#[repr(C)]
pub struct IntDoubleInt {
    a: i32,
    b: f64,
    c: i32,
}

// CHECK: define void @f_int_double_int_s_arg(%IntDoubleInt* {{.*}}%a)
#[no_mangle]
pub extern "C" fn f_int_double_int_s_arg(a: IntDoubleInt) {}

// CHECK: define void @f_ret_int_double_int_s(%IntDoubleInt* {{.*}}sret
#[no_mangle]
pub extern "C" fn f_ret_int_double_int_s() -> IntDoubleInt {
    IntDoubleInt { a: 1, b: 2., c: 3 }
}

#[repr(C)]
pub struct CharCharDouble {
    a: u8,
    b: u8,
    c: f64,
}

// CHECK: define void @f_char_char_double_s_arg([2 x i64] %0)
#[no_mangle]
pub extern "C" fn f_char_char_double_s_arg(a: CharCharDouble) {}

// CHECK: define [2 x i64] @f_ret_char_char_double_s()
#[no_mangle]
pub extern "C" fn f_ret_char_char_double_s() -> CharCharDouble {
    CharCharDouble { a: 1, b: 2, c: 3. }
}

#[repr(C)]
pub union DoubleU {
    a: f64,
}

// CHECK: define void @f_double_u_arg(i64 %0)
#[no_mangle]
pub extern "C" fn f_double_u_arg(a: DoubleU) {}

// CHECK: define i64 @f_ret_double_u()
#[no_mangle]
pub extern "C" fn f_ret_double_u() -> DoubleU {
    unsafe { DoubleU { a: 1. } }
}