forked from OSchip/llvm-project
286 lines
6.5 KiB
C
286 lines
6.5 KiB
C
// 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
|