// RUN: %clang_cc1 %s -fsyntax-only -verify -triple=i686-apple-darwin9
// RUN: %clang_cc1 %s -fsyntax-only -verify -triple=arm-linux-gnueabihf
// RUN: %clang_cc1 %s -fsyntax-only -verify -triple=aarch64-linux-gnu
// RUN: %clang_cc1 %s -fsyntax-only -verify -triple=x86_64-pc-linux-gnu
// RUN: %clang_cc1 %s -fsyntax-only -verify -triple=x86_64-scei-ps4
// expected-no-diagnostics
#include <stddef.h>

#define CHECK_SIZE(kind, name, size) \
  extern int name##_1[sizeof(kind name) == size ? 1 : -1];
#define CHECK_ALIGN(kind, name, size) \
  extern int name##_2[__alignof(kind name) == size ? 1 : -1];
#define CHECK_OFFSET(kind, name, member, offset) \
  extern int name##_3[offsetof(kind name, member) == offset ? 1 : -1];

// Zero-width bit-fields
struct a {char x; int : 0; char y;};
#if defined(__arm__) || defined(__aarch64__)
CHECK_SIZE(struct, a, 8)
CHECK_ALIGN(struct, a, 4)
#else
CHECK_SIZE(struct, a, 5)
CHECK_ALIGN(struct, a, 1)
#endif

// Zero-width bit-fields with packed
struct __attribute__((packed)) a2 { short x : 9; char : 0; int y : 17; };
CHECK_SIZE(struct, a2, 5)
CHECK_ALIGN(struct, a2, 1)

// Zero-width bit-fields at the end of packed struct
struct __attribute__((packed)) a3 { short x : 9; int : 0; };
#if defined(__arm__) || defined(__aarch64__)
CHECK_SIZE(struct, a3, 4)
CHECK_ALIGN(struct, a3, 4)
#else
CHECK_SIZE(struct, a3, 4)
CHECK_ALIGN(struct, a3, 1)
#endif

// For comparison, non-zero-width bit-fields at the end of packed struct
struct __attribute__((packed)) a4 { short x : 9; int : 1; };
CHECK_SIZE(struct, a4, 2)
CHECK_ALIGN(struct, a4, 1)

union b {char x; int : 0; char y;};
#if defined(__arm__) || defined(__aarch64__)
CHECK_SIZE(union, b, 4)
CHECK_ALIGN(union, b, 4)
#else
CHECK_SIZE(union, b, 1)
CHECK_ALIGN(union, b, 1)
#endif

// Unnamed bit-field align
struct c {char x; int : 20;};
#if defined(__arm__) || defined(__aarch64__)
CHECK_SIZE(struct, c, 4)
CHECK_ALIGN(struct, c, 4)
#else
CHECK_SIZE(struct, c, 4)
CHECK_ALIGN(struct, c, 1)
#endif

union d {char x; int : 20;};
#if defined(__arm__) || defined(__aarch64__)
CHECK_SIZE(union, d, 4)
CHECK_ALIGN(union, d, 4)
#else
CHECK_SIZE(union, d, 3)
CHECK_ALIGN(union, d, 1)
#endif

// Bit-field packing
struct __attribute__((packed)) e {int x : 4, y : 30, z : 30;};
CHECK_SIZE(struct, e, 8)
CHECK_ALIGN(struct, e, 1)

// Alignment on bit-fields
struct f {__attribute((aligned(8))) int x : 30, y : 30, z : 30;};
CHECK_SIZE(struct, f, 24)
CHECK_ALIGN(struct, f, 8)

// Large structure (overflows i32, in bits).
struct s0 {
  char a[0x32100000];
  int x:30, y:30;
};

CHECK_SIZE(struct, s0, 0x32100008)
CHECK_ALIGN(struct, s0, 4)

// Bit-field with explicit align bigger than normal.
struct g0 {
  char a;
  __attribute__((aligned(16))) int b : 1;
  char c;
};

#if defined(__ORBIS__)
CHECK_SIZE(struct, g0, 16);
CHECK_ALIGN(struct, g0, 16);
CHECK_OFFSET(struct, g0, c, 2);
#else
CHECK_SIZE(struct, g0, 32);
CHECK_ALIGN(struct, g0, 16);
CHECK_OFFSET(struct, g0, c, 17);
#endif

// Bit-field with explicit align smaller than normal.
struct g1 {
  char a;
  __attribute__((aligned(2))) int b : 1;
  char c;
};

CHECK_SIZE(struct, g1, 4);
CHECK_ALIGN(struct, g1, 4);
#if defined(__ORBIS__)
CHECK_OFFSET(struct, g1, c, 2);
#else
CHECK_OFFSET(struct, g1, c, 3);
#endif

// Same as above but without explicit align.
struct g2 {
  char a;
  int b : 1;
  char c;
};

CHECK_SIZE(struct, g2, 4);
CHECK_ALIGN(struct, g2, 4);
CHECK_OFFSET(struct, g2, c, 2);

