If some architecture traps on unaligned access, then the compiler can and should simply generate the correct code so that it loads the integer piece by piece instead. Load multiple integers and shift and mask away the irrelevant bits, done. This is exactly what modern architectures already do in hardware. Works, it's just a little slower.

This is exactly what the compilers do if you use a packed structure to access unaligned data. Works everywhere, as expected. Compilers have always known what to do, they just weren't doing it. C standard says no.

The fact is the standard is garbage and the first thing every C programmer should learn is that they can and should ignore it. There is never any reason to wonder what the standard is supposed to do. The only thing that matters is what compilers actually do.

▲

bluGill an hour ago | parent | next [-]

The pointer might be something you forced. The compiler needs to do the right thing but if you set the pointer to an unaligned address because you have information on the hardware you can get this undefined situation with nothing the compiler can do about it.

▲

matheusmoreira an hour ago | parent [-]

Any reason the hardware pointer can't be accessed via the packed structure?

https://news.ycombinator.com/item?id=48205371

▲

saagarjha 25 minutes ago | parent | next [-]

The same reason you probably aren’t adding manual alignment fixes to your code?

	▲	matheusmoreira 7 minutes ago \| parent [-]
		No reason at all, then. Because I am manually dealing with alignment in my code. Wrote a lisp, its bytes type supports reading and writing integers at arbitrary locations within the buffer. Test suite exercises aligned and unaligned memory access for every C integer type. Also wrote my own mem* functions, dealing with alignment in those was certainly a fun exercise. It wasn't necessary, I just wanted the performance benefits.

▲

bluGill 31 minutes ago | parent | prev [-]

however you certainly can do that. The point of unaligned is the hardware can't load it from a single memory location in one address. It needs two accesses. And in that time, the value of one of the two addresses that the hardware has to load can change.

I would hope you're not so stupid as to design hardware that relies on this, but the fact is it certainly is possible for someone to do that. And if you do that, there is nothing that the compiler or the standard can do. It can't be done correctly

	▲	matheusmoreira 17 minutes ago \| parent [-]
		Yeah, the unaligned accesses aren't going to be atomic unless the hardware supports it. > And in that time, the value of one of the two addresses that the hardware has to load can change. You mean volatile addresses that could spontaneously change in the middle of the reads? Like memory mapped I/O addresses? I would expect these to have stricter access requirements than arbitrary general purpose memory locations. > I would hope you're not so stupid as to design hardware that relies on this You and me both. > And if you do that, there is nothing that the compiler or the standard can do. It can't be done correctly Anything that does that is broken and terrible anyway. It really shouldn't contaminate language design. It's the sort of thing that compilers should be adding attributes for, rather than constraining the language to the point nothing works correctly and making us use attributes on everything to restore some sane baseline behavior.

▲

da-alex 44 minutes ago | parent | prev [-]

But if it's a pointer, the compiler doesn't know the alignment at compile time. Should the compiler insert an alignment check of every pointer access?

	▲	matheusmoreira 28 minutes ago \| parent [-]
		Compilers could add support for an unaligned attribute that we can apply to pointers. I'd prefer that to wrapping everything in a packed structure which is quite unsightly. Would have been better if correct behavior was the default while pointer alignment requirements were opt in, just like vector stuff. Nothing we can do about it now. I would hope the compiler is smart enough to figure out which accesses are aligned and unaligned on its own.