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 StorageOffset:0> 18struct __attribute((packed)) s0 { 19 int f0 : 24; 20}; 21 22struct s0 g0 = { 0xdeadbeef }; 23 24int f0_load(struct s0 *a0) { 25 int size_check[sizeof(struct s0) == 3 ? 1 : -1]; 26 return a0->f0; 27} 28int f0_store(struct s0 *a0) { 29 return (a0->f0 = 1); 30} 31int f0_reload(struct s0 *a0) { 32 return (a0->f0 += 1); 33} 34 35// CHECK-OPT-LABEL: define i64 @test_0() 36// CHECK-OPT: ret i64 1 37// CHECK-OPT: } 38unsigned 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 StorageOffset:0> 58// CHECK-RECORD: <CGBitFieldInfo Offset:10 Size:10 IsSigned:1 StorageSize:24 StorageOffset:0> 59 60#pragma pack(push) 61#pragma pack(1) 62struct __attribute((packed)) s1 { 63 signed f0 : 10; 64 signed f1 : 10; 65}; 66#pragma pack(pop) 67 68struct s1 g1 = { 0xdeadbeef, 0xdeadbeef }; 69 70int f1_load(struct s1 *a0) { 71 int size_check[sizeof(struct s1) == 3 ? 1 : -1]; 72 return a0->f1; 73} 74int f1_store(struct s1 *a0) { 75 return (a0->f1 = 1234); 76} 77int f1_reload(struct s1 *a0) { 78 return (a0->f1 += 1234); 79} 80 81// CHECK-OPT-LABEL: define i64 @test_1() 82// CHECK-OPT: ret i64 210 83// CHECK-OPT: } 84unsigned 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 StorageOffset:0> 106 107union __attribute__((packed)) u2 { 108 unsigned long long f0 : 3; 109}; 110 111union u2 g2 = { 0xdeadbeef }; 112 113int f2_load(union u2 *a0) { 114 return a0->f0; 115} 116int f2_store(union u2 *a0) { 117 return (a0->f0 = 1234); 118} 119int f2_reload(union u2 *a0) { 120 return (a0->f0 += 1234); 121} 122 123// CHECK-OPT-LABEL: define i64 @test_2() 124// CHECK-OPT: ret i64 2 125// CHECK-OPT: } 126unsigned 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 139struct s3 { 140 long long f0 : 32; 141 long long f1 : 32; 142}; 143 144struct s3 g3 = { 0xdeadbeef, 0xdeadbeef }; 145 146int f3_load(struct s3 *a0) { 147 a0->f0 = 1; 148 return a0->f0; 149} 150int f3_store(struct s3 *a0) { 151 a0->f0 = 1; 152 return (a0->f0 = 1234); 153} 154int f3_reload(struct s3 *a0) { 155 a0->f0 = 1; 156 return (a0->f0 += 1234); 157} 158 159// CHECK-OPT-LABEL: define i64 @test_3() 160// CHECK-OPT: ret i64 -559039940 161// CHECK-OPT: } 162unsigned 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 176struct s4 { 177 unsigned f0 : 16; 178 unsigned f1 : 28 __attribute__ ((packed)); 179}; 180 181struct s4 g4 = { 0xdeadbeef, 0xdeadbeef }; 182 183int f4_load(struct s4 *a0) { 184 return a0->f0 ^ a0->f1; 185} 186int f4_store(struct s4 *a0) { 187 return (a0->f0 = 1234) ^ (a0->f1 = 5678); 188} 189int f4_reload(struct s4 *a0) { 190 return (a0->f0 += 1234) ^ (a0->f1 += 5678); 191} 192 193// CHECK-OPT-LABEL: define i64 @test_4() 194// CHECK-OPT: ret i64 4860 195// CHECK-OPT: } 196unsigned 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 207struct s5 { 208 unsigned f0 : 2; 209 _Bool f1 : 1; 210 _Bool f2 : 1; 211}; 212 213struct s5 g5 = { 0xdeadbeef, 0xdeadbeef }; 214 215int f5_load(struct s5 *a0) { 216 return a0->f0 ^ a0->f1; 217} 218int f5_store(struct s5 *a0) { 219 return (a0->f0 = 0xF) ^ (a0->f1 = 0xF) ^ (a0->f2 = 0xF); 220} 221int f5_reload(struct s5 *a0) { 222 return (a0->f0 += 0xF) ^ (a0->f1 += 0xF) ^ (a0->f2 += 0xF); 223} 224 225// CHECK-OPT-LABEL: define i64 @test_5() 226// CHECK-OPT: ret i64 2 227// CHECK-OPT: } 228unsigned 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 239struct s6 { 240 unsigned f0 : 2; 241}; 242 243struct s6 g6 = { 0xF }; 244 245int f6_load(struct s6 *a0) { 246 return a0->f0; 247} 248int f6_store(struct s6 *a0) { 249 return a0->f0 = 0x0; 250} 251int f6_reload(struct s6 *a0) { 252 return (a0->f0 += 0xF); 253} 254 255// CHECK-OPT-LABEL: 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, i32, [12 x i8] } 275// CHECK-RECORD: IsZeroInitializable:1 276// CHECK-RECORD: BitFields:[ 277// CHECK-RECORD: <CGBitFieldInfo Offset:0 Size:5 IsSigned:1 StorageSize:8 StorageOffset:12> 278// CHECK-RECORD: <CGBitFieldInfo Offset:0 Size:29 IsSigned:1 StorageSize:32 StorageOffset:16> 279 280struct __attribute__((aligned(16))) s7 { 281 int a, b, c; 282 int f0 : 5; 283 int f1 : 29; 284}; 285 286int 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 294struct __attribute__((packed)) s8 { 295 char f0 : 4; 296 char f1; 297 int f2 : 4; 298 char f3 : 4; 299}; 300 301struct s8 g8 = { 0xF }; 302 303int f8_load(struct s8 *a0) { 304 return a0->f0 ^ a0 ->f2 ^ a0->f3; 305} 306int f8_store(struct s8 *a0) { 307 return (a0->f0 = 0xFD) ^ (a0->f2 = 0xFD) ^ (a0->f3 = 0xFD); 308} 309int f8_reload(struct s8 *a0) { 310 return (a0->f0 += 0xFD) ^ (a0->f2 += 0xFD) ^ (a0->f3 += 0xFD); 311} 312 313// CHECK-OPT-LABEL: define i32 @test_8() 314// CHECK-OPT: ret i32 -3 315// CHECK-OPT: } 316unsigned 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 331struct __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 342int f9_load(struct s9 *a0) { 343 return a0->f7; 344} 345