1// RUN: %clang_cc1 -triple arm64-apple-ios11 -fobjc-arc -fblocks -fobjc-runtime=ios-11.0 -emit-llvm -o - -DUSESTRUCT -I %S/Inputs %s | FileCheck %s 2 3// RUN: %clang_cc1 -triple arm64-apple-ios11 -fobjc-arc -fblocks -fobjc-runtime=ios-11.0 -emit-pch -I %S/Inputs -o %t %s 4// RUN: %clang_cc1 -triple arm64-apple-ios11 -fobjc-arc -fblocks -fobjc-runtime=ios-11.0 -include-pch %t -emit-llvm -o - -DUSESTRUCT -I %S/Inputs %s | FileCheck %s 5 6#ifndef HEADER 7#define HEADER 8#include "strong_in_union.h" 9 10typedef void (^BlockTy)(void); 11 12typedef struct { 13 int a[4]; 14} Trivial; 15 16typedef struct { 17 Trivial f0; 18 id f1; 19} Strong; 20 21typedef struct { 22 int i; 23 id f1; 24} StrongSmall; 25 26typedef struct { 27 Strong f0; 28 id f1; 29 double d; 30} StrongOuter; 31 32typedef struct { 33 id f0; 34 Strong f1; 35} StrongOuter2; 36 37typedef struct { 38 int f0; 39 volatile id f1; 40} StrongVolatile; 41 42typedef struct { 43 BlockTy f0; 44} StrongBlock; 45 46typedef struct { 47 int i; 48 id f0[2][2]; 49} IDArray; 50 51typedef struct { 52 double d; 53 Strong f0[2][2]; 54} StructArray; 55 56typedef struct { 57 id f0; 58 int i : 9; 59} Bitfield0; 60 61typedef struct { 62 char c; 63 int i0 : 2; 64 int i1 : 4; 65 id f0; 66 int i2 : 31; 67 int i3 : 1; 68 id f1; 69 int : 0; 70 int a[3]; 71 id f2; 72 double d; 73 int i4 : 1; 74 volatile int i5 : 2; 75 volatile char i6; 76} Bitfield1; 77 78typedef struct { 79 id x; 80 volatile int a[16]; 81} VolatileArray ; 82 83#endif 84 85#ifdef USESTRUCT 86 87StrongSmall getStrongSmall(void); 88StrongOuter getStrongOuter(void); 89StrongOuter2 getStrongOuter2(void); 90void calleeStrongSmall(StrongSmall); 91void func(Strong *); 92 93// CHECK: %[[STRUCT_BITFIELD1:.*]] = type { i8, i8, i8*, i32, i8*, [3 x i32], i8*, double, i8, i8 } 94 95// CHECK: define void @test_constructor_destructor_StrongOuter() 96// CHECK: %[[T:.*]] = alloca %[[STRUCT_STRONGOUTER:.*]], align 8 97// CHECK: %[[V0:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[T]] to i8** 98// CHECK: call void @__default_constructor_8_S_s16_s24(i8** %[[V0]]) 99// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[T]] to i8** 100// CHECK: call void @__destructor_8_S_s16_s24(i8** %[[V1]]) 101// CHECK: ret void 102 103// CHECK: define linkonce_odr hidden void @__default_constructor_8_S_s16_s24(i8** %[[DST:.*]]) 104// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 105// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 106// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 107// CHECK: call void @__default_constructor_8_s16(i8** %[[V0]]) 108// CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8* 109// CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 24 110// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8** 111// CHECK: %[[V4:.*]] = bitcast i8** %[[V3]] to i8* 112// CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 %[[V4]], i8 0, i64 8, i1 false) 113// CHECK: ret void 114 115// CHECK: define linkonce_odr hidden void @__default_constructor_8_s16(i8** %[[DST:.*]]) 116// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 117// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 118// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 119// CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8* 120// CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 16 121// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8** 122// CHECK: %[[V4:.*]] = bitcast i8** %[[V3]] to i8* 123// CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 %[[V4]], i8 0, i64 8, i1 false) 124// CHECK: ret void 125 126// CHECK: define linkonce_odr hidden void @__destructor_8_S_s16_s24(i8** %[[DST:.*]]) 127// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 128// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 129// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 130// CHECK: call void @__destructor_8_s16(i8** %[[V0]]) 131// CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8* 132// CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 24 133// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8** 134// CHECK: call void @llvm.objc.storeStrong(i8** %[[V3]], i8* null) 135// CHECK: ret void 136 137// CHECK: define linkonce_odr hidden void @__destructor_8_s16(i8** %[[DST:.*]]) 138// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 139// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 140// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 141// CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8* 142// CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 16 143// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8** 144// CHECK: call void @llvm.objc.storeStrong(i8** %[[V3]], i8* null) 145// CHECK: ret void 146 147void test_constructor_destructor_StrongOuter(void) { 148 StrongOuter t; 149} 150 151// CHECK: define void @test_copy_constructor_StrongOuter(%[[STRUCT_STRONGOUTER:.*]]* %[[S:.*]]) 152// CHECK: %[[S_ADDR:.*]] = alloca %[[STRUCT_STRONGOUTER]]*, align 8 153// CHECK: %[[T:.*]] = alloca %[[STRUCT_STRONGOUTER]], align 8 154// CHECK: store %[[STRUCT_STRONGOUTER]]* %[[S]], %[[STRUCT_STRONGOUTER]]** %[[S_ADDR]], align 8 155// CHECK: %[[V0:.*]] = load %[[STRUCT_STRONGOUTER]]*, %[[STRUCT_STRONGOUTER]]** %[[S_ADDR]], align 8 156// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[T]] to i8** 157// CHECK: %[[V2:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[V0]] to i8** 158// CHECK: call void @__copy_constructor_8_8_S_t0w16_s16_s24_t32w8(i8** %[[V1]], i8** %[[V2]]) 159// CHECK: %[[V3:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[T]] to i8** 160// CHECK: call void @__destructor_8_S_s16_s24(i8** %[[V3]]) 161// CHECK: ret void 162 163// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_S_t0w16_s16_s24_t32w8(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 164// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 165// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 166// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 167// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 168// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 169// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 170// CHECK: call void @__copy_constructor_8_8_t0w16_s16(i8** %[[V0]], i8** %[[V1]]) 171// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8* 172// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 24 173// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8** 174// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8* 175// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 24 176// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8** 177// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8 178// CHECK: %[[V9:.*]] = call i8* @llvm.objc.retain(i8* %[[V8]]) 179// CHECK: store i8* %[[V9]], i8** %[[V4]], align 8 180// CHECK: %[[V10:.*]] = bitcast i8** %[[V0]] to i8* 181// CHECK: %[[V11:.*]] = getelementptr inbounds i8, i8* %[[V10]], i64 32 182// CHECK: %[[V12:.*]] = bitcast i8* %[[V11]] to i8** 183// CHECK: %[[V13:.*]] = bitcast i8** %[[V1]] to i8* 184// CHECK: %[[V14:.*]] = getelementptr inbounds i8, i8* %[[V13]], i64 32 185// CHECK: %[[V15:.*]] = bitcast i8* %[[V14]] to i8** 186// CHECK: %[[V16:.*]] = bitcast i8** %[[V12]] to i64* 187// CHECK: %[[V17:.*]] = bitcast i8** %[[V15]] to i64* 188// CHECK: %[[V18:.*]] = load i64, i64* %[[V17]], align 8 189// CHECK: store i64 %[[V18]], i64* %[[V16]], align 8 190// CHECK: ret void 191 192// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_t0w16_s16(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 193// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 194// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 195// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 196// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 197// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 198// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 199// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8* 200// CHECK: %[[V3:.*]] = bitcast i8** %[[V1]] to i8* 201// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %[[V2]], i8* align 8 %[[V3]], i64 16, i1 false) 202// CHECK: %[[V4:.*]] = bitcast i8** %[[V0]] to i8* 203// CHECK: %[[V5:.*]] = getelementptr inbounds i8, i8* %[[V4]], i64 16 204// CHECK: %[[V6:.*]] = bitcast i8* %[[V5]] to i8** 205// CHECK: %[[V7:.*]] = bitcast i8** %[[V1]] to i8* 206// CHECK: %[[V8:.*]] = getelementptr inbounds i8, i8* %[[V7]], i64 16 207// CHECK: %[[V9:.*]] = bitcast i8* %[[V8]] to i8** 208// CHECK: %[[V10:.*]] = load i8*, i8** %[[V9]], align 8 209// CHECK: %[[V11:.*]] = call i8* @llvm.objc.retain(i8* %[[V10]]) 210// CHECK: store i8* %[[V11]], i8** %[[V6]], align 8 211// CHECK: ret void 212 213void test_copy_constructor_StrongOuter(StrongOuter *s) { 214 StrongOuter t = *s; 215} 216 217/// CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_S_t0w16_s16_s24_t32w8(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 218// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 219// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 220// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 221// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 222// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 223// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 224// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8* 225// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 24 226// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8** 227// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8* 228// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 24 229// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8** 230// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8 231// CHECK: call void @llvm.objc.storeStrong(i8** %[[V4]], i8* %[[V8]]) 232 233void test_copy_assignment_StrongOuter(StrongOuter *d, StrongOuter *s) { 234 *d = *s; 235} 236 237// CHECK: define void @test_move_constructor_StrongOuter() 238// CHECK: %[[T1:.*]] = getelementptr inbounds %[[STRUCT_BLOCK_BYREF_T:.*]], %[[STRUCT_BLOCK_BYREF_T]]* %{{.*}}, i32 0, i32 7 239// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[T1]] to i8** 240// CHECK: call void @__default_constructor_8_S_s16_s24(i8** %[[V1]]) 241// CHECK: %[[T2:.*]] = getelementptr inbounds %[[STRUCT_BLOCK_BYREF_T]], %[[STRUCT_BLOCK_BYREF_T]]* %{{.*}}, i32 0, i32 7 242// CHECK: %[[V9:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[T2]] to i8** 243// CHECK: call void @__destructor_8_S_s16_s24(i8** %[[V9]]) 244 245// CHECK: define internal void @__Block_byref_object_copy_(i8*, i8*) 246// CHECK: call void @__move_constructor_8_8_S_t0w16_s16_s24_t32w8( 247 248// CHECK: define linkonce_odr hidden void @__move_constructor_8_8_S_t0w16_s16_s24_t32w8(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 249// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 250// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 251// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 252// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 253// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 254// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 255// CHECK: call void @__move_constructor_8_8_t0w16_s16(i8** %[[V0]], i8** %[[V1]]) 256// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8* 257// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 24 258// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8** 259// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8* 260// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 24 261// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8** 262// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8 263// CHECK: store i8* null, i8** %[[V7]], align 8 264// CHECK: store i8* %[[V8]], i8** %[[V4]], align 8 265 266// CHECK: define internal void @__Block_byref_object_dispose_(i8*) 267// CHECK: call void @__destructor_8_S_s16_s24( 268 269void test_move_constructor_StrongOuter(void) { 270 __block StrongOuter t; 271 BlockTy b = ^{ (void)t; }; 272} 273 274// CHECK: define linkonce_odr hidden void @__move_assignment_8_8_S_t0w16_s16_s24_t32w8(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 275// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 276// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 277// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 278// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 279// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 280// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 281// CHECK: call void @__move_assignment_8_8_t0w16_s16(i8** %[[V0]], i8** %[[V1]]) 282// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8* 283// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 24 284// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8** 285// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8* 286// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 24 287// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8** 288// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8 289// CHECK: store i8* null, i8** %[[V7]], align 8 290// CHECK: %[[V9:.*]] = load i8*, i8** %[[V4]], align 8 291// CHECK: store i8* %[[V8]], i8** %[[V4]], align 8 292// CHECK: call void @llvm.objc.release(i8* %[[V9]]) 293 294void test_move_assignment_StrongOuter(StrongOuter *p) { 295 *p = getStrongOuter(); 296} 297 298// CHECK: define linkonce_odr hidden void @__default_constructor_8_s0_S_s24(i8** %[[DST:.*]]) 299// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 300// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 301// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 302// CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8* 303// CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 %[[V1]], i8 0, i64 8, i1 false) 304// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8* 305// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 8 306// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8** 307// CHECK: call void @__default_constructor_8_s16(i8** %[[V4]]) 308 309// CHECK: define linkonce_odr hidden void @__destructor_8_s0_S_s24(i8** %[[DST:.*]]) 310// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 311// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 312// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 313// CHECK: call void @llvm.objc.storeStrong(i8** %[[V0]], i8* null) 314// CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8* 315// CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 8 316// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8** 317// CHECK: call void @__destructor_8_s16(i8** %[[V3]]) 318 319void test_constructor_destructor_StrongOuter2(void) { 320 StrongOuter2 t; 321} 322 323// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_s0_S_t8w16_s24(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 324// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 325// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 326// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 327// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 328// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 329// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 330// CHECK: %[[V2:.*]] = load i8*, i8** %[[V1]], align 8 331// CHECK: %[[V3:.*]] = call i8* @llvm.objc.retain(i8* %[[V2]]) 332// CHECK: store i8* %[[V3]], i8** %[[V0]], align 8 333// CHECK: %[[V4:.*]] = bitcast i8** %[[V0]] to i8* 334// CHECK: %[[V5:.*]] = getelementptr inbounds i8, i8* %[[V4]], i64 8 335// CHECK: %[[V6:.*]] = bitcast i8* %[[V5]] to i8** 336// CHECK: %[[V7:.*]] = bitcast i8** %[[V1]] to i8* 337// CHECK: %[[V8:.*]] = getelementptr inbounds i8, i8* %[[V7]], i64 8 338// CHECK: %[[V9:.*]] = bitcast i8* %[[V8]] to i8** 339// CHECK: call void @__copy_constructor_8_8_t0w16_s16(i8** %[[V6]], i8** %[[V9]]) 340 341void test_copy_constructor_StrongOuter2(StrongOuter2 *s) { 342 StrongOuter2 t = *s; 343} 344 345// CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_s0_S_t8w16_s24(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 346// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 347// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 348// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 349// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 350// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 351// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 352// CHECK: %[[V2:.*]] = load i8*, i8** %[[V1]], align 8 353// CHECK: call void @llvm.objc.storeStrong(i8** %[[V0]], i8* %[[V2]]) 354// CHECK: %[[V3:.*]] = bitcast i8** %[[V0]] to i8* 355// CHECK: %[[V4:.*]] = getelementptr inbounds i8, i8* %[[V3]], i64 8 356// CHECK: %[[V5:.*]] = bitcast i8* %[[V4]] to i8** 357// CHECK: %[[V6:.*]] = bitcast i8** %[[V1]] to i8* 358// CHECK: %[[V7:.*]] = getelementptr inbounds i8, i8* %[[V6]], i64 8 359// CHECK: %[[V8:.*]] = bitcast i8* %[[V7]] to i8** 360// CHECK: call void @__copy_assignment_8_8_t0w16_s16(i8** %[[V5]], i8** %[[V8]]) 361 362void test_copy_assignment_StrongOuter2(StrongOuter2 *d, StrongOuter2 *s) { 363 *d = *s; 364} 365 366// CHECK: define linkonce_odr hidden void @__move_constructor_8_8_s0_S_t8w16_s24(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 367// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 368// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 369// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 370// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 371// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 372// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 373// CHECK: %[[V2:.*]] = load i8*, i8** %[[V1]], align 8 374// CHECK: store i8* null, i8** %[[V1]], align 8 375// CHECK: store i8* %[[V2]], i8** %[[V0]], align 8 376// CHECK: %[[V3:.*]] = bitcast i8** %[[V0]] to i8* 377// CHECK: %[[V4:.*]] = getelementptr inbounds i8, i8* %[[V3]], i64 8 378// CHECK: %[[V5:.*]] = bitcast i8* %[[V4]] to i8** 379// CHECK: %[[V6:.*]] = bitcast i8** %[[V1]] to i8* 380// CHECK: %[[V7:.*]] = getelementptr inbounds i8, i8* %[[V6]], i64 8 381// CHECK: %[[V8:.*]] = bitcast i8* %[[V7]] to i8** 382// CHECK: call void @__move_constructor_8_8_t0w16_s16(i8** %[[V5]], i8** %[[V8]]) 383 384void test_move_constructor_StrongOuter2(void) { 385 __block StrongOuter2 t; 386 BlockTy b = ^{ (void)t; }; 387} 388 389// CHECK: define linkonce_odr hidden void @__move_assignment_8_8_s0_S_t8w16_s24(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 390// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 391// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 392// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 393// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 394// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 395// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 396// CHECK: %[[V2:.*]] = load i8*, i8** %[[V1]], align 8 397// CHECK: store i8* null, i8** %[[V1]], align 8 398// CHECK: %[[V3:.*]] = load i8*, i8** %[[V0]], align 8 399// CHECK: store i8* %[[V2]], i8** %[[V0]], align 8 400// CHECK: call void @llvm.objc.release(i8* %[[V3]]) 401// CHECK: %[[V4:.*]] = bitcast i8** %[[V0]] to i8* 402// CHECK: %[[V5:.*]] = getelementptr inbounds i8, i8* %[[V4]], i64 8 403// CHECK: %[[V6:.*]] = bitcast i8* %[[V5]] to i8** 404// CHECK: %[[V7:.*]] = bitcast i8** %[[V1]] to i8* 405// CHECK: %[[V8:.*]] = getelementptr inbounds i8, i8* %[[V7]], i64 8 406// CHECK: %[[V9:.*]] = bitcast i8* %[[V8]] to i8** 407// CHECK: call void @__move_assignment_8_8_t0w16_s16(i8** %[[V6]], i8** %[[V9]]) 408 409void test_move_assignment_StrongOuter2(StrongOuter2 *p) { 410 *p = getStrongOuter2(); 411} 412 413// CHECK: define void @test_parameter_StrongSmall([2 x i64] %[[A_COERCE:.*]]) 414// CHECK: %[[A:.*]] = alloca %[[STRUCT_STRONG:.*]], align 8 415// CHECK: %[[V0:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to [2 x i64]* 416// CHECK: store [2 x i64] %[[A_COERCE]], [2 x i64]* %[[V0]], align 8 417// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to i8** 418// CHECK: call void @__destructor_8_s8(i8** %[[V1]]) 419// CHECK: ret void 420 421void test_parameter_StrongSmall(StrongSmall a) { 422} 423 424// CHECK: define void @test_argument_StrongSmall([2 x i64] %[[A_COERCE:.*]]) 425// CHECK: %[[A:.*]] = alloca %[[STRUCT_STRONGSMALL:.*]], align 8 426// CHECK: %[[TEMP_LVALUE:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8 427// CHECK: %[[V0:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[A]] to [2 x i64]* 428// CHECK: store [2 x i64] %[[A_COERCE]], [2 x i64]* %[[V0]], align 8 429// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[TEMP_LVALUE]] to i8** 430// CHECK: %[[V2:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[A]] to i8** 431// CHECK: call void @__copy_constructor_8_8_t0w4_s8(i8** %[[V1]], i8** %[[V2]]) 432// CHECK: %[[V3:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[TEMP_LVALUE]] to [2 x i64]* 433// CHECK: %[[V4:.*]] = load [2 x i64], [2 x i64]* %[[V3]], align 8 434// CHECK: call void @calleeStrongSmall([2 x i64] %[[V4]]) 435// CHECK: %[[V5:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[A]] to i8** 436// CHECK: call void @__destructor_8_s8(i8** %[[V5]]) 437// CHECK: ret void 438 439void test_argument_StrongSmall(StrongSmall a) { 440 calleeStrongSmall(a); 441} 442 443// CHECK: define [2 x i64] @test_return_StrongSmall([2 x i64] %[[A_COERCE:.*]]) 444// CHECK: %[[RETVAL:.*]] = alloca %[[STRUCT_STRONGSMALL:.*]], align 8 445// CHECK: %[[A:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8 446// CHECK: %[[V0:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[A]] to [2 x i64]* 447// CHECK: store [2 x i64] %[[A_COERCE]], [2 x i64]* %[[V0]], align 8 448// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[RETVAL]] to i8** 449// CHECK: %[[V2:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[A]] to i8** 450// CHECK: call void @__copy_constructor_8_8_t0w4_s8(i8** %[[V1]], i8** %[[V2]]) 451// CHECK: %[[V3:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[A]] to i8** 452// CHECK: call void @__destructor_8_s8(i8** %[[V3]]) 453// CHECK: %[[V4:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[RETVAL]] to [2 x i64]* 454// CHECK: %[[V5:.*]] = load [2 x i64], [2 x i64]* %[[V4]], align 8 455// CHECK: ret [2 x i64] %[[V5]] 456 457StrongSmall test_return_StrongSmall(StrongSmall a) { 458 return a; 459} 460 461// CHECK: define void @test_destructor_ignored_result() 462// CHECK: %[[COERCE:.*]] = alloca %[[STRUCT_STRONGSMALL:.*]], align 8 463// CHECK: %[[CALL:.*]] = call [2 x i64] @getStrongSmall() 464// CHECK: %[[V0:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[COERCE]] to [2 x i64]* 465// CHECK: store [2 x i64] %[[CALL]], [2 x i64]* %[[V0]], align 8 466// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[COERCE]] to i8** 467// CHECK: call void @__destructor_8_s8(i8** %[[V1]]) 468// CHECK: ret void 469 470void test_destructor_ignored_result(void) { 471 getStrongSmall(); 472} 473 474// CHECK: define void @test_copy_constructor_StrongBlock( 475// CHECK: call void @__copy_constructor_8_8_sb0( 476// CHECK: call void @__destructor_8_sb0( 477// CHECK: ret void 478 479// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_sb0(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 480// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 481// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 482// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 483// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 484// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 485// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 486// CHECK: %[[V2:.*]] = load i8*, i8** %[[V1]], align 8 487// CHECK: %[[V3:.*]] = call i8* @llvm.objc.retainBlock(i8* %[[V2]]) 488// CHECK: store i8* %[[V3]], i8** %[[V0]], align 8 489// CHECK: ret void 490 491void test_copy_constructor_StrongBlock(StrongBlock *s) { 492 StrongBlock t = *s; 493} 494 495// CHECK: define void @test_copy_assignment_StrongBlock(%[[STRUCT_STRONGBLOCK:.*]]* %[[D:.*]], %[[STRUCT_STRONGBLOCK]]* %[[S:.*]]) 496// CHECK: call void @__copy_assignment_8_8_sb0( 497 498// CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_sb0(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 499// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 500// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 501// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 502// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 503// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 504// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 505// CHECK: %[[V2:.*]] = load i8*, i8** %[[V1]], align 8 506// CHECK: %[[V3:.*]] = call i8* @llvm.objc.retainBlock(i8* %[[V2]]) 507// CHECK: %[[V4:.*]] = load i8*, i8** %[[V0]], align 8 508// CHECK: store i8* %[[V3]], i8** %[[V0]], align 8 509// CHECK: call void @llvm.objc.release(i8* %[[V4]]) 510// CHECK: ret void 511 512void test_copy_assignment_StrongBlock(StrongBlock *d, StrongBlock *s) { 513 *d = *s; 514} 515 516// CHECK: define void @test_copy_constructor_StrongVolatile0( 517// CHECK: call void @__copy_constructor_8_8_t0w4_sv8( 518// CHECK: call void @__destructor_8_sv8( 519 520// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_t0w4_sv8( 521// CHECK: %[[V8:.*]] = load volatile i8*, i8** %{{.*}}, align 8 522// CHECK: %[[V9:.*]] = call i8* @llvm.objc.retain(i8* %[[V8]]) 523// CHECK: store volatile i8* %[[V9]], i8** %{{.*}}, align 8 524 525void test_copy_constructor_StrongVolatile0(StrongVolatile *s) { 526 StrongVolatile t = *s; 527} 528 529// CHECK: define void @test_copy_constructor_StrongVolatile1( 530// CHECK: call void @__copy_constructor_8_8_tv0w128_sv16( 531 532void test_copy_constructor_StrongVolatile1(Strong *s) { 533 volatile Strong t = *s; 534} 535 536// CHECK: define void @test_block_capture_Strong() 537// CHECK: call void @__default_constructor_8_s16( 538// CHECK: call void @__copy_constructor_8_8_t0w16_s16( 539// CHECK: call void @__destructor_8_s16( 540// CHECK: call void @__destructor_8_s16( 541// CHECK: ret void 542 543// CHECK: define linkonce_odr hidden void @__copy_helper_block_8_32n13_8_8_t0w16_s16(i8*, i8*) 544// CHECK: call void @__copy_constructor_8_8_t0w16_s16( 545// CHECK: ret void 546 547// CHECK: define linkonce_odr hidden void @__destroy_helper_block_8_32n5_8_s16( 548// CHECK: call void @__destructor_8_s16( 549// CHECK: ret void 550 551void test_block_capture_Strong(void) { 552 Strong t; 553 BlockTy b = ^(){ (void)t; }; 554} 555 556// CHECK: define void @test_variable_length_array(i32 %[[N:.*]]) 557// CHECK: %[[N_ADDR:.*]] = alloca i32, align 4 558// CHECK: store i32 %[[N]], i32* %[[N_ADDR]], align 4 559// CHECK: %[[V0:.*]] = load i32, i32* %[[N_ADDR]], align 4 560// CHECK: %[[V1:.*]] = zext i32 %[[V0]] to i64 561// CHECK: %[[VLA:.*]] = alloca %[[STRUCT_STRONG:.*]], i64 %[[V1]], align 8 562// CHECK: %[[V3:.*]] = bitcast %[[STRUCT_STRONG]]* %[[VLA]] to i8** 563// CHECK: %[[V4:.*]] = mul nuw i64 24, %[[V1]] 564// CHECK: %[[V5:.*]] = bitcast i8** %[[V3]] to i8* 565// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 %[[V4]] 566// CHECK: %[[DSTARRAY_END:.*]] = bitcast i8* %[[V6]] to i8** 567// CHECK: br label 568 569// CHECK: %[[DSTADDR_CUR:.*]] = phi i8** [ %[[V3]], {{.*}} ], [ %[[V7:.*]], {{.*}} ] 570// CHECK: %[[DONE:.*]] = icmp eq i8** %[[DSTADDR_CUR]], %[[DSTARRAY_END]] 571// CHECK: br i1 %[[DONE]], label 572 573// CHECK: call void @__default_constructor_8_s16(i8** %[[DSTADDR_CUR]]) 574// CHECK: %[[V8:.*]] = bitcast i8** %[[DSTADDR_CUR]] to i8* 575// CHECK: %[[V9:.*]] = getelementptr inbounds i8, i8* %[[V8]], i64 24 576// CHECK: %[[V7]] = bitcast i8* %[[V9]] to i8** 577// CHECK: br label 578 579// CHECK: call void @func(%[[STRUCT_STRONG]]* %[[VLA]]) 580// CHECK: %[[V10:.*]] = getelementptr inbounds %[[STRUCT_STRONG]], %[[STRUCT_STRONG]]* %[[VLA]], i64 %[[V1]] 581// CHECK: %[[ARRAYDESTROY_ISEMPTY:.*]] = icmp eq %[[STRUCT_STRONG]]* %[[VLA]], %[[V10]] 582// CHECK: br i1 %[[ARRAYDESTROY_ISEMPTY]], label 583 584// CHECK: %[[ARRAYDESTROY_ELEMENTPAST:.*]] = phi %[[STRUCT_STRONG]]* [ %[[V10]], {{.*}} ], [ %[[ARRAYDESTROY_ELEMENT:.*]], {{.*}} ] 585// CHECK: %[[ARRAYDESTROY_ELEMENT]] = getelementptr inbounds %[[STRUCT_STRONG]], %[[STRUCT_STRONG]]* %[[ARRAYDESTROY_ELEMENTPAST]], i64 -1 586// CHECK: %[[V11:.*]] = bitcast %[[STRUCT_STRONG]]* %[[ARRAYDESTROY_ELEMENT]] to i8** 587// CHECK: call void @__destructor_8_s16(i8** %[[V11]]) 588// CHECK: %[[ARRAYDESTROY_DONE:.*]] = icmp eq %[[STRUCT_STRONG]]* %[[ARRAYDESTROY_ELEMENT]], %[[VLA]] 589// CHECK: br i1 %[[ARRAYDESTROY_DONE]], label 590 591// CHECK: ret void 592 593void test_variable_length_array(int n) { 594 Strong a[n]; 595 func(a); 596} 597 598// CHECK: define linkonce_odr hidden void @__default_constructor_8_AB8s8n4_s8_AE( 599// CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 %{{.*}}, i8 0, i64 32, i1 false) 600void test_constructor_destructor_IDArray(void) { 601 IDArray t; 602} 603 604// CHECK: define linkonce_odr hidden void @__default_constructor_8_AB8s24n4_S_s24_AE( 605void test_constructor_destructor_StructArray(void) { 606 StructArray t; 607} 608 609// Test that StructArray's field 'd' is copied before entering the loop. 610 611// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_t0w8_AB8s24n4_S_t8w16_s24_AE(i8** %[[DST:.*]], i8** %[[SRC:.*]]) 612// CHECK: entry: 613// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8 614// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8 615// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8 616// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8 617// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8 618// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8 619// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i64* 620// CHECK: %[[V3:.*]] = bitcast i8** %[[V1]] to i64* 621// CHECK: %[[V4:.*]] = load i64, i64* %[[V3]], align 8 622// CHECK: store i64 %[[V4]], i64* %[[V2]], align 8 623 624// CHECK: phi i8** 625// CHECK: phi i8** 626 627// CHECK: phi i8** 628// CHECK: phi i8** 629 630// CHECK-NOT: load i64, i64* % 631// CHECK-NOT: store i64 % 632// CHECK: call void @__copy_constructor_8_8_t0w16_s16( 633 634void test_copy_constructor_StructArray(StructArray a) { 635 StructArray t = a; 636} 637 638// Check that IRGen copies the 9-bit bitfield emitting i16 load and store. 639 640// CHECK: define void @test_copy_constructor_Bitfield0( 641 642// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_s0_t8w2( 643// CHECK: %[[V4:.*]] = bitcast i8** %{{.*}} to i8* 644// CHECK: %[[V5:.*]] = getelementptr inbounds i8, i8* %[[V4]], i64 8 645// CHECK: %[[V6:.*]] = bitcast i8* %[[V5]] to i8** 646// CHECK: %[[V7:.*]] = bitcast i8** %{{.*}} to i8* 647// CHECK: %[[V8:.*]] = getelementptr inbounds i8, i8* %[[V7]], i64 8 648// CHECK: %[[V9:.*]] = bitcast i8* %[[V8]] to i8** 649// CHECK: %[[V10:.*]] = bitcast i8** %[[V6]] to i16* 650// CHECK: %[[V11:.*]] = bitcast i8** %[[V9]] to i16* 651// CHECK: %[[V12:.*]] = load i16, i16* %[[V11]], align 8 652// CHECK: store i16 %[[V12]], i16* %[[V10]], align 8 653// CHECK: ret void 654 655void test_copy_constructor_Bitfield0(Bitfield0 *a) { 656 Bitfield0 t = *a; 657} 658 659// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_t0w2_s8_t16w4_s24_t32w12_s48_t56w9_tv513w2_tv520w8 660// CHECK: %[[V4:.*]] = load i16, i16* %{{.*}}, align 8 661// CHECK: store i16 %[[V4]], i16* %{{.*}}, align 8 662// CHECK: %[[V21:.*]] = load i32, i32* %{{.*}}, align 8 663// CHECK: store i32 %[[V21]], i32* %{{.*}}, align 8 664// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %{{.*}}, i8* align 8 %{{.*}}, i64 12, i1 false) 665// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %{{.*}}, i8* align 8 %{{.*}}, i64 9, i1 false) 666// CHECK: %[[V54:.*]] = bitcast i8** %[[V0:.*]] to %[[STRUCT_BITFIELD1]]* 667// CHECK: %[[I5:.*]] = getelementptr inbounds %[[STRUCT_BITFIELD1]], %[[STRUCT_BITFIELD1]]* %[[V54]], i32 0, i32 8 668// CHECK: %[[V55:.*]] = bitcast i8** %[[V1:.*]] to %[[STRUCT_BITFIELD1]]* 669// CHECK: %[[I51:.*]] = getelementptr inbounds %[[STRUCT_BITFIELD1]], %[[STRUCT_BITFIELD1]]* %[[V55]], i32 0, i32 8 670// CHECK: %[[BF_LOAD:.*]] = load volatile i8, i8* %[[I51]], align 8 671// CHECK: %[[BF_SHL:.*]] = shl i8 %[[BF_LOAD]], 5 672// CHECK: %[[BF_ASHR:.*]] = ashr i8 %[[BF_SHL]], 6 673// CHECK: %[[BF_CAST:.*]] = sext i8 %[[BF_ASHR]] to i32 674// CHECK: %[[V56:.*]] = trunc i32 %[[BF_CAST]] to i8 675// CHECK: %[[BF_LOAD2:.*]] = load volatile i8, i8* %[[I5]], align 8 676// CHECK: %[[BF_VALUE:.*]] = and i8 %[[V56]], 3 677// CHECK: %[[BF_SHL3:.*]] = shl i8 %[[BF_VALUE]], 1 678// CHECK: %[[BF_CLEAR:.*]] = and i8 %[[BF_LOAD2]], -7 679// CHECK: %[[BF_SET:.*]] = or i8 %[[BF_CLEAR]], %[[BF_SHL3]] 680// CHECK: store volatile i8 %[[BF_SET]], i8* %[[I5]], align 8 681// CHECK: %[[V57:.*]] = bitcast i8** %[[V0]] to %[[STRUCT_BITFIELD1]]* 682// CHECK: %[[I6:.*]] = getelementptr inbounds %[[STRUCT_BITFIELD1]], %[[STRUCT_BITFIELD1]]* %[[V57]], i32 0, i32 9 683// CHECK: %[[V58:.*]] = bitcast i8** %[[V1]] to %[[STRUCT_BITFIELD1]]* 684// CHECK: %[[I64:.*]] = getelementptr inbounds %[[STRUCT_BITFIELD1]], %[[STRUCT_BITFIELD1]]* %[[V58]], i32 0, i32 9 685// CHECK: %[[V59:.*]] = load volatile i8, i8* %[[I64]], align 1 686// CHECK: store volatile i8 %[[V59]], i8* %[[I6]], align 1 687 688void test_copy_constructor_Bitfield1(Bitfield1 *a) { 689 Bitfield1 t = *a; 690} 691 692// CHECK: define void @test_strong_in_union() 693// CHECK: alloca %{{.*}} 694// CHECK-NEXT: ret void 695 696void test_strong_in_union() { 697 U t; 698} 699 700// CHECK: define void @test_copy_constructor_VolatileArray( 701// CHECK: call void @__copy_constructor_8_8_s0_AB8s4n16_tv64w32_AE( 702 703// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_s0_AB8s4n16_tv64w32_AE( 704// CHECK: %[[ADDR_CUR:.*]] = phi i8** 705// CHECK: %[[ADDR_CUR1:.*]] = phi i8** 706// CHECK: %[[V12:.*]] = bitcast i8** %[[ADDR_CUR]] to i32* 707// CHECK: %[[V13:.*]] = bitcast i8** %[[ADDR_CUR1]] to i32* 708// CHECK: %[[V14:.*]] = load volatile i32, i32* %[[V13]], align 4 709// CHECK: store volatile i32 %[[V14]], i32* %[[V12]], align 4 710 711void test_copy_constructor_VolatileArray(VolatileArray *a) { 712 VolatileArray t = *a; 713} 714 715#endif /* USESTRUCT */ 716