// Explicit attribute align on bit-field has precedence over packed attribute
// applied too the struct.
struct __attribute__((packed)) g3 {
  char a;
  __attribute__((aligned(16))) int b : 1;
  char c;
};

CHECK_ALIGN(struct, g3, 16);
#if defined(__ORBIS__)
CHECK_SIZE(struct, g3, 16);
CHECK_OFFSET(struct, g3, c, 2);
#else
CHECK_SIZE(struct, g3, 32);
CHECK_OFFSET(struct, g3, c, 17);
#endif

struct __attribute__((packed)) g4 {
  char a;
  __attribute__((aligned(2))) int b : 1;
  char c;
};

CHECK_SIZE(struct, g4, 4);
CHECK_ALIGN(struct, g4, 2);
#if defined(__ORBIS__)
CHECK_OFFSET(struct, g4, c, 2);
#else
CHECK_OFFSET(struct, g4, c, 3);
#endif

struct g5 {
  char : 1;
  __attribute__((aligned(1))) int n : 24;
};
CHECK_SIZE(struct, g5, 4);
CHECK_ALIGN(struct, g5, 4);

struct __attribute__((packed)) g6 {
  char : 1;
  __attribute__((aligned(1))) int n : 24;
};
CHECK_SIZE(struct, g6, 4);
CHECK_ALIGN(struct, g6, 1);

struct g7 {
  char : 1;
  __attribute__((aligned(1))) int n : 25;
};
#if defined(__ORBIS__)
CHECK_SIZE(struct, g7, 4);
#else
CHECK_SIZE(struct, g7, 8);
#endif
CHECK_ALIGN(struct, g7, 4);

struct __attribute__((packed)) g8 {
  char : 1;
  __attribute__((aligned(1))) int n : 25;
};
#if defined(__ORBIS__)
CHECK_SIZE(struct, g8, 4);
#else
CHECK_SIZE(struct, g8, 5);
#endif
CHECK_ALIGN(struct, g8, 1);

struct g9 {
  __attribute__((aligned(1))) char a : 2, b : 2, c : 2, d : 2, e : 2;
  int i;
};
#if defined(__ORBIS__)
CHECK_SIZE(struct, g9, 8);
#else
CHECK_SIZE(struct, g9, 12);
#endif
CHECK_ALIGN(struct, g9, 4);

struct __attribute__((packed)) g10 {
  __attribute__((aligned(1))) char a : 2, b : 2, c : 2, d : 2, e : 2;
  int i;
};
#if defined(__ORBIS__)
CHECK_SIZE(struct, g10, 6);
#else
CHECK_SIZE(struct, g10, 9);
#endif
CHECK_ALIGN(struct, g10, 1);

struct g11 {
  char a;
  __attribute__((aligned(1))) long long b : 62;
  char c;
};
#if defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
CHECK_SIZE(struct, g11, 24);
CHECK_ALIGN(struct, g11, 8);
CHECK_OFFSET(struct, g11, c, 16);
#else
CHECK_SIZE(struct, g11, 16);
CHECK_ALIGN(struct, g11, 4);
CHECK_OFFSET(struct, g11, c, 12);
#endif

struct __attribute__((packed)) g12 {
  char a;
  __attribute__((aligned(1))) long long b : 62;
  char c;
};
CHECK_SIZE(struct, g12, 10);
CHECK_ALIGN(struct, g12, 1);
CHECK_OFFSET(struct, g12, c, 9);

struct g13 {
  char a;
  __attribute__((aligned(1))) long long : 0;
  char c;
};
#if defined(__arm__) || defined(__aarch64__)
CHECK_SIZE(struct, g13, 16);
CHECK_ALIGN(struct, g13, 8);
CHECK_OFFSET(struct, g13, c, 8);
#elif defined(__x86_64__)
CHECK_SIZE(struct, g13, 9);
CHECK_ALIGN(struct, g13, 1);
CHECK_OFFSET(struct, g13, c, 8);
#else
CHECK_SIZE(struct, g13, 5);
CHECK_ALIGN(struct, g13, 1);
CHECK_OFFSET(struct, g13, c, 4);
#endif

struct __attribute__((packed)) g14 {
  char a;
  __attribute__((aligned(1))) long long : 0;
  char c;
};
#if defined(__arm__) || defined(__aarch64__)
CHECK_SIZE(struct, g14, 16);
CHECK_ALIGN(struct, g14, 8);
CHECK_OFFSET(struct, g14, c, 8);
#elif defined(__x86_64__)
CHECK_SIZE(struct, g14, 9);
CHECK_ALIGN(struct, g14, 1);
CHECK_OFFSET(struct, g14, c, 8);
#else
CHECK_SIZE(struct, g14, 5);
CHECK_ALIGN(struct, g14, 1);
CHECK_OFFSET(struct, g14, c, 4);
#endif