Home | History | Annotate | Download | only in CodeGen
      1 // RUN: %clang_cc1 -emit-llvm -triple x86_64 -O3 -o %t.opt.ll %s \
      2 // RUN:   -fdump-record-layouts > %t.dump.txt
      3 // RUN: FileCheck -check-prefix=CHECK-RECORD < %t.dump.txt %s
      4 // RUN: FileCheck -check-prefix=CHECK-OPT < %t.opt.ll %s
      5 
      6 /****/
      7 
      8 // Check that we don't read off the end a packed 24-bit structure.
      9 // PR6176
     10 
     11 // CHECK-RECORD: *** Dumping IRgen Record Layout
     12 // CHECK-RECORD: Record: RecordDecl{{.*}}s0
     13 // CHECK-RECORD: Layout: <CGRecordLayout
     14 // CHECK-RECORD:   LLVMType:%struct.s0 = type <{ [3 x i8] }>
     15 // CHECK-RECORD:   IsZeroInitializable:1
     16 // CHECK-RECORD:   BitFields:[
     17 // CHECK-RECORD:     <CGBitFieldInfo Offset:0 Size:24 IsSigned:1 StorageSize:24 StorageAlignment:1>
     18 struct __attribute((packed)) s0 {
     19   int f0 : 24;
     20 };
     21 
     22 struct s0 g0 = { 0xdeadbeef };
     23 
     24 int f0_load(struct s0 *a0) {
     25   int size_check[sizeof(struct s0) == 3 ? 1 : -1];
     26   return a0->f0;
     27 }
     28 int f0_store(struct s0 *a0) {
     29   return (a0->f0 = 1);
     30 }
     31 int f0_reload(struct s0 *a0) {
     32   return (a0->f0 += 1);
     33 }
     34 
     35 // CHECK-OPT: define i64 @test_0()
     36 // CHECK-OPT:  ret i64 1
     37 // CHECK-OPT: }
     38 unsigned long long test_0() {
     39   struct s0 g0 = { 0xdeadbeef };
     40   unsigned long long res = 0;
     41   res ^= g0.f0;
     42   res ^= f0_load(&g0) ^ f0_store(&g0) ^ f0_reload(&g0);
     43   res ^= g0.f0;
     44   return res;
     45 }
     46 
     47 /****/
     48 
     49 // PR5591
     50 
     51 // CHECK-RECORD: *** Dumping IRgen Record Layout
     52 // CHECK-RECORD: Record: RecordDecl{{.*}}s1
     53 // CHECK-RECORD: Layout: <CGRecordLayout
     54 // CHECK-RECORD:   LLVMType:%struct.s1 = type <{ [3 x i8] }>
     55 // CHECK-RECORD:   IsZeroInitializable:1
     56 // CHECK-RECORD:   BitFields:[
     57 // CHECK-RECORD:     <CGBitFieldInfo Offset:0 Size:10 IsSigned:1 StorageSize:24 StorageAlignment:1>
     58 // CHECK-RECORD:     <CGBitFieldInfo Offset:10 Size:10 IsSigned:1 StorageSize:24 StorageAlignment:1>
     59 
     60 #pragma pack(push)
     61 #pragma pack(1)
     62 struct __attribute((packed)) s1 {
     63   signed f0 : 10;
     64   signed f1 : 10;
     65 };
     66 #pragma pack(pop)
     67 
     68 struct s1 g1 = { 0xdeadbeef, 0xdeadbeef };
     69 
     70 int f1_load(struct s1 *a0) {
     71   int size_check[sizeof(struct s1) == 3 ? 1 : -1];
     72   return a0->f1;
     73 }
     74 int f1_store(struct s1 *a0) {
     75   return (a0->f1 = 1234);
     76 }
     77 int f1_reload(struct s1 *a0) {
     78   return (a0->f1 += 1234);
     79 }
     80 
     81 // CHECK-OPT: define i64 @test_1()
     82 // CHECK-OPT:  ret i64 210
     83 // CHECK-OPT: }
     84 unsigned long long test_1() {
     85   struct s1 g1 = { 0xdeadbeef, 0xdeadbeef };
     86   unsigned long long res = 0;
     87   res ^= g1.f0 ^ g1.f1;
     88   res ^= f1_load(&g1) ^ f1_store(&g1) ^ f1_reload(&g1);
     89   res ^= g1.f0 ^ g1.f1;
     90   return res;
     91 }
     92 
     93 /****/
     94 
     95 // Check that we don't access beyond the bounds of a union.
     96 //
     97 // PR5567
     98 
     99 // CHECK-RECORD: *** Dumping IRgen Record Layout
    100 // CHECK-RECORD: Record: RecordDecl{{.*}}u2
    101 // CHECK-RECORD: Layout: <CGRecordLayout
    102 // CHECK-RECORD:   LLVMType:%union.u2 = type <{ i8 }>
    103 // CHECK-RECORD:   IsZeroInitializable:1
    104 // CHECK-RECORD:   BitFields:[
    105 // CHECK-RECORD:     <CGBitFieldInfo Offset:0 Size:3 IsSigned:0 StorageSize:8 StorageAlignment:1>
    106 
    107 union __attribute__((packed)) u2 {
    108   unsigned long long f0 : 3;
    109 };
    110 
    111 union u2 g2 = { 0xdeadbeef };
    112 
    113 int f2_load(union u2 *a0) {
    114   return a0->f0;
    115 }
    116 int f2_store(union u2 *a0) {
    117   return (a0->f0 = 1234);
    118 }
    119 int f2_reload(union u2 *a0) {
    120   return (a0->f0 += 1234);
    121 }
    122 
    123 // CHECK-OPT: define i64 @test_2()
    124 // CHECK-OPT:  ret i64 2
    125 // CHECK-OPT: }
    126 unsigned long long test_2() {
    127   union u2 g2 = { 0xdeadbeef };
    128   unsigned long long res = 0;
    129   res ^= g2.f0;
    130   res ^= f2_load(&g2) ^ f2_store(&g2) ^ f2_reload(&g2);
    131   res ^= g2.f0;
    132   return res;
    133 }
    134 
    135 /***/
    136 
    137 // PR5039
    138 
    139 struct s3 {
    140   long long f0 : 32;
    141   long long f1 : 32;
    142 };
    143 
    144 struct s3 g3 = { 0xdeadbeef, 0xdeadbeef };
    145 
    146 int f3_load(struct s3 *a0) {
    147   a0->f0 = 1;
    148   return a0->f0;
    149 }
    150 int f3_store(struct s3 *a0) {
    151   a0->f0 = 1;
    152   return (a0->f0 = 1234);
    153 }
    154 int f3_reload(struct s3 *a0) {
    155   a0->f0 = 1;
    156   return (a0->f0 += 1234);
    157 }
    158 
    159 // CHECK-OPT: define i64 @test_3()
    160 // CHECK-OPT:  ret i64 -559039940
    161 // CHECK-OPT: }
    162 unsigned long long test_3() {
    163   struct s3 g3 = { 0xdeadbeef, 0xdeadbeef };
    164   unsigned long long res = 0;
    165   res ^= g3.f0 ^ g3.f1;
    166   res ^= f3_load(&g3) ^ f3_store(&g3) ^ f3_reload(&g3);
    167   res ^= g3.f0 ^ g3.f1;
    168   return res;
    169 }
    170 
    171 /***/
    172 
    173 // This is a case where the bitfield access will straddle an alignment boundary
    174 // of its underlying type.
    175 
    176 struct s4 {
    177   unsigned f0 : 16;
    178   unsigned f1 : 28 __attribute__ ((packed));
    179 };
    180 
    181 struct s4 g4 = { 0xdeadbeef, 0xdeadbeef };
    182 
    183 int f4_load(struct s4 *a0) {
    184   return a0->f0 ^ a0->f1;
    185 }
    186 int f4_store(struct s4 *a0) {
    187   return (a0->f0 = 1234) ^ (a0->f1 = 5678);
    188 }
    189 int f4_reload(struct s4 *a0) {
    190   return (a0->f0 += 1234) ^ (a0->f1 += 5678);
    191 }
    192 
    193 // CHECK-OPT: define i64 @test_4()
    194 // CHECK-OPT:  ret i64 4860
    195 // CHECK-OPT: }
    196 unsigned long long test_4() {
    197   struct s4 g4 = { 0xdeadbeef, 0xdeadbeef };
    198   unsigned long long res = 0;
    199   res ^= g4.f0 ^ g4.f1;
    200   res ^= f4_load(&g4) ^ f4_store(&g4) ^ f4_reload(&g4);
    201   res ^= g4.f0 ^ g4.f1;
    202   return res;
    203 }
    204 
    205 /***/
    206 
    207 struct s5 {
    208   unsigned f0 : 2;
    209   _Bool f1 : 1;
    210   _Bool f2 : 1;
    211 };
    212 
    213 struct s5 g5 = { 0xdeadbeef, 0xdeadbeef };
    214 
    215 int f5_load(struct s5 *a0) {
    216   return a0->f0 ^ a0->f1;
    217 }
    218 int f5_store(struct s5 *a0) {
    219   return (a0->f0 = 0xF) ^ (a0->f1 = 0xF) ^ (a0->f2 = 0xF);
    220 }
    221 int f5_reload(struct s5 *a0) {
    222   return (a0->f0 += 0xF) ^ (a0->f1 += 0xF) ^ (a0->f2 += 0xF);
    223 }
    224 
    225 // CHECK-OPT: define i64 @test_5()
    226 // CHECK-OPT:  ret i64 2
    227 // CHECK-OPT: }
    228 unsigned long long test_5() {
    229   struct s5 g5 = { 0xdeadbeef, 0xdeadbeef, 0xdeadbeef };
    230   unsigned long long res = 0;
    231   res ^= g5.f0 ^ g5.f1 ^ g5.f2;
    232   res ^= f5_load(&g5) ^ f5_store(&g5) ^ f5_reload(&g5);
    233   res ^= g5.f0 ^ g5.f1 ^ g5.f2;
    234   return res;
    235 }
    236 
    237 /***/
    238 
    239 struct s6 {
    240   _Bool f0 : 2;
    241 };
    242 
    243 struct s6 g6 = { 0xF };
    244 
    245 int f6_load(struct s6 *a0) {
    246   return a0->f0;
    247 }
    248 int f6_store(struct s6 *a0) {
    249   return a0->f0 = 0x0;
    250 }
    251 int f6_reload(struct s6 *a0) {
    252   return (a0->f0 += 0xF);
    253 }
    254 
    255 // CHECK-OPT: define zeroext i1 @test_6()
    256 // CHECK-OPT:  ret i1 true
    257 // CHECK-OPT: }
    258 _Bool test_6() {
    259   struct s6 g6 = { 0xF };
    260   unsigned long long res = 0;
    261   res ^= g6.f0;
    262   res ^= f6_load(&g6);
    263   res ^= g6.f0;
    264   return res;
    265 }
    266 
    267 /***/
    268 
    269 // Check that we compute the best alignment possible for each access.
    270 //
    271 // CHECK-RECORD: *** Dumping IRgen Record Layout
    272 // CHECK-RECORD: Record: RecordDecl{{.*}}s7
    273 // CHECK-RECORD: Layout: <CGRecordLayout
    274 // CHECK-RECORD:   LLVMType:%struct.s7 = type { i32, i32, i32, i8, [3 x i8], [4 x i8], [12 x i8] }
    275 // CHECK-RECORD:   IsZeroInitializable:1
    276 // CHECK-RECORD:   BitFields:[
    277 // CHECK-RECORD:     <CGBitFieldInfo Offset:0 Size:5 IsSigned:1 StorageSize:8 StorageAlignment:4>
    278 // CHECK-RECORD:     <CGBitFieldInfo Offset:0 Size:29 IsSigned:1 StorageSize:32 StorageAlignment:16>
    279 
    280 struct __attribute__((aligned(16))) s7 {
    281   int a, b, c;
    282   int f0 : 5;
    283   int f1 : 29;
    284 };
    285 
    286 int f7_load(struct s7 *a0) {
    287   return a0->f0;
    288 }
    289 
    290 /***/
    291 
    292 // This is a case where we narrow the access width immediately.
    293 
    294 struct __attribute__((packed)) s8 {
    295   char f0 : 4;
    296   char f1;
    297   int  f2 : 4;
    298   char f3 : 4;
    299 };
    300 
    301 struct s8 g8 = { 0xF };
    302 
    303 int f8_load(struct s8 *a0) {
    304   return a0->f0 ^ a0 ->f2 ^ a0->f3;
    305 }
    306 int f8_store(struct s8 *a0) {
    307   return (a0->f0 = 0xFD) ^ (a0->f2 = 0xFD) ^ (a0->f3 = 0xFD);
    308 }
    309 int f8_reload(struct s8 *a0) {
    310   return (a0->f0 += 0xFD) ^ (a0->f2 += 0xFD) ^ (a0->f3 += 0xFD);
    311 }
    312 
    313 // CHECK-OPT: define i32 @test_8()
    314 // CHECK-OPT:  ret i32 -3
    315 // CHECK-OPT: }
    316 unsigned test_8() {
    317   struct s8 g8 = { 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef };
    318   unsigned long long res = 0;
    319   res ^= g8.f0 ^ g8.f2 ^ g8.f3;
    320   res ^= f8_load(&g8) ^ f8_store(&g8) ^ f8_reload(&g8);
    321   res ^= g8.f0 ^ g8.f2 ^ g8.f3;
    322   return res;
    323 }
    324 
    325 /***/
    326 
    327 // This is another case where we narrow the access width immediately.
    328 //
    329 // <rdar://problem/7893760>
    330 
    331 struct __attribute__((packed)) s9 {
    332   unsigned f0 : 7;
    333   unsigned f1 : 7;
    334   unsigned f2 : 7;
    335   unsigned f3 : 7;
    336   unsigned f4 : 7;
    337   unsigned f5 : 7;
    338   unsigned f6 : 7;
    339   unsigned f7 : 7;
    340 };
    341 
    342 int f9_load(struct s9 *a0) {
    343   return a0->f7;
    344 }
    345