I notice that gcc does not follow the 32-bit ABI for the x86, in that it forces
the stack alignment to 16 bytes rather than the ABI-required 4 bytes. This is
a problem when interacting with compilers that are ABI-compliant.
So, I threw the -mpreferred-stack-boundary=2 on gcc/gfortran/g77 to restore ABI
compliance, and then I notice that gfortran/g77 generates double precision
arrays that are not aligned to 8-byte boundaries, which breaks pretty much all
interoperability as well (and also means you will get cache splits all the
time, and so decrease your performance). The -malign-double flag does not fix
this. So I now have the choice of not interoperating due to ABI violation, or
not interoperating with other compilers due to lack of data alignment.
I read the gcc manual on this point, and it talks like you have to choose:
either you force the stack to always be aligned to 16-byte boundary, or gcc is
unable to guarantee alignment for any stack value. However, this is a false
choice: given an unaligned stack it is trivial for a function to force a
particular alignment (eg., 16-byte) for some values it is storing on the stack.
I can provide code and pointers, if that is helpful.
So, I think it is a bad idea for gcc to violate the ABI for something that is
trivial to do without violating the ABI: not only do you rule out
interoperability by not following the ABI, but even in strict gcc code, you
lose a lot of performance when people need to follow the ABI.
However, if the preferred stack trick worked, I could work around, but since it
actually makes arrays not be aligned to a multiple of their base size, I cannot
find a workaround for this misfeature. Any ideas?
Thanks,
Clint
--
Summary: Gcc misaligns arrays when stack is forced follow the
x8632 ABI
Product: gcc
Version: unknown
Status: UNCONFIRMED
Severity: normal
Priority: P3
Component: fortran
AssignedTo: unassigned at gcc dot gnu dot org
ReportedBy: whaley at cs dot utsa dot edu
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38496
