* g++.old-deja/g++.abi/align.C: New test.
* g++.old-deja/g++.abi/aggregates.C: Likewise.
* g++.old-deja/g++.abi/bitfields.C: Likewise.
From-SVN: r30769
+1999-12-02 Alex Samuel <samuel@codesourcery.com>
+
+ * g++.old-deja/g++.abi/align.C: New test.
+ * g++.old-deja/g++.abi/aggregates.C: Likewise.
+ * g++.old-deja/g++.abi/bitfields.C: Likewise.
+
1999-12-01 Richard Henderson <rth@cygnus.com>
* gcc.c-torture/execute/991201-1.c: New.
--- /dev/null
+// Skip if not target: i?86-*-linux*
+// Special g++ Options: -malign-double
+// Origin: Alex Samuel <samuel@codesourcery.com>
+
+/* Test the data layout of C aggregates by checking aggregate size and
+ alignment and field offsets for compliance with the IA-64 ABI. */
+
+template<typename T>
+inline unsigned
+alignmentof ()
+{
+ struct S
+ {
+ char start_;
+ T object_;
+ };
+
+ return (unsigned) & ((S *) 0)->object_;
+}
+
+/* Computes the alignment, in bytes, of TYPE. */
+
+#define alignof(type) (alignmentof<type> ())
+
+/* Computes the offset of FIELD in AGGREGATE. */
+
+#define offsetof(aggregate, field) \
+ ((unsigned) (& ((aggregate*) 0)->field))
+
+
+/* Structs S1, S2, S3, S4, and union U5 are taken from Intel, "IA-64
+ Software Conventions and Runtime Architecture Guide", version of
+ August 1999. */
+
+struct S1
+{
+ char c;
+};
+
+struct S2
+{
+ char c;
+ char d;
+ short s;
+ int n;
+};
+
+struct S3
+{
+ char c;
+ short s;
+};
+
+struct S4
+{
+ char c;
+ double d;
+ short s;
+};
+
+union U5
+{
+ char c;
+ short s;
+ int j;
+};
+
+
+
+int
+main ()
+{
+ if (sizeof (struct S1) != 1)
+ return 1;
+ if (alignof (struct S1) != 1)
+ return 2;
+ if (offsetof (struct S1, c) != 0)
+ return 3;
+
+ if (sizeof (struct S2) != 8)
+ return 4;
+ if (alignof (struct S2) != 4)
+ return 5;
+ if (offsetof (struct S2, c) != 0)
+ return 6;
+ if (offsetof (struct S2, d) != 1)
+ return 7;
+ if (offsetof (struct S2, s) != 2)
+ return 8;
+ if (offsetof (struct S2, n) != 4)
+ return 9;
+
+ if (sizeof (struct S3) != 4)
+ return 10;
+ if (alignof (struct S3) != 2)
+ return 11;
+ if (offsetof (struct S3, c) != 0)
+ return 12;
+ if (offsetof (struct S3, s) != 2)
+ return 13;
+
+ if (sizeof (struct S4) != 24)
+ return 14;
+ if (alignof (struct S4) != 8)
+ return 15;
+ if (offsetof (struct S4, c) != 0)
+ return 16;
+ if (offsetof (struct S4, d) != 8)
+ return 17;
+ if (offsetof (struct S4, s) != 16)
+ return 18;
+
+ if (sizeof (union U5) != 4)
+ return 19;
+ if (alignof (union U5) != 4)
+ return 20;
+ if (offsetof (union U5, c) != 0)
+ return 21;
+ if (offsetof (union U5, s) != 0)
+ return 22;
+ if (offsetof (union U5, j) != 0)
+ return 23;
+
+ return 0;
+}
--- /dev/null
+// Skip if not target: i?86-*-linux*
+// Special g++ Options: -malign-double
+// Origin: Alex Samuel <samuel@codesourcery.com>
+
+/* Test the size and alignment of fundamental C types for compliance
+ with the IA-64 ABI. */
+
+template<typename T>
+inline unsigned
+alignmentof ()
+{
+ struct S
+ {
+ char start_;
+ T object_;
+ };
+
+ return (unsigned) & ((S *) 0)->object_;
+}
+
+/* Computes the alignment, in bytes, of TYPE. */
+
+#define alignof(type) (alignmentof<type> ())
+
+int
+main ()
+{
+ if (sizeof (char) != 1)
+ return 1;
+ if (alignof (char) != 1)
+ return 2;
+ if (sizeof (signed char) != 1)
+ return 3;
+ if (alignof (signed char) != 1)
+ return 4;
+ if (sizeof (unsigned char) != 1)
+ return 5;
+ if (alignof (unsigned char) != 1)
+ return 6;
+ if (sizeof (short) != 2)
+ return 7;
+ if (alignof (short) != 2)
+ return 8;
+ if (sizeof (signed short) != 2)
+ return 9
+ if (alignof (signed short) != 2)
+ return 10;
+ if (sizeof (unsigned short) != 2)
+ return 11;
+ if (alignof (unsigned short) != 2)
+ return 12;
+ if (sizeof (int) != 4)
+ return 13;
+ if (alignof (int) != 4)
+ return 14;
+ if (sizeof (signed int) != 4)
+ return 15;
+ if (alignof (signed int) != 4)
+ return 16;
+ if (sizeof (unsigned int) != 4)
+ return 17;
+ if (alignof (unsigned int) != 4)
+ return 18;
+ if (sizeof (enum { a }) != 4)
+ return 19;
+ if (alignof (enum { a }) != 4)
+ return 20;
+#ifdef HAVE_IA64_TYPES
+ if (sizeof (__int64) != 8)
+ return 21;
+ if (alignof (__int64) != 8)
+ return 22;
+ if (sizeof (signed __int64) != 8)
+ return 23;
+ if (alignof (signed ___int64) != 8)
+ return 24;
+ if (sizeof (unsigned __int64) != 8)
+ return 25;
+ if (alignof (unsigned __int64) != 8)
+ return 26;
+ if (sizeof (__int128) != 16)
+ return 27;
+ if (alignof (__int128) != 16)
+ return 28;
+ if (sizeof (signed __int128) != 16)
+ return 29;
+ if (alignof (signed ___int128) != 16)
+ return 30;
+ if (sizeof (unsigned __int128) != 16)
+ return 31;
+ if (alignof (unsigned ___int128) != 16)
+ return 32;
+#endif /* HAVE_IA64_TYPES */
+ if (sizeof (void *) != 4)
+ return 33;
+ if (alignof (pointer) != 4)
+ return 34;
+ if (sizeof (void (*) ()) != 4)
+ return 35;
+ if (alignof (void (*) ()) != 4)
+ return 36;
+ if (sizeof (float) != 4)
+ return 37;
+ if (alignof (float) != 4)
+ return 38;
+ if (sizeof (double) != 8)
+ return 39;
+ if (alignof (double) != 8)
+ return 40;
+#ifdef HAVE_IA64_TYPES
+ if (sizeof (__float80) != 16)
+ return 41;
+ if (alignof (__float80) != 16)
+ return 42;
+ if (sizeof (__float128) != 16)
+ return 43;
+ if (alignof (__float128) != 16)
+ return 44;
+#endif /* HAVE_IA64_TYPES */
+
+ return 0;
+}
--- /dev/null
+// Skip if not target: i?86-*-linux*
+// Special g++ Options: -malign-double
+// Origin: Alex Samuel <samuel@codesourcery.com>
+
+/* Test the layout of bitfields in C aggretagtes for compliance with
+ the IA-64 ABI. */
+
+#include <cstring>
+
+template<typename T>
+inline unsigned
+alignmentof ()
+{
+ struct S
+ {
+ char start_;
+ T object_;
+ };
+
+ return (unsigned) & ((S *) 0)->object_;
+}
+
+/* Computes the alignment, in bytes, of TYPE. */
+
+#define alignof(type) (alignmentof<type> ())
+
+/* Returns true iff all the bits in the range
+ START_BIT <= bit < START_BIT + NUM_BITS, and only those bits, are
+ set in the region of memory starting at BUF of LENGTH bytes. */
+
+bool
+check_bits (char *buf,
+ unsigned length,
+ unsigned start_bit,
+ unsigned num_bits)
+{
+ for (unsigned bit = 0; bit < 8 * length; ++bit) {
+ bool is_set = (buf[bit / 8] & (1 << (bit % 8))) != 0;
+ if (start_bit <= bit && bit < start_bit + num_bits) {
+ if (! is_set)
+ return false;
+ }
+ else {
+ if (is_set)
+ return false;
+ }
+ }
+ return true;
+}
+
+/* Creates a variable of type AGGREGATE, sets FIELD to -1, and
+ verifies that NUM_BITS bits starting at START_BIT, and no other
+ bits, are set. If the check fails, returns with value RVAL. */
+
+#define CHECK_FIELD(AGGREGATE, FIELD, START_BIT, NUM_BITS, RVAL) \
+ do { \
+ AGGREGATE a__; \
+ memset (& a__, 0, sizeof (a__)); \
+ a__.FIELD = -1; \
+ if (! check_bits ((char *) & a__, sizeof (a__), START_BIT, NUM_BITS)) \
+ return RVAL; \
+ } while (0);
+
+
+
+/* Structs S1, S2, S3, S4, and union U5 are taken from Intel, "IA-64
+ Software Conventions and Runtime Architecture Guide", version of
+ August 1999. */
+
+struct S1
+{
+ int j : 5;
+ int k : 6;
+ int m : 7;
+};
+
+#ifdef HAVE_IA64_TYPES
+struct S2
+{
+ short s : 9;
+ __int64 j : 9;
+ char c ;
+ short t : 9;
+ short u : 9;
+ char d ;
+};
+#endif /* HAVE_IA64_TYPES */
+
+struct S3
+{
+ char c ;
+ short s : 8;
+};
+
+union U4
+{
+ char c ;
+ short s : 8;
+};
+
+struct S5
+{
+ char c ;
+ int : 0;
+ char d ;
+ short : 9;
+ char e ;
+ char : 0;
+};
+
+
+int
+main ()
+{
+ if (sizeof (struct S1) != 4)
+ return 1;
+ if (alignof (struct S1) != 4)
+ return 2;
+ CHECK_FIELD (S1, j, 0, 5, 3);
+ CHECK_FIELD (S1, k, 5, 6, 4);
+ CHECK_FIELD (S1, m, 11, 7, 5);
+
+#ifdef HAVE_IA64_TYPES
+ if (sizeof (struct S2) != 16)
+ return 6;
+ if (alignof (struct S2) != 8)
+ return 7;
+ CHECK_FIELD (S2, s, 0, 9, 8);
+ CHECK_FIELD (S2, j, 9, 9, 9);
+ CHECK_FIELD (S2, c, 24, 8, 10);
+ CHECK_FIELD (S2, t, 32, 9, 11);
+ CHECK_FIELD (S2, u, 48, 9, 12);
+ CHECK_FIELD (S2, d, 64, 8, 13);
+#endif /* HAVE_IA64_TYPES */
+
+ if (sizeof (struct S3) != 2)
+ return 14;
+ if (sizeof (struct S3) != 2)
+ return 15;
+ CHECK_FIELD (S3, c, 0, 8, 16);
+ CHECK_FIELD (S3, s, 8, 8, 17);
+
+ if (sizeof (union U4) != 2)
+ return 18;
+ if (alignof (union U4) != 2)
+ return 19;
+ CHECK_FIELD (U4, c, 0, 8, 20);
+ CHECK_FIELD (U4, s, 0, 8, 21);
+
+ if (sizeof (struct S5) != 9)
+ return 22;
+ if (alignof (struct S5) != 1)
+ return 23;
+ CHECK_FIELD (S5, c, 0, 8, 24);
+ CHECK_FIELD (S5, d, 32, 8, 25);
+ CHECK_FIELD (S5, e, 64, 8, 26);
+
+ return 0;
+}
git://gcc.gnu.org / gcc.git / commitdiff