[Bug c++/34747] New: __attribute__((aligned(x)))+__alignof != correct behaviour

[andry at inbox dot ru]

__attribute__((aligned(x))) is not derivable and etc. Here is the tests which
discovering the bugs:

///////////////////////////////////////////////////////////////////////////////
#include <stdio.h>

#ifdef __GNUC__
#define DECLARE_ALIGN(x) __attribute__((aligned(x)))
#elif defined(_MSC_VER)
#define DECLARE_ALIGN(x) __declspec(align(x))
#endif

struct DECLARE_ALIGN(1) A1 {
};

struct DECLARE_ALIGN(16) A16 {
};

struct DECLARE_ALIGN(32) A32 {
};

#pragma pack(push,1)
struct DECLARE_ALIGN(16) A16P1 { //Alignment still should be 16
};

struct DECLARE_ALIGN(32) A32P1 { //Alignment still should be 32
};
#pragma pack(pop)

struct DECLARE_ALIGN(16) A1632_1 : A32 {}; //Overall alignment still should be
32
struct DECLARE_ALIGN(16) A1632_2 { A32 a32; }; //Overall alignment still should
be 32

int failures = 0;

///////////////////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct test1_t {
  A1 a1;
};
#pragma pack(pop)
void test1() {
  if(__alignof(test1_t) != 1) { printf("FAILED: test1\n"); failures++; }
}

#pragma pack(push,1)
struct test2_t
  : A1 {
};
#pragma pack(pop)
void test2() {
  if(__alignof(test2_t) != 1) { printf("FAILED: test2\n"); failures++; }
}

#pragma pack(push,1)
struct test3_t {
  int i;
  A1 a1;
};
#pragma pack(pop)
void test3() {
  if(__alignof(test3_t) != 1) { printf("FAILED: test3\n"); failures++; }
}

#pragma pack(push,1)
struct test4_t
  : A1 {
  int i;
};
#pragma pack(pop)
void test4() {
  if(__alignof(test4_t) != 1) { printf("FAILED: test4\n"); failures++; }
}

///////////////////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct test5_t {
  A16P1 a16p1;
};
#pragma pack(pop)
void test5() {
  if(__alignof(test5_t) != 16) { printf("FAILED: test5\n"); failures++; }
}

#pragma pack(push,1)
struct test6_t
  : A16P1 {
};
#pragma pack(pop)
void test6() {
  if(__alignof(test6_t) != 16) { printf("FAILED: test6\n"); failures++; }
}

#pragma pack(push,1)
struct test7_t {
  int i;
  A16P1 a16p1;
};
#pragma pack(pop)
void test7() {
  if(__alignof(test7_t) != 16) { printf("FAILED: test7\n"); failures++; }
}

#pragma pack(push,1)
struct test8_t
  : A16P1 {
  int i;
};
#pragma pack(pop)
void test8() {
  if(__alignof(test8_t) != 16) { printf("FAILED: test8\n"); failures++; }
}

///////////////////////////////////////////////////////////////////////////////
struct test10_t {
  int i;
  A16 a16;
};
void test10() {
  if(__alignof(test10_t) != 16) { printf("FAILED: test10\n"); failures++; }
}

struct test11_t {
  int i;
  A16 a16;
  A32 a32;
};
void test11() {
  if(__alignof(test11_t) != 32) { printf("FAILED: test11\n"); failures++; }
}

struct test12_t : A16 {
  int i;
};
void test12() {
  if(__alignof(test12_t) != 16) { printf("FAILED: test12\n"); failures++; }
}

struct test13_t : A16,A32 {
  char i;
};
void test13() {
  if(__alignof(test13_t) != 32) { printf("FAILED: test13\n"); failures++; }
}

struct test14_t : A16,A32 {
  char c;
  int i;
};
void test14() {
  if(__alignof(test14_t) != 32) { printf("FAILED: test14\n"); failures++; }
}

struct test15_t {
  int i;
  A16P1 a16p1;
};
void test15() {
  if(__alignof(test15_t) != 16) { printf("FAILED: test15\n"); failures++; }
}

struct test16_t {
  int i;
  A16P1 a16p1;
  A32P1 a32p1;
};
void test16() {
  if(__alignof(test16_t) != 32) { printf("FAILED: test16\n"); failures++; }
}

struct test17_t : A16P1 {
  int i;
};
void test17() {
  if(__alignof(test17_t) != 16) { printf("FAILED: test17\n"); failures++; }
}

struct test18_t : A16P1,A32P1 {
  int i;
};
void test18() {
  if(__alignof(test18_t) != 32) { printf("FAILED: test18\n"); failures++; }
}

struct test19_t : A16P1,A32P1 {
  char c;
  int i;
};
void test19() {
  if(__alignof(test19_t) != 32) { printf("FAILED: test19\n"); failures++; }
}

#pragma pack(push,1)
struct test20_t {
  int i;
  A16 a16;
};
void test20() {
  if(__alignof(test20_t) != 16) { printf("FAILED: test20\n"); failures++; }
}

struct test21_t {
  int i;
  A16 a16;
  A32 a32;
};
void test21() {
  if(__alignof(test21_t) != 32) { printf("FAILED: test21\n"); failures++; }
}

struct test22_t : A16 {
  int i;
};
void test22() {
  if(__alignof(test22_t) != 16) { printf("FAILED: test22\n"); failures++; }
}

struct test23_t : A16,A32 {
  int i;
};
void test23() {
  if(__alignof(test23_t) != 32) { printf("FAILED: test23\n"); failures++; }
}

struct test24_t : A16,A32 {
  char c;
  int i;
};
void test24() {
  if(__alignof(test24_t) != 32) { printf("FAILED: test24\n"); failures++; }
}

struct test25_t {
  int i;
  A16P1 a16p1;
};
void test25() {
  if(__alignof(test25_t) != 16) { printf("FAILED: test25\n"); failures++; }
}

struct test26_t {
  int i;
  A16P1 a16p1;
  A32P1 a32p1;
};
void test26() {
  if(__alignof(test26_t) != 32) { printf("FAILED: test26\n"); failures++; }
}

struct test27_t : A16P1 {
  int i;
};
void test27() {
  if(__alignof(test27_t) != 16) { printf("FAILED: test27\n"); failures++; }
}

struct test28_t : A16P1,A32P1 {
  int i;
};
void test28() {
  if(__alignof(test28_t) != 32) { printf("FAILED: test28\n"); failures++; }
}

struct test29_t : A16P1,A32P1 {
  char c;
  int i;
};
void test29() {
  if(__alignof(test29_t) != 32) { printf("FAILED: test29\n"); failures++; }
}
#pragma pack(pop)

///////////////////////////////////////////////////////////////////////////////
struct test30_t : A16 {
};
void test30() {
  if(__alignof(test30_t) != 16) { printf("FAILED: test30\n"); failures++; }
}

struct test31_t : A32 {
  A16 a16;
};
void test31() {
  if(__alignof(test31_t) != 32) { printf("FAILED: test31\n"); failures++; }
}

struct test32_t : A16 {
  A32 a32;
};
void test32() {
  if(__alignof(test32_t) != 32) { printf("FAILED: test32\n"); failures++; }
}

struct test33_t : A32 {
  A16 a16;
};
void test33() {
  if(__alignof(test33_t) != 32) { printf("FAILED: test33\n"); failures++; }
}

#pragma pack(push,1)
struct test35_t : A16 {
};
void test35() {
  if(__alignof(test35_t) != 16) { printf("FAILED: test35\n"); failures++; }
}

struct test36_t : A32 {
  A16 a16;
};
void test36() {
  if(__alignof(test36_t) != 32) { printf("FAILED: test36\n"); failures++; }
}

struct test37_t : A16 {
  A32 a32;
};
void test37() {
  if(__alignof(test37_t) != 32) { printf("FAILED: test37\n"); failures++; }
}

struct test38_t : A32 {
  A16 a16;
};
void test38() {
  if(__alignof(test38_t) != 32) { printf("FAILED: test38\n"); failures++; }
}
#pragma pack(pop)

///////////////////////////////////////////////////////////////////////////////
struct test40_t : A1632_1 {
};
void test40() {
  if(__alignof(test40_t) != 32) { printf("FAILED: test40\n"); failures++; }
}

struct test41_t : A1632_2 {
};
void test41() {
  if(__alignof(test41_t) != 32) { printf("FAILED: test41\n"); failures++; }
}

struct test42_t {
  A1632_1 a1632;
};
void test42() {
  if(__alignof(test42_t) != 32) { printf("FAILED: test42\n"); failures++; }
}

struct test43_t {
  A1632_2 a1632;
};
void test43() {
  if(__alignof(test43_t) != 32) { printf("FAILED: test43\n"); failures++; }
}

#pragma pack(push,1)
struct test45_t : A1632_1 {
};
void test45() {
  if(__alignof(test45_t) != 32) { printf("FAILED: test45\n"); failures++; }
}

struct test46_t : A1632_2 {
};
void test46() {
  if(__alignof(test46_t) != 32) { printf("FAILED: test46\n"); failures++; }
}

struct test47_t {
  A1632_1 a1632;
};
void test47() {
  if(__alignof(test47_t) != 32) { printf("FAILED: test47\n"); failures++; }
}

struct test48_t {
  A1632_2 a1632;
};
void test48() {
  if(__alignof(test48_t) != 32) { printf("FAILED: test48\n"); failures++; }
}
#pragma pack(pop)

int main() {
  test1();  test2();  test3();  test4();  test5();  test6();  test7(); 
test8();
  test10(); test11(); test12(); test13(); test14(); test15(); test16();
test17(); test18(); test19();
  test20(); test21(); test22(); test23(); test24(); test25(); test26();
test27(); test28(); test29();
  test30(); test31(); test32(); test33();           test35(); test36();
test37(); test38();
  test40(); test41(); test42(); test43();           test45(); test46();
test47(); test48();
  if(!failures) {
    printf("No failures!\n");
  } else {
    printf("%u tests failed!\n",failures);
  }
  return 0;
}
///////////////////////////////////////////////////////////////////////////////

Test failes with 33 errors.
For example, Microsoft Visual Stidio 2003/2005/2008 C++ behavies all tests
correct and without any failures.


-- 
           Summary: __attribute__((aligned(x)))+__alignof != correct
                    behaviour
           Product: gcc
           Version: 4.1.2
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: andry at inbox dot ru
  GCC host triplet: host-i686-pc-cygwin


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=34747