loongarch64-unknown-linux-gnu `extern "C"` ABI violates repr(transparent) on unions

[RalfJung]

The types (i32, f32) and MaybeUninit<T> do not have the same ABI, as demonstrated by this testcase:

#![feature(rustc_attrs)]

type T = (i32, f32);

#[rustc_abi(debug)]
extern "C" fn test1(_x: T) {}

#[rustc_abi(debug)]
extern "C" fn test2(_x: std::mem::MaybeUninit<T>) {}

fn main() {}

The first is

                   mode: Cast(
                       CastTarget {
                           prefix: [
                               Some(
                                   Reg {
                                       kind: Integer,
                                       size: Size(4 bytes),
                                   },
                               ),
                               None,
                               None,
                               None,
                               None,
                               None,
                               None,
                               None,
                           ],
                           rest: Uniform {
                               unit: Reg {
                                   kind: Float,
                                   size: Size(4 bytes),
                               },
                               total: Size(4 bytes),
                           },
                           attrs: ArgAttributes {
                               regular: (empty),
                               arg_ext: None,
                               pointee_size: Size(0 bytes),
                               pointee_align: None,
                           },
                       },
                       false,
                   ),

The second is

                   mode: Cast(
                       CastTarget {
                           prefix: [
                               None,
                               None,
                               None,
                               None,
                               None,
                               None,
                               None,
                               None,
                           ],
                           rest: Uniform {
                               unit: Reg {
                                   kind: Integer,
                                   size: Size(8 bytes),
                               },
                               total: Size(8 bytes),
                           },
                           attrs: ArgAttributes {
                               regular: (empty),
                               arg_ext: None,
                               pointee_size: Size(0 bytes),
                               pointee_align: None,
                           },
                       },
                       false,
                   ),

RISC-V had the exact same issue, so the fix will likely also be the same.

I couldn't find an O-loongarch label.

Cc'ing the people listed on https://doc.rust-lang.org/rustc/platform-support/loongarch-linux.html
@hev @xiangzhai @zhaixiaojuan @xen0n

[RalfJung]

The loongarch ABI seems to be pretty much exactly like the RISC-V ABI, so I wonder if it would make sense to share some of that code so that bugs like this only have to be fixed once.

[xen0n]

Thanks for the report! The LoongArch ABI is indeed closely modeled after that of RISC-V, so yeah the fix should look similar. @hev should be able to follow up tomorrow.

[apiraino]

WG-prioritization assigning priority (Zulip discussion).

@rustbot label -I-prioritize +P-medium

[hev]

@xen0n I don't think you meant to tag me. Don't know much about rust.

[xen0n]

@xen0n I don't think you meant to tag me. Don't know much about rust.

Doh, the correct Rust/LoongArch person is @heiher who happens to have another handle of "hev". Sorry for the noise!

[heiher]

Thanks for your pointing out.

I don't think the types (i32, f32) and MaybeUninit<(i32, f32) would have the same ABI on LoongArch64. The key point of the problem is that MaybeUninit is a union, which is different from a struct:

#[repr(transparent)]
pub union MaybeUninit<T> {
    /* private fields */
}

For types (i32, f32) and #[repr(transparent)] struct X((i32, f32)), they are same ABI:

#![feature(rustc_attrs)]

type T = (i32, f32);

#[repr(transparent)]
struct X(T);

#[rustc_abi(debug)]
extern "C" fn test1(_x: T) {}

#[rustc_abi(debug)]
extern "C" fn test2(_x: X) {}

fn main() {}

The first is:

                   mode: Cast(
                       CastTarget {
                           prefix: [
                               Some(
                                   Reg {
                                       kind: Integer,
                                       size: Size(4 bytes),
                                   },
                               ),
                               None,
                               None,
                               None,
                               None,
                               None,
                               None,
                               None,
                           ],
                           rest: Uniform {
                               unit: Reg {
                                   kind: Float,
                                   size: Size(4 bytes),
                               },
                               total: Size(4 bytes),
                           },
                           attrs: ArgAttributes {
                               regular: (empty),
                               arg_ext: None,
                               pointee_size: Size(0 bytes),
                               pointee_align: None,
                           },
                       },
                       false,
                   ),

The second is:

                   mode: Cast(
                       CastTarget {
                           prefix: [
                               Some(
                                   Reg {
                                       kind: Integer,
                                       size: Size(4 bytes),
                                   },
                               ),
                               None,
                               None,
                               None,
                               None,
                               None,
                               None,
                               None,
                           ],
                           rest: Uniform {
                               unit: Reg {
                                   kind: Float,
                                   size: Size(4 bytes),
                               },
                               total: Size(4 bytes),
                           },
                           attrs: ArgAttributes {
                               regular: (empty),
                               arg_ext: None,
                               pointee_size: Size(0 bytes),
                               pointee_align: None,
                           },
                       },
                       false,
                   ),

And it seems that the current ABI of MaybeUninit<(i32, f32) is the same as that of C language on LoongArch64:

struct T {
    int i;
    float f;
};

union X {
    struct T v;
};

void test1(struct T x) {}
void test2(union X y) {}

int main (int argc, char *argv[])
{
    struct T t;
    union X x;

    t.i = 6339;
    t.f = 6338.0;

    x.v.i = 6339;
    x.v.f = 6338.0;

    test1(t);
    test2(x);

    return 0;
}

The first is:

(gdb) i r r4
r4             0x18c3              6339
(gdb) i r f0
f0             {f = 0x45c61000, d = 0x3b031b0145c61000} {f = 6338, d = 1.9754611757025394e-24}

The second is:

(gdb) i r r4
r4             0x45c61000000018c3  5027723626191788227 // {float = 0x45c61000, int = 0x000018c3 }
(gdb) i r f0
f0             {f = 0x45c61000, d = 0x3b031b0145c61000} {f = 6338, d = 1.9754611757025394e-24}