GCC 3.2
Franz Sirl
Franz.Sirl-kernel@lauterbach.com
Sat Jul 27 16:26:00 GMT 2002
On Samstag, 27. Juli 2002 00:50, Mark Mitchell wrote:
> I have created the GCC 3.2 branch.
>
> Once Jakub indicates that the ABI patchset has been checked in, I will
> start rolling the 3.2 prerelease.
Nice :-).
On the ABI patches, shouldn't __GXX_ABI_VERSION be bumped now? I would also
request this macro to become a generic one, so you can use it while
preprocessing C and assembly, often used for bridging code like eg. in
mozilla.
Another thing, Kevin Hendricks, one of the OpenOffice developers, sent me a
short test program with all the alignment stuff the OO people had to change
between 2.9x and 3.x. Would some of the C++ people take a close look at this
code? Note that the current ABI patches fixed already 2 problems the OO
people had to workaround with gcc-3.1, so maybe the others are ABI bugs as
well?
For example on powerpc-linux-gnu, with gcc-3.1.1:
[fsirl@entropy:~]$ g++ -O2 datatest.cxx -o datatest_nofix
[fsirl@entropy:~]$ ./datatest_nofix
> sizeof(AlignSize_Impl) = 16; __alignof__ (AlignSize_Impl) = 8
> sizeof(M) = 8; __alignof__ (M) = 4
> sizeof(N) = 8; __alignof__ (N) = 4
### sizeof(N) = 8 instead of expected 12!!!
### OFFSET_OF(N, p) = 6 instead of expected 8!!!
> sizeof(N2) = 12; __alignof__ (N2) = 4
> sizeof(O) = 16; __alignof__ (O) = 8
> sizeof(D) = 8; __alignof__ (D) = 4
> sizeof(C1) = 2; __alignof__ (C1) = 2
> sizeof(C2) = 8; __alignof__ (C2) = 4
> sizeof(C3) = 24; __alignof__ (C3) = 8
> sizeof(C4) = 32; __alignof__ (C4) = 8
### sizeof(C4) = 32 instead of expected 40!!!
### OFFSET_OF(C4, n4) = 20 instead of expected 24!!!
### OFFSET_OF(C4, d4) = 24 instead of expected 32!!!
> sizeof(C5) = 48; __alignof__ (C5) = 8
### sizeof(C5) = 48 instead of expected 56!!!
### OFFSET_OF(C5, n5) = 32 instead of expected 40!!!
### OFFSET_OF(C5, b5) = 40 instead of expected 48!!!
> sizeof(C6) = 64; __alignof__ (C6) = 8
### sizeof(C6) = 64 instead of expected 72!!!
### OFFSET_OF(C6, b6) = 56 instead of expected 64!!!
> sizeof(O2) = 24; __alignof__ (O2) = 8
> sizeof(Char3) = 3; __alignof__ (Char3) = 1
> sizeof(P) = 16; __alignof__ (P) = 8
### sizeof(P) = 16 instead of expected 24!!!
> sizeof(second) = 4; __alignof__ (second) = 4
And now with gcc-3.2:
[fsirl@entropy:~]$ ~/obj/gcc32/gcc/xgcc -B ~/obj/gcc32/gcc/ -O2 datatest.cxx
-o datatest_nofix
[fsirl@entropy:~]$ ./datatest_nofix
> sizeof(AlignSize_Impl) = 16; __alignof__ (AlignSize_Impl) = 8
> sizeof(M) = 8; __alignof__ (M) = 4
> sizeof(N) = 12; __alignof__ (N) = 4
> sizeof(N2) = 12; __alignof__ (N2) = 4
> sizeof(O) = 16; __alignof__ (O) = 8
> sizeof(D) = 8; __alignof__ (D) = 4
> sizeof(C1) = 2; __alignof__ (C1) = 2
> sizeof(C2) = 8; __alignof__ (C2) = 4
> sizeof(C3) = 24; __alignof__ (C3) = 8
> sizeof(C4) = 32; __alignof__ (C4) = 8
### sizeof(C4) = 32 instead of expected 40!!!
### OFFSET_OF(C4, n4) = 20 instead of expected 24!!!
### OFFSET_OF(C4, d4) = 24 instead of expected 32!!!
> sizeof(C5) = 48; __alignof__ (C5) = 8
### sizeof(C5) = 48 instead of expected 56!!!
### OFFSET_OF(C5, n5) = 32 instead of expected 40!!!
### OFFSET_OF(C5, b5) = 40 instead of expected 48!!!
> sizeof(C6) = 64; __alignof__ (C6) = 8
### sizeof(C6) = 64 instead of expected 72!!!
### OFFSET_OF(C6, b6) = 56 instead of expected 64!!!
> sizeof(O2) = 24; __alignof__ (O2) = 8
> sizeof(Char3) = 3; __alignof__ (Char3) = 1
> sizeof(P) = 24; __alignof__ (P) = 8
> sizeof(second) = 4; __alignof__ (second) = 4
If you add -DADJUST_ALIGN to the compile flags, the OO workarounds are turned
on the the testcase passes with gcc-3.1.1 and gcc-3.2.
Franz.
-------------- next part --------------
#include <stdlib.h>
#include <stdio.h>
typedef struct _Any
{
void * pType;
void * pData;
void * pReserved;
} uno_Any;
typedef _Any Any;
// Patching the gcc 3 incompatible alignment change for linux
// This pragma macro is appended to every first member of a struct,
// iff the struct inherits from a base struct and the first member
// of this structure is not a double or [unsigned] long long.
#ifdef ADJUST_ALIGN
#define CPPU_GCC3_ALIGN( base_struct ) __attribute__ ((aligned (__alignof__ (base_struct))))
#else
#define CPPU_GCC3_ALIGN( base_struct )
#endif
typedef enum {
My_BYTE,
MY_CHAR,
MY_INT,
MY_LONG,
MY_LONGLONG,
MY_FLOAT,
MY_DOUBLE
} TypeClass;
#if defined(__GNUC__) && defined(__linux__) && defined(__intel__)
#define MAX_ALIGNMENT_4
#endif
#define OFFSET_OF( s, m ) ((size_t)((char *)&((s *)16)->m -16))
#define BINTEST_VERIFY( c ) \
if (! (c)) { fprintf( stderr, "### binary compatibility test failed: " #c " [line %d]!!!\n", __LINE__ ); }
#define BINTEST_VERIFYOFFSET( s, m, n ) \
if (OFFSET_OF(s, m) != n) { fprintf( stderr, "### OFFSET_OF(" #s ", " #m ") = %d instead of expected %d!!!\n", OFFSET_OF(s, m), n ); }
#define BINTEST_VERIFYSIZE( s, n ) \
fprintf( stderr, "> sizeof(" #s ") = %d; __alignof__ (" #s ") = %d\n", sizeof(s), __alignof__ (s) ); \
if (sizeof(s) != n) { fprintf( stderr, "### sizeof(" #s ") = %d instead of expected %d!!!\n", sizeof(s), n ); }
struct C1
{
signed short n1;
};
struct C2 : public C1
{
signed long n2 CPPU_GCC3_ALIGN( C1 );
};
struct C3 : public C2
{
double d3;
signed long n3;
};
struct C4 : public C3
{
signed long n4 CPPU_GCC3_ALIGN( C3 );
double d4;
};
struct C5 : public C4
{
signed long long n5;
unsigned char b5;
};
struct C6 : public C1
{
C5 c6 CPPU_GCC3_ALIGN( C1 );
unsigned char b6;
};
struct D
{
signed short d;
signed long e;
};
struct E
{
unsigned char a;
unsigned char b;
unsigned char c;
signed short d;
signed long e;
};
struct M
{
signed long n;
signed short o;
};
struct N : public M
{
signed short p CPPU_GCC3_ALIGN( M );
};
struct N2
{
M m;
signed short p;
};
struct O : public M
{
double p;
};
struct O2 : public O
{
double p2;
};
struct P : public N
{
double p2;
};
struct empty
{
};
struct second : public empty
{
int a;
};
struct AlignSize_Impl
{
signed short nInt16;
double dDouble;
};
struct Char1
{
char c1;
};
struct Char2 : public Char1
{
char c2 CPPU_GCC3_ALIGN( Char1 );
};
struct Char3 : public Char2
{
char c3 CPPU_GCC3_ALIGN( Char2 );
};
struct Char4
{
Char3 chars;
char c;
};
class BinaryCompatible_Impl
{
public:
BinaryCompatible_Impl();
};
BinaryCompatible_Impl::BinaryCompatible_Impl()
{
#ifdef MAX_ALIGNMENT_4
// max alignment is 4
BINTEST_VERIFYOFFSET( AlignSize_Impl, dDouble, 4 );
BINTEST_VERIFYSIZE( AlignSize_Impl, 12 );
#else
// max alignment is 8
BINTEST_VERIFYOFFSET( AlignSize_Impl, dDouble, 8 );
BINTEST_VERIFYSIZE( AlignSize_Impl, 16 );
#endif
// enum
BINTEST_VERIFY( sizeof( TypeClass ) == sizeof( signed long ) );
// any
BINTEST_VERIFY( sizeof(void *) >= sizeof(signed long) );
BINTEST_VERIFY( sizeof( Any ) == sizeof( _Any ) );
BINTEST_VERIFY( sizeof( Any ) == sizeof( void * ) * 3 );
BINTEST_VERIFYOFFSET( Any, pType, 0 );
BINTEST_VERIFYOFFSET( Any, pData, 4 );
BINTEST_VERIFYOFFSET( Any, pReserved, 8 );
// struct
BINTEST_VERIFYSIZE( M, 8 );
BINTEST_VERIFYOFFSET( M, o, 4 );
BINTEST_VERIFYSIZE( N, 12 );
BINTEST_VERIFYOFFSET( N, p, 8 );
BINTEST_VERIFYSIZE( N2, 12 );
BINTEST_VERIFYOFFSET( N2, p, 8 );
BINTEST_VERIFYSIZE( O, 16 );
BINTEST_VERIFYSIZE( D, 8 );
BINTEST_VERIFYOFFSET( D, e, 4 );
BINTEST_VERIFYOFFSET( E, d, 4 );
BINTEST_VERIFYOFFSET( E, e, 8 );
BINTEST_VERIFYSIZE( C1, 2 );
BINTEST_VERIFYSIZE( C2, 8 );
BINTEST_VERIFYOFFSET( C2, n2, 4 );
#ifdef MAX_ALIGNMENT_4
BINTEST_VERIFYSIZE( C3, 20 );
BINTEST_VERIFYOFFSET( C3, d3, 8 );
BINTEST_VERIFYOFFSET( C3, n3, 16 );
BINTEST_VERIFYSIZE( C4, 32 );
BINTEST_VERIFYOFFSET( C4, n4, 20 );
BINTEST_VERIFYOFFSET( C4, d4, 24 );
BINTEST_VERIFYSIZE( C5, 44 );
BINTEST_VERIFYOFFSET( C5, n5, 32 );
BINTEST_VERIFYOFFSET( C5, b5, 40 );
BINTEST_VERIFYSIZE( C6, 52 );
BINTEST_VERIFYOFFSET( C6, c6, 4 );
BINTEST_VERIFYOFFSET( C6, b6, 48 );
#else
BINTEST_VERIFYSIZE( C3, 24 );
BINTEST_VERIFYOFFSET( C3, d3, 8 );
BINTEST_VERIFYOFFSET( C3, n3, 16 );
BINTEST_VERIFYSIZE( C4, 40 );
BINTEST_VERIFYOFFSET( C4, n4, 24 );
BINTEST_VERIFYOFFSET( C4, d4, 32 );
BINTEST_VERIFYSIZE( C5, 56 );
BINTEST_VERIFYOFFSET( C5, n5, 40 );
BINTEST_VERIFYOFFSET( C5, b5, 48 );
BINTEST_VERIFYSIZE( C6, 72 );
BINTEST_VERIFYOFFSET( C6, c6, 8 );
BINTEST_VERIFYOFFSET( C6, b6, 64 );
#endif
BINTEST_VERIFYSIZE( O2, 24 );
BINTEST_VERIFYOFFSET( O2, p2, 16 );
BINTEST_VERIFYSIZE( Char3, 3 );
BINTEST_VERIFYOFFSET( Char4, c, 3 );
#ifdef MAX_ALIGNMENT_4
// max alignment is 4
BINTEST_VERIFYSIZE( P, 20 );
#else
// alignment of P is 8, because of P[] ...
BINTEST_VERIFYSIZE( P, 24 );
BINTEST_VERIFYSIZE( second, sizeof( int ) );
#endif
}
static BinaryCompatible_Impl aTest;
int main ()
{
exit(0);
}
More information about the Gcc
mailing list