`__attribute__((aligned(...))` dropped from variable declarations

[jrmuizel]

__attribute__(( aligned (16) )) float FOO[4] = {4, 4, 4, 4};

is translated as

#[no_mangle]
pub static mut FOO: [libc::c_float; 4] =
    [4 as libc::c_int as libc::c_float, 4 as libc::c_int as libc::c_float,
     4 as libc::c_int as libc::c_float, 4 as libc::c_int as libc::c_float];

Because the alignment requirement is dropped it can cause problems for SIMD code.

[ahomescu]

The problem is that afaik Rust doesn't have an equivalent of the original C code, i.e., the #[repr(align(16))] attribute on statics/consts/variables of any kind. The closest thing we could do is define a newtype for the type of the variable and add the alignment attribute on that, but then we'd have to keep track of that everywhere and dereference/re-wrap it as needed.

The transpiled code would look something like:

#[repr(C, align(16))]
pub struct FooType([libc::c_float; 4]);
#[no_mangle]
pub static mut FOO: FooType = FooType(
    [4 as libc::c_int as libc::c_float, 4 as libc::c_int as libc::c_float,
     4 as libc::c_int as libc::c_float, 4 as libc::c_int as libc::c_float]);

[folkertdev]

I'm looking at code like this

#include <stdint.h>

uint32_t read32(const void* ptr) {
    typedef __attribute__((aligned(1))) uint32_t unaligned_uint32;
    return *((const unaligned_uint32*)ptr);
}

and here a repr(packed(1)) should work I think? The alignment really means this is a different type. Of course the idiomatic thing would be a read_unaligned but I don't really see how that could be done.

btw alignment on statics is in the works, see rust-lang/rfcs#3806

[folkertdev]

A better idea: clang must actually know the alignment of the read. (or at least, llvm will, so the information must be there somewhere). Is there some way that could be communicated so that c2rust could use read_unaligned/write_unaligned if the alignment of a dereference is less than the alignment of the type?

cc @kkysen you seem to have done a lot of the c2rust-ast-exporter stuff which is, I'm assuming, where this information would be available and has to be passed through.

---

edit: I did get this to work, here is a wip commit 6851240

It produces this rust code. The cast isn't really needed any more, I suppose, but at least it no longer just dereferences a misaligned pointer.

pub type __uint32_t = std::ffi::c_uint;
pub type uint32_t = __uint32_t;
pub type unaligned_uint32 = uint32_t;
#[no_mangle]
pub unsafe extern "C" fn read32(mut ptr: *const std::ffi::c_void) -> uint32_t {
    return (ptr as *const unaligned_uint32).read_unaligned();
}

[kkysen]

cc @kkysen you seem to have done a lot of the c2rust-ast-exporter stuff which is, I'm assuming, where this information would be available and has to be passed through.

Oh, not really. I've helped fix some bugs there, but I didn't write most of it nor am I super familiar with it.

[ahomescu]

I think #225 is related to this.

After a minute of searching I found https://docs.rs/aligned. We could update c2rust to wrap types and values in aligned::Aligned for the most common alignments.

[ahomescu]

Alternatively, we could just use the native support in the language. Taking inventory of all the different language items where this is needed:

• Structure definitions - already supported by #[repr(align(N))]
• Function alignment - added recently as #[rustc_align(N)] in Tracking Issue for #[align(...)] on function items (fn_align) rust-lang/rust#82232; there seem to be some issues with the syntax so it might change.
• Statics/globals - coming soon as #[rustc_static_align(N)] in Tracking Issue for static_align - alignment on static items rust-lang/rust#146177
• Local variables - TBD
• Structure fields - TBD, should be covered by RFC: Add an attribute for raising the alignment of various items rust-lang/rfcs#3806 at some point.
• Pointer reads/writes - nothing special required from Rust, c2rust needs to detect this and emit read_unaligned.

Feel free to let me know if I missed anything.