`__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.