align_of for small structs does not give the actual alignment of pointers

[huonw]

#[derive(Debug, Copy)]
struct Foo {
    x: u8,
}

fn main() {
    let f = Foo { x: 1 };
    let vec = vec![f, f, f, f, f];

    println!("size: {}", std::mem::size_of::<Foo>());
    println!("align: {}", std::mem::align_of::<Foo>());
    println!("alignment offset: {}", (&vec[2] as *const _ as usize) % std::mem::align_of::<Foo>());
}

It prints size: 1 align: 8 alignment offset: 2. I would expect that every value of type T is aligned to align_of::<T>() (i.e. the % should always give 0).

On x86-64, this applies to anything with alignment < 8, including #[repr(packed)] structs.

I'm not sure it's a bug, but it does seem rather confusing.

Also, NB. this means size_of < align_of.

(min_align_of acts more like I might expect.)

[Diggsey]

Comment from the source:

// We use the preferred alignment as the default alignment for a type. This
// appears to be what clang migrated towards as well:
//
// http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20110725/044411.html

Unfortunately, the link does not give details of why that choice was made, as it's a surprising one to say the least.

[pnkfelix]

polish issue for 1.0 milestone, P-high.

[brson]

Hard part is figuring out the correct implementation.

[tbu-]

I don't see the bug here, min_align_of is the hard limit that must be adhered to, and align_of gives a suggestion. It would be very bad to take an alignment of 8 for a 1-byte struct in a vector.

[huonw]

@tbu- that's the point, the conveniently named "align_of" is a dangerous value to use in many situations, while min_align_of is conservative and always correct (although may be less efficient than necessary in a few scenarios).

E.g. C++11's alignof acts like min_align_of, this prints 1:

#include<cstdio>

struct foo { char x; };
int main() {
    printf("%lu\n", alignof(struct foo));
}

[lilyball]

I've always been confused by what the heck align_of is. I know the module is already marked stable, but I really feel like it should be renamed to preferred_align_of and min_align_of be changed to align_of. Every single time I've ever had a reason to look at alignment, minimum alignment turns out to be what I was interested in. May as well make it the default function.

Similarly, the documentation on what is currently align_of claims that this is the alignment that, if adhered to, guarantees the type will function properly. Surely that's actually the minimum alignment. The docs should be changed instead to explain that this is the preferred alignment, and hopefully give a short explanation as to what the heck that actually means.

[nikomatsakis]

I think sizeof and alignof (the defaults) should do whatever C++ does.