ahatanak updated this revision to Diff 127233.
ahatanak added a comment.
Insert an underscore before src-alignment in the BNF rule for alignment-info.
<alignment-info> ::= <dst-alignment> ["_" <src-alignment>]
https://reviews.llvm.org/D41228
Files:
include/clang/AST/Decl.h
include/clang/AST/Type.h
include/clang/Basic/DiagnosticSemaKinds.td
lib/AST/ASTContext.cpp
lib/AST/Decl.cpp
lib/AST/Type.cpp
lib/CodeGen/CGBlocks.cpp
lib/CodeGen/CGCall.cpp
lib/CodeGen/CGDecl.cpp
lib/CodeGen/CGDeclCXX.cpp
lib/CodeGen/CGExprAgg.cpp
lib/CodeGen/CMakeLists.txt
lib/CodeGen/CodeGenCStruct.cpp
lib/CodeGen/CodeGenFunction.cpp
lib/CodeGen/CodeGenFunction.h
lib/Sema/JumpDiagnostics.cpp
lib/Sema/SemaDecl.cpp
lib/Sema/SemaExpr.cpp
test/ARCMT/checking.m
test/CodeGenObjC/strong-in-c-struct.m
test/SemaObjC/arc-decls.m
test/SemaObjC/arc-system-header.m
test/SemaObjC/strong-in-c-struct.m
Index: test/SemaObjC/strong-in-c-struct.m
===================================================================
--- /dev/null
+++ test/SemaObjC/strong-in-c-struct.m
@@ -0,0 +1,56 @@
+// RUN: %clang_cc1 -triple arm64-apple-ios11 -fobjc-arc -fblocks -fobjc-runtime=ios-11.0 -fsyntax-only -verify %s
+
+typedef struct {
+ id a;
+} Strong;
+
+void callee_variadic(const char *, ...);
+
+void test_variadic(void) {
+ Strong t;
+ callee_variadic("s", t); // expected-error {{cannot pass non-trivial C object of type 'Strong' by value to variadic function}}
+}
+
+void test_jump0(int cond) {
+ switch (cond) {
+ case 0:
+ ;
+ Strong x; // expected-note {{jump bypasses initialization of variable of non-trivial C struct type}}
+ break;
+ case 1: // expected-error {{cannot jump from switch statement to this case label}}
+ x.a = 0;
+ break;
+ }
+}
+
+void test_jump1(void) {
+ static void *ips[] = { &&L0 };
+L0: // expected-note {{possible target of indirect goto}}
+ ;
+ Strong x; // expected-note {{jump exits scope of variable with non-trivial destructor}}
+ goto *ips; // expected-error {{cannot jump}}
+}
+
+typedef void (^BlockTy)(void);
+void func(BlockTy);
+void func2(Strong);
+
+void test_block_scope0(int cond) {
+ Strong x; // expected-note {{jump enters lifetime of block which captures a C struct that is non-trivial to destroy}}
+ switch (cond) {
+ case 0:
+ func(^{ func2(x); });
+ break;
+ default: // expected-error {{cannot jump from switch statement to this case label}}
+ break;
+ }
+}
+
+void test_block_scope1(void) {
+ static void *ips[] = { &&L0 };
+L0: // expected-note {{possible target of indirect goto}}
+ ;
+ Strong x; // expected-note {{jump exits scope of variable with non-trivial destructor}} expected-note {{jump exits lifetime of block which captures a C struct that is non-trivial to destroy}}
+ func(^{ func2(x); });
+ goto *ips; // expected-error {{cannot jump}}
+}
Index: test/SemaObjC/arc-system-header.m
===================================================================
--- test/SemaObjC/arc-system-header.m
+++ test/SemaObjC/arc-system-header.m
@@ -23,8 +23,7 @@
}
void test5(struct Test5 *p) {
- p->field = 0; // expected-error {{'field' is unavailable in ARC}}
- // [email protected]:25 {{field has non-trivial ownership qualification}}
+ p->field = 0;
}
id test6() {
@@ -49,8 +48,7 @@
extern void doSomething(Test9 arg);
void test9() {
- Test9 foo2 = {0, 0}; // expected-error {{'field' is unavailable in ARC}}
- // [email protected]:56 {{field has non-trivial ownership qualification}}
+ Test9 foo2 = {0, 0};
doSomething(foo2);
}
#endif
Index: test/SemaObjC/arc-decls.m
===================================================================
--- test/SemaObjC/arc-decls.m
+++ test/SemaObjC/arc-decls.m
@@ -3,7 +3,7 @@
// rdar://8843524
struct A {
- id x; // expected-error {{ARC forbids Objective-C objects in struct}}
+ id x;
};
union u {
@@ -13,7 +13,7 @@
@interface I {
struct A a;
struct B {
- id y[10][20]; // expected-error {{ARC forbids Objective-C objects in struct}}
+ id y[10][20];
id z;
} b;
@@ -23,7 +23,7 @@
// rdar://10260525
struct r10260525 {
- id (^block) (); // expected-error {{ARC forbids blocks in struct}}
+ id (^block) ();
};
struct S {
Index: test/CodeGenObjC/strong-in-c-struct.m
===================================================================
--- /dev/null
+++ test/CodeGenObjC/strong-in-c-struct.m
@@ -0,0 +1,495 @@
+// RUN: %clang_cc1 -triple arm64-apple-ios11 -fobjc-arc -fblocks -fobjc-runtime=ios-11.0 -emit-llvm -o - %s | FileCheck %s
+
+typedef void (^BlockTy)(void);
+
+typedef struct {
+ int f0;
+ id f1;
+} Strong;
+
+typedef struct {
+ Strong f0;
+ id f1;
+} StrongOuter;
+
+typedef struct {
+ int f0;
+ volatile id f1;
+} StrongVolatile;
+
+typedef struct {
+ BlockTy f0;
+} StrongBlock;
+
+typedef struct {
+ int i;
+ id f0[2][2];
+} IDArray;
+
+typedef struct {
+ double d;
+ Strong f0[2][2];
+} StructArray;
+
+Strong getStrong(void);
+StrongOuter getStrongOuter(void);
+void calleeStrong(Strong);
+void func(Strong *);
+
+
+// CHECK: define void @test_constructor_destructor_StrongOuter()
+// CHECK: %[[T:.*]] = alloca %[[STRUCT_StrongOuter:.*]], align 8
+// CHECK: %[[V0:.*]] = bitcast %[[STRUCT_StrongOuter]]* %[[T]] to i8*
+// CHECK: call void @__default_constructor_8_s8_s16(i8** %[[V0]])
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__default_constructor_8_s8_s16(i8** %[[DST:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: call void @__default_constructor_8_s8(i8** %[[V0]])
+// CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 16
+// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8**
+// CHECK: %[[V4:.*]] = bitcast i8** %[[V3]] to i8*
+// CHECK: call void @llvm.memset.p0i8.i64(i8* %[[V4]], i8 0, i64 8, i32 8, i1 false)
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__default_constructor_8_s8(i8** %[[DST:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 8
+// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8**
+// CHECK: %[[V4:.*]] = bitcast i8** %[[V3]] to i8*
+// CHECK: call void @llvm.memset.p0i8.i64(i8* %[[V4]], i8 0, i64 8, i32 8, i1 false)
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__destructor_8_s8_s16(i8** %[[DST:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: call void @__destructor_8_s8(i8** %[[V0]])
+// CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 16
+// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8**
+// CHECK: call void @objc_storeStrong(i8** %[[V3]], i8* null)
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__destructor_8_s8(i8** %[[DST:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V2:.*]] = getelementptr inbounds i8, i8* %[[V1]], i64 8
+// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to i8**
+// CHECK: call void @objc_storeStrong(i8** %[[V3]], i8* null)
+// CHECK: ret void
+
+void test_constructor_destructor_StrongOuter(void) {
+ StrongOuter t;
+}
+
+// CHECK: define void @test_copy_constructor_StrongOuter(%[[STRUCT_STRONGOUTER:.*]]* %[[S:.*]])
+// CHECK: %[[S_ADDR:.*]] = alloca %[[STRUCT_STRONGOUTER]]*, align 8
+// CHECK: %[[T:.*]] = alloca %[[STRUCT_STRONGOUTER]], align 8
+// CHECK: store %[[STRUCT_STRONGOUTER]]* %[[S]], %[[STRUCT_STRONGOUTER]]** %[[S_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load %[[STRUCT_STRONGOUTER]]*, %[[STRUCT_STRONGOUTER]]** %[[S_ADDR]], align 8
+// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[T]] to i8*
+// CHECK: %[[V2:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[V0]] to i8*
+// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[V1]], i8* %[[V2]], i64 24, i32 8, i1 false)
+// CHECK: %[[V3:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[T]] to i8**
+// CHECK: %[[V4:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[V0]] to i8**
+// CHECK: call void @__copy_constructor_8_8_s8_s16(i8** %[[V3]], i8** %[[V4]])
+// CHECK: %[[V5:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[T]] to i8**
+// CHECK: call void @__destructor_8_s8_s16(i8** %[[V5]])
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_s8_s16(i8** %[[DST:.*]], i8** %[[SRC:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
+// CHECK: call void @__copy_constructor_8_8_s8(i8** %[[V0]], i8** %[[V1]])
+// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 16
+// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
+// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
+// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 16
+// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
+// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
+// CHECK: %[[V9:.*]] = call i8* @objc_retain(i8* %[[V8]])
+// CHECK: store i8* %[[V9]], i8** %[[V4]], align 8
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_s8(i8** %[[DST:.*]], i8** %[[SRC:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 8
+// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
+// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
+// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 8
+// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
+// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
+// CHECK: %[[V9:.*]] = call i8* @objc_retain(i8* %[[V8]])
+// CHECK: store i8* %[[V9]], i8** %[[V4]], align 8
+// CHECK: ret void
+
+void test_copy_constructor_StrongOuter(StrongOuter *s) {
+ StrongOuter t = *s;
+}
+
+// CHECK: define void @test_copy_assignment_StrongOuter(%[[STRUCT_STRONGOUTER:.*]]* %[[D:.*]], %[[STRUCT_STRONGOUTER]]* %[[S:.*]])
+// CHECK: %[[D_ADDR:.*]] = alloca %[[STRUCT_STRONGOUTER]]*, align 8
+// CHECK: %[[S_ADDR:.*]] = alloca %[[STRUCT_STRONGOUTER]]*, align 8
+// CHECK: store %[[STRUCT_STRONGOUTER]]* %[[D]], %[[STRUCT_STRONGOUTER]]** %[[D_ADDR]], align 8
+// CHECK: store %[[STRUCT_STRONGOUTER]]* %[[S]], %[[STRUCT_STRONGOUTER]]** %[[S_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load %[[STRUCT_STRONGOUTER]]*, %[[STRUCT_STRONGOUTER]]** %[[D_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load %[[STRUCT_STRONGOUTER]]*, %[[STRUCT_STRONGOUTER]]** %[[S_ADDR]], align 8
+// CHECK: %[[V2:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[V0]] to i8*
+// CHECK: %[[V3:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[V1]] to i8*
+// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[V2]], i8* %[[V3]], i64 24, i32 8, i1 false)
+// CHECK: %[[V4:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[V0]] to i8**
+// CHECK: %[[V5:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[V1]] to i8**
+// CHECK: call void @__copy_assignment_8_8_s8_s16(i8** %[[V4]], i8** %[[V5]])
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_s8_s16(i8** %[[DST:.*]], i8** %[[SRC:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
+// CHECK: call void @__copy_assignment_8_8_s8(i8** %[[V0]], i8** %[[V1]])
+// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 16
+// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
+// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
+// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 16
+// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
+// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
+// CHECK: call void @objc_storeStrong(i8** %[[V4]], i8* %[[V8]])
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_s8(i8** %[[DST:.*]], i8** %[[SRC:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 8
+// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
+// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
+// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 8
+// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
+// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
+// CHECK: call void @objc_storeStrong(i8** %[[V4]], i8* %[[V8]])
+// CHECK: ret void
+
+void test_copy_assignment_StrongOuter(StrongOuter *d, StrongOuter *s) {
+ *d = *s;
+}
+
+// CHECK: define internal void @__Block_byref_object_copy_(i8*, i8*)
+// CHECK: call void @__move_constructor_8_8_s8_s16(
+
+// CHECK: define linkonce_odr hidden void @__move_constructor_8_8_s8_s16(i8** %[[DST:.*]], i8** %[[SRC:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
+// CHECK: call void @__move_constructor_8_8_s8(i8** %[[V0]], i8** %[[V1]])
+// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 16
+// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
+// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
+// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 16
+// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
+// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
+// CHECK: store i8* null, i8** %[[V7]], align 8
+// CHECK: store i8* %[[V8]], i8** %[[V4]], align 8
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__move_constructor_8_8_s8(i8** %[[DST:.*]], i8** %[[SRC:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 8
+// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
+// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
+// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 8
+// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
+// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
+// CHECK: store i8* null, i8** %[[V7]], align 8
+// CHECK: store i8* %[[V8]], i8** %[[V4]], align 8
+// CHECK: ret void
+
+// CHECK: define internal void @__Block_byref_object_dispose_(i8*)
+// CHECK: call void @__destructor_8_s8_s16(
+// CHECK: ret void
+
+void test_move_constructor_StrongOuter(void) {
+ __block StrongOuter t;
+ BlockTy b = ^{ (void)t; };
+}
+
+// CHECK: define void @test_move_assignment_StrongOuter(%[[STRUCT_STRONGOUTER:.*]]* %[[P:.*]])
+// CHECK: %[[P_ADDR:.*]] = alloca %[[STRUCT_STRONGOUTER]]*, align 8
+// CHECK: %[[TMP:.*]] = alloca %[[STRUCT_STRONGOUTER]], align 8
+// CHECK: store %[[STRUCT_STRONGOUTER]]* %[[P]], %[[STRUCT_STRONGOUTER]]** %[[P_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load %[[STRUCT_STRONGOUTER]]*, %[[STRUCT_STRONGOUTER]]** %[[P_ADDR]], align 8
+// CHECK: call void @getStrongOuter(%[[STRUCT_STRONGOUTER]]* sret %[[TMP]])
+// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[V0]] to i8*
+// CHECK: %[[V2:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[TMP]] to i8*
+// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[V1]], i8* %[[V2]], i64 24, i32 8, i1 false)
+// CHECK: %[[V3:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[V0]] to i8**
+// CHECK: %[[V4:.*]] = bitcast %[[STRUCT_STRONGOUTER]]* %[[TMP]] to i8**
+// CHECK: call void @__move_assignment_8_8_s8_s16(i8** %[[V3]], i8** %[[V4]])
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__move_assignment_8_8_s8_s16(i8** %[[DST:.*]], i8** %[[SRC:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
+// CHECK: call void @__move_assignment_8_8_s8(i8** %[[V0]], i8** %[[V1]])
+// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 16
+// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
+// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
+// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 16
+// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
+// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
+// CHECK: store i8* null, i8** %[[V7]], align 8
+// CHECK: %[[V9:.*]] = load i8*, i8** %[[V4]], align 8
+// CHECK: store i8* %[[V8]], i8** %[[V4]], align 8
+// CHECK: call void @objc_release(i8* %[[V9]])
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__move_assignment_8_8_s8(i8** %[[DST:.*]], i8** %[[SRC:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V2:.*]] = bitcast i8** %[[V0]] to i8*
+// CHECK: %[[V3:.*]] = getelementptr inbounds i8, i8* %[[V2]], i64 8
+// CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to i8**
+// CHECK: %[[V5:.*]] = bitcast i8** %[[V1]] to i8*
+// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 8
+// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to i8**
+// CHECK: %[[V8:.*]] = load i8*, i8** %[[V7]], align 8
+// CHECK: store i8* null, i8** %[[V7]], align 8
+// CHECK: %[[V9:.*]] = load i8*, i8** %[[V4]], align 8
+// CHECK: store i8* %[[V8]], i8** %[[V4]], align 8
+// CHECK: call void @objc_release(i8* %[[V9]])
+// CHECK: ret void
+
+void test_move_assignment_StrongOuter(StrongOuter *p) {
+ *p = getStrongOuter();
+}
+
+// CHECK: define void @test_parameter_Strong([2 x i64] %[[A_COERCE:.*]])
+// CHECK: %[[A:.*]] = alloca %[[STRUCT_STRONG:.*]], align 8
+// CHECK: %[[V0:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to [2 x i64]*
+// CHECK: store [2 x i64] %[[A_COERCE]], [2 x i64]* %[[V0]], align 8
+// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to i8**
+// CHECK: call void @__destructor_8_s8(i8** %[[V1]])
+// CHECK: ret void
+
+void test_parameter_Strong(Strong a) {
+}
+
+// CHECK: define void @test_argument_Strong([2 x i64] %[[A_COERCE:.*]])
+// CHECK: %[[A:.*]] = alloca %[[STRUCT_STRONG:.*]], align 8
+// CHECK-NEXT: %[[TEMP_LVALUE:.*]] = alloca %[[STRUCT_STRONG]], align 8
+// CHECK-NEXT: %[[V0:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to [2 x i64]*
+// CHECK-NEXT: store [2 x i64] %[[A_COERCE]], [2 x i64]* %[[V0]], align 8
+// CHECK-NEXT: %[[V1:.*]] = bitcast %[[STRUCT_STRONG]]* %[[TEMP_LVALUE]] to i8*
+// CHECK-NEXT: %[[V2:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to i8*
+// CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[V1]], i8* %[[V2]], i64 16, i32 8, i1 false)
+// CHECK-NEXT: %[[V3:.*]] = bitcast %[[STRUCT_STRONG]]* %[[TEMP_LVALUE]] to i8**
+// CHECK-NEXT: %[[V4:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to i8**
+// CHECK-NEXT: call void @__copy_constructor_8_8_s8(i8** %[[V3]], i8** %[[V4]])
+// CHECK-NEXT: %[[V5:.*]] = bitcast %[[STRUCT_STRONG]]* %[[TEMP_LVALUE]] to [2 x i64]*
+// CHECK-NEXT: %[[V6:.*]] = load [2 x i64], [2 x i64]* %[[V5]], align 8
+// CHECK-NEXT: call void @calleeStrong([2 x i64] %[[V6]])
+// CHECK-NEXT: %[[V7:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to i8**
+// CHECK-NEXT: call void @__destructor_8_s8(i8** %[[V7]])
+// CHECK-NEXT: ret void
+
+void test_argument_Strong(Strong a) {
+ calleeStrong(a);
+}
+
+// CHECK: define [2 x i64] @test_return_Strong([2 x i64] %[[A_COERCE:.*]])
+// CHECK: %[[RETVAL:.*]] = alloca %[[STRUCT_STRONG:.*]], align 8
+// CHECK-NEXT: %[[A:.*]] = alloca %[[STRUCT_STRONG]], align 8
+// CHECK-NEXT: %[[V0:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to [2 x i64]*
+// CHECK-NEXT: store [2 x i64] %[[A_COERCE]], [2 x i64]* %[[V0]], align 8
+// CHECK-NEXT: %[[V1:.*]] = bitcast %[[STRUCT_STRONG]]* %[[RETVAL]] to i8*
+// CHECK-NEXT: %[[V2:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to i8*
+// CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[V1]], i8* %[[V2]], i64 16, i32 8, i1 false)
+// CHECK-NEXT: %[[V3:.*]] = bitcast %[[STRUCT_STRONG]]* %[[RETVAL]] to i8**
+// CHECK-NEXT: %[[V4:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to i8**
+// CHECK-NEXT: call void @__copy_constructor_8_8_s8(i8** %[[V3]], i8** %[[V4]])
+// CHECK-NEXT: %[[V5:.*]] = bitcast %[[STRUCT_STRONG]]* %[[A]] to i8**
+// CHECK-NEXT: call void @__destructor_8_s8(i8** %[[V5]])
+// CHECK-NEXT: %[[V6:.*]] = bitcast %[[STRUCT_STRONG]]* %[[RETVAL]] to [2 x i64]*
+// CHECK-NEXT: %[[V7:.*]] = load [2 x i64], [2 x i64]* %[[V6]], align 8
+// CHECK-NEXT: ret [2 x i64] %[[V7]]
+
+Strong test_return_Strong(Strong a) {
+ return a;
+}
+
+// CHECK: define void @test_destructor_ignored_result()
+// CHECK: %[[COERCE:.*]] = alloca %[[STRUCT_STRONG:.*]], align 8
+// CHECK: %[[CALL:.*]] = call [2 x i64] @getStrong()
+// CHECK: %[[V0:.*]] = bitcast %[[STRUCT_STRONG]]* %[[COERCE]] to [2 x i64]*
+// CHECK: store [2 x i64] %[[CALL]], [2 x i64]* %[[V0]], align 8
+// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONG]]* %[[COERCE]] to i8**
+// CHECK: call void @__destructor_8_s8(i8** %[[V1]])
+// CHECK: ret void
+
+void test_destructor_ignored_result(void) {
+ getStrong();
+}
+
+// CHECK: define void @test_copy_constructor_StrongBlock(
+// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(
+// CHECK: call void @__copy_constructor_8_8_sb0(
+// CHECK: call void @__destructor_8_sb0(
+// CHECK: ret void
+
+// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_sb0(i8** %[[DST:.*]], i8** %[[SRC:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V2:.*]] = load i8*, i8** %[[V1]], align 8
+// CHECK: %[[V3:.*]] = call i8* @objc_retainBlock(i8* %[[V2]])
+// CHECK: store i8* %[[V3]], i8** %[[V0]], align 8
+// CHECK: ret void
+
+void test_copy_constructor_StrongBlock(StrongBlock *s) {
+ StrongBlock t = *s;
+}
+
+// CHECK: define void @test_copy_assignment_StrongBlock(%[[STRUCT_STRONGBLOCK:.*]]* %[[D:.*]], %[[STRUCT_STRONGBLOCK]]* %[[S:.*]])
+// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(
+// CHECK: call void @__copy_assignment_8_8_sb0(
+
+// CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_sb0(i8** %[[DST:.*]], i8** %[[SRC:.*]])
+// CHECK: %[[DST_ADDR:.*]] = alloca i8**, align 8
+// CHECK: %[[SRC_ADDR:.*]] = alloca i8**, align 8
+// CHECK: store i8** %[[DST]], i8*** %[[DST_ADDR]], align 8
+// CHECK: store i8** %[[SRC]], i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V0:.*]] = load i8**, i8*** %[[DST_ADDR]], align 8
+// CHECK: %[[V1:.*]] = load i8**, i8*** %[[SRC_ADDR]], align 8
+// CHECK: %[[V2:.*]] = load i8*, i8** %[[V1]], align 8
+// CHECK: %[[V3:.*]] = call i8* @objc_retainBlock(i8* %[[V2]])
+// CHECK: %[[V4:.*]] = load i8*, i8** %[[V0]], align 8
+// CHECK: store i8* %[[V3]], i8** %[[V0]], align 8
+// CHECK: call void @objc_release(i8* %[[V4]])
+// CHECK: ret void
+
+void test_copy_assignment_StrongBlock(StrongBlock *d, StrongBlock *s) {
+ *d = *s;
+}
+
+// CHECK: define void @test_copy_constructor_StrongVolatile0(
+// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(
+// CHECK: call void @__copy_constructor_8_8_sv8(
+// CHECK: call void @__destructor_8_sv8(
+
+// CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_sv8(
+// CHECK: %[[V8:.*]] = load volatile i8*, i8** %{{.*}}, align 8
+// CHECK: %[[V9:.*]] = call i8* @objc_retain(i8* %[[V8]])
+// CHECK: store volatile i8* %[[V9]], i8** %{{.*}}, align 8
+
+void test_copy_constructor_StrongVolatile0(StrongVolatile *s) {
+ StrongVolatile t = *s;
+}
+
+// CHECK: define void @test_copy_constructor_StrongVolatile1(
+// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(
+// CHECK: call void @__copy_constructor_8_8_sv8(
+
+void test_copy_constructor_StrongVolatile1(Strong *s) {
+ volatile Strong t = *s;
+}
+
+// CHECK: define void @test_variable_length_array(i32 %[[N:.*]])
+// CHECK: %[[N_ADDR:.*]] = alloca i32, align 4
+// CHECK: store i32 %[[N]], i32* %[[N_ADDR]], align 4
+// CHECK: %[[V0:.*]] = load i32, i32* %[[N_ADDR]], align 4
+// CHECK: %[[V1:.*]] = zext i32 %[[V0]] to i64
+// CHECK: %[[VLA:.*]] = alloca %[[STRUCT_STRONG:.*]], i64 %[[V1]], align 8
+// CHECK: %[[V3:.*]] = bitcast %[[STRUCT_STRONG]]* %[[VLA]] to i8**
+// CHECK: %[[V4:.*]] = mul nuw i64 16, %[[V1]]
+// CHECK: %[[V5:.*]] = bitcast i8** %[[V3]] to i8*
+// CHECK: %[[V6:.*]] = getelementptr inbounds i8, i8* %[[V5]], i64 %[[V4]]
+// CHECK: %[[DSTARRAY_END:.*]] = bitcast i8* %[[V6]] to i8**
+// CHECK: br label
+
+// CHECK: %[[DSTADDR_CUR:.*]] = phi i8** [ %[[V3]], {{.*}} ], [ %[[V7:.*]], {{.*}} ]
+// CHECK: %[[DONE:.*]] = icmp eq i8** %[[DSTADDR_CUR]], %[[DSTARRAY_END]]
+// CHECK: br i1 %[[DONE]], label
+
+// CHECK: call void @__default_constructor_8_s8(i8** %[[DSTADDR_CUR]])
+// CHECK: %[[V8:.*]] = bitcast i8** %[[DSTADDR_CUR]] to i8*
+// CHECK: %[[V9:.*]] = getelementptr inbounds i8, i8* %[[V8]], i64 16
+// CHECK: %[[V7]] = bitcast i8* %[[V9]] to i8**
+// CHECK: br label
+
+// CHECK: call void @func(%[[STRUCT_STRONG]]* %[[VLA]])
+// CHECK: %[[V10:.*]] = getelementptr inbounds %[[STRUCT_STRONG]], %[[STRUCT_STRONG]]* %[[VLA]], i64 %[[V1]]
+// CHECK: %[[ARRAYDESTROY_ISEMPTY:.*]] = icmp eq %[[STRUCT_STRONG]]* %[[VLA]], %[[V10]]
+// CHECK: br i1 %[[ARRAYDESTROY_ISEMPTY]], label
+
+// CHECK: %[[ARRAYDESTROY_ELEMENTPAST:.*]] = phi %[[STRUCT_STRONG]]* [ %[[V10]], {{.*}} ], [ %[[ARRAYDESTROY_ELEMENT:.*]], {{.*}} ]
+// CHECK: %[[ARRAYDESTROY_ELEMENT]] = getelementptr inbounds %[[STRUCT_STRONG]], %[[STRUCT_STRONG]]* %[[ARRAYDESTROY_ELEMENTPAST]], i64 -1
+// CHECK: %[[V11:.*]] = bitcast %[[STRUCT_STRONG]]* %[[ARRAYDESTROY_ELEMENT]] to i8**
+// CHECK: call void @__destructor_8_s8(i8** %[[V11]]) #5
+// CHECK: %[[ARRAYDESTROY_DONE:.*]] = icmp eq %[[STRUCT_STRONG]]* %[[ARRAYDESTROY_ELEMENT]], %[[VLA]]
+// CHECK: br i1 %[[ARRAYDESTROY_DONE]], label
+
+// CHECK: ret void
+
+void test_variable_length_array(int n) {
+ Strong a[n];
+ func(a);
+}
+
+// CHECK: define linkonce_odr hidden void @__default_constructor_8_AB8_8_4_s8_AE(
+void test_constructor_destructor_IDArray(void) {
+ IDArray t;
+}
+
+// CHECK: __default_constructor_8_AB8_16_4_s16_AE
+void test_constructor_destructor_StructArray(void) {
+ StructArray t;
+}
Index: test/ARCMT/checking.m
===================================================================
--- test/ARCMT/checking.m
+++ test/ARCMT/checking.m
@@ -116,7 +116,7 @@
}
struct S {
- A* a; // expected-error {{ARC forbids Objective-C objects in struct}}
+ A* a;
};
@interface B
Index: lib/Sema/SemaExpr.cpp
===================================================================
--- lib/Sema/SemaExpr.cpp
+++ lib/Sema/SemaExpr.cpp
@@ -776,6 +776,9 @@
return VAK_Valid;
}
+ if (Ty.nonTrivialToDestroy())
+ return VAK_Invalid;
+
if (Ty.isCXX98PODType(Context))
return VAK_Valid;
@@ -837,7 +840,10 @@
break;
case VAK_Invalid:
- if (Ty->isObjCObjectType())
+ if (Ty.hasNonTrivialToDestroyStruct())
+ Diag(E->getLocStart(),
+ diag::err_cannot_pass_non_trivial_c_struct_to_vararg) << Ty << CT;
+ else if (Ty->isObjCObjectType())
DiagRuntimeBehavior(
E->getLocStart(), nullptr,
PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
Index: lib/Sema/SemaDecl.cpp
===================================================================
--- lib/Sema/SemaDecl.cpp
+++ lib/Sema/SemaDecl.cpp
@@ -10941,6 +10941,9 @@
}
}
+ if (var->getType().hasNonTrivialToDestroyStruct())
+ getCurFunction()->setHasBranchProtectedScope();
+
// Warn about externally-visible variables being defined without a
// prior declaration. We only want to do this for global
// declarations, but we also specifically need to avoid doing it for
@@ -14823,6 +14826,7 @@
// Get the type for the field.
const Type *FDTy = FD->getType().getTypePtr();
+ Qualifiers QS = FD->getType().getQualifiers();
if (!FD->isAnonymousStructOrUnion()) {
// Remember all fields written by the user.
@@ -14964,7 +14968,9 @@
FD->setType(T);
} else if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
Record && !ObjCFieldLifetimeErrReported &&
- (!getLangOpts().CPlusPlus || Record->isUnion())) {
+ ((!getLangOpts().CPlusPlus &&
+ QS.getObjCLifetime() == Qualifiers::OCL_Weak) ||
+ Record->isUnion())) {
// It's an error in ARC or Weak if a field has lifetime.
// We don't want to report this in a system header, though,
// so we just make the field unavailable.
@@ -15000,6 +15006,19 @@
Record->setHasObjectMember(true);
}
}
+
+ if (Record && !getLangOpts().CPlusPlus) {
+ QualType FT = FD->getType();
+ if (FT.nonTrivialToDefaultInitialize())
+ Record->setNonTrivialToDefaultInitialize(true);
+ if (FT.nonTrivialToCopy())
+ Record->setNonTrivialToCopy(true);
+ if (FT.nonTrivialToDestructiveMove())
+ Record->setNonTrivialToDestructiveMove(true);
+ if (FT.nonTrivialToDestroy())
+ Record->setNonTrivialToDestroy(true);
+ }
+
if (Record && FD->getType().isVolatileQualified())
Record->setHasVolatileMember(true);
// Keep track of the number of named members.
Index: lib/Sema/JumpDiagnostics.cpp
===================================================================
--- lib/Sema/JumpDiagnostics.cpp
+++ lib/Sema/JumpDiagnostics.cpp
@@ -154,6 +154,10 @@
return ScopePair(diag::note_protected_by_objc_weak_init,
diag::note_exits_objc_weak);
+ case QualType::DK_non_trivial_c_struct:
+ return ScopePair(diag::note_protected_by_non_trivial_c_struct_init,
+ diag::note_exits_dtor);
+
case QualType::DK_cxx_destructor:
OutDiag = diag::note_exits_dtor;
break;
@@ -254,6 +258,10 @@
Diags = ScopePair(diag::note_enters_block_captures_weak,
diag::note_exits_block_captures_weak);
break;
+ case QualType::DK_non_trivial_c_struct:
+ Diags = ScopePair(diag::note_enters_block_captures_non_trivial_c_struct,
+ diag::note_exits_block_captures_non_trivial_c_struct);
+ break;
case QualType::DK_none:
llvm_unreachable("non-lifetime captured variable");
}
Index: lib/CodeGen/CodeGenFunction.h
===================================================================
--- lib/CodeGen/CodeGenFunction.h
+++ lib/CodeGen/CodeGenFunction.h
@@ -1532,6 +1532,7 @@
return false;
case QualType::DK_cxx_destructor:
case QualType::DK_objc_weak_lifetime:
+ case QualType::DK_non_trivial_c_struct:
return getLangOpts().Exceptions;
case QualType::DK_objc_strong_lifetime:
return getLangOpts().Exceptions &&
@@ -3330,6 +3331,21 @@
CXXDtorType Type,
const CXXRecordDecl *RD);
+ // These functions emit calls to the special functions of non-trivial C
+ // structs.
+ void defaultInitNonTrivialCStructVar(Address DstPtr, QualType QT,
+ bool IsVolatile);
+ void callDefaultConstructor(Address DstPtr, QualType QT, bool IsVolatile);
+ void callCopyConstructor(Address DstPtr, Address SrcPtr,
+ QualType QT, bool IsVolatile);
+ void callMoveConstructor(Address DstPtr, Address SrcPtr,
+ QualType QT, bool IsVolatile);
+ void callCopyAssignmentOperator(Address DstPtr, Address SrcPtr,
+ QualType QT, bool IsVolatile);
+ void callMoveAssignmentOperator(Address DstPtr, Address SrcPtr,
+ QualType QT, bool IsVolatile);
+ void callDestructor(Address DstPtr, QualType QT, bool IsVolatile);
+
RValue
EmitCXXMemberOrOperatorCall(const CXXMethodDecl *Method,
const CGCallee &Callee,
@@ -3501,6 +3517,7 @@
static Destroyer destroyARCStrongPrecise;
static Destroyer destroyARCWeak;
static Destroyer emitARCIntrinsicUse;
+ static Destroyer destroyNonTrivialCStruct;
void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr);
llvm::Value *EmitObjCAutoreleasePoolPush();
Index: lib/CodeGen/CodeGenFunction.cpp
===================================================================
--- lib/CodeGen/CodeGenFunction.cpp
+++ lib/CodeGen/CodeGenFunction.cpp
@@ -1138,6 +1138,15 @@
if (Ty->isVariablyModifiedType())
EmitVariablyModifiedType(Ty);
+
+ // If this arg is a type that is non-trivial to destruct and is not passed
+ // indirectly, the callee is responsible for destructing the argument.
+ if (Ty.hasNonTrivialToDestroyStruct()) {
+ AutoVarEmission Emission(*VD);
+ Emission.Addr = GetAddrOfLocalVar(VD);
+ emitAutoVarTypeCleanup(Emission,
+ QualType::DK_non_trivial_c_struct);
+ }
}
// Emit a location at the end of the prologue.
if (CGDebugInfo *DI = getDebugInfo())
Index: lib/CodeGen/CodeGenCStruct.cpp
===================================================================
--- /dev/null
+++ lib/CodeGen/CodeGenCStruct.cpp
@@ -0,0 +1,570 @@
+//===--- CodeGenCStruct.cpp - Emit Special Functions for C Structs --------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines functions to generate various special functions for C
+// structs.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CodeGenFunction.h"
+#include "CodeGenModule.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+using namespace clang;
+using namespace CodeGen;
+
+namespace {
+enum FieldKind {
+ FK_Strong, // objc strong pointer.
+ FK_Struct, // non-trivial C struct.
+ FK_Array // array that has non-trivial elements.
+};
+}
+
+/// Return an address with the specified offset from the passed address.
+static Address getAddrWithOffset(Address Addr, unsigned Offset,
+ CodeGenFunction &CGF) {
+ if (!Addr.isValid() || Offset == 0)
+ return Addr;
+ Addr = CGF.Builder.CreateBitCast(Addr, CGF.CGM.Int8PtrTy);
+ Addr = CGF.Builder.CreateConstInBoundsGEP(Addr, Offset, CharUnits::One());
+ return CGF.Builder.CreateBitCast(Addr, CGF.CGM.Int8PtrPtrTy);
+}
+
+static const CGFunctionInfo &getFunctionInfo(CodeGenModule &CGM, bool IsBinary,
+ FunctionArgList &Args) {
+ ASTContext &Ctx = CGM.getContext();
+ llvm::SmallVector<ImplicitParamDecl *, 2> Params;
+ QualType ParamTy = Ctx.getPointerType(Ctx.VoidPtrTy);
+ Params.push_back(ImplicitParamDecl::Create(Ctx, nullptr, SourceLocation(),
+ &Ctx.Idents.get("dst"), ParamTy,
+ ImplicitParamDecl::Other));
+
+ if (IsBinary)
+ Params.push_back(ImplicitParamDecl::Create(Ctx, nullptr, SourceLocation(),
+ &Ctx.Idents.get("src"), ParamTy,
+ ImplicitParamDecl::Other));
+
+ for (auto &P : Params)
+ Args.push_back(P);
+
+ return CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args);
+}
+
+// Get the kind of a C struct field. Returns an empty Optional if the field
+// type is trivial.
+template <class T>
+static llvm::Optional<FieldKind> getFieldKind(QualType QT, ASTContext &Ctx) {
+ if (!T::isInterestingType(QT))
+ return Optional<FieldKind>();
+
+ if (QT->getAs<RecordType>())
+ return FK_Struct;
+ if (Ctx.getAsArrayType(QT))
+ return FK_Array;
+ if (QT.getQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong)
+ return FK_Strong;
+
+ return Optional<FieldKind>();
+}
+
+static std::string getVolatileOffsetStr(bool IsVolatile, CharUnits Offset) {
+ std::string S;
+ if (IsVolatile)
+ S = "v";
+ S += llvm::to_string(Offset.getQuantity());
+ return S;
+}
+
+namespace {
+// This is a helper class that encodes the information about the fields of a
+// non-trivial C struct into the name of its special functions. The string has
+// the following structure:
+//
+// <struct-field-info> ::= <field-info>+
+// <field-info> ::= <struct-or-scalar-field-info> | <array-field-info> |
+// <struct-or-scalar-field-info> ::= <struct-field-info> | <strong-field-info>
+// <array-field-info> ::= "_AB" <array-offset> '_' <element-size> '_'
+// <num-elements> <element-info> "_AE"
+// <element-size> ::= <struct-or-scalar-field-info>
+// <strong-field-info> ::= "_s" ["_b"] ["_v"] <field-offset>
+
+template <class T> class FieldInfoToString {
+public:
+ FieldInfoToString(QualType QT, bool IsVolatile, ASTContext &C) : Ctx(C) {
+ visitStruct(CharUnits::Zero(), QT, IsVolatile);
+ }
+
+ void visitField(CharUnits Offset, QualType QT, bool IsVolatile) {
+ switch (*getFieldKind<T>(QT, Ctx)) {
+ case FK_Struct:
+ visitStruct(Offset, QT, IsVolatile);
+ break;
+ case FK_Array:
+ visitArray(Offset, QT, IsVolatile);
+ break;
+ case FK_Strong:
+ Str += "_s";
+ if (QT->isBlockPointerType())
+ Str += "b";
+ Str += getVolatileOffsetStr(IsVolatile, Offset);
+ break;
+ }
+ }
+
+ void visitStruct(CharUnits Offset, QualType QT, bool IsVolatile) {
+ const RecordDecl *RD = QT->castAs<RecordType>()->getDecl();
+ const ASTRecordLayout &RL = Ctx.getASTRecordLayout(RD);
+
+ // Iterate over the fields of the struct.
+ size_t FieldNo = 0;
+ for (const FieldDecl *FD : RD->fields()) {
+ QualType FT = FD->getType();
+ unsigned FOffsetVal = RL.getFieldOffset(FieldNo++) / Ctx.getCharWidth();
+ if (getFieldKind<T>(FT, Ctx)) {
+ CharUnits FOffset = Offset + CharUnits::fromQuantity(FOffsetVal);
+ visitField(FOffset, FT, FT.isVolatileQualified() || IsVolatile);
+ }
+ }
+ }
+
+ void visitArray(CharUnits Offset, QualType QT, bool IsVolatile) {
+ const auto *AT = Ctx.getAsConstantArrayType(QT);
+ unsigned NumElts = Ctx.getConstantArrayElementCount(AT);
+ QualType EltTy = Ctx.getBaseElementType(AT);
+ unsigned EltSize = Ctx.getTypeSizeInChars(EltTy).getQuantity();
+ Str += "_AB" + llvm::to_string(Offset.getQuantity()) + "_" +
+ llvm::to_string(EltSize) + "_" + llvm::to_string(NumElts);
+ visitField(Offset, EltTy, IsVolatile);
+ Str += "_AE";
+ }
+
+ operator std::string() const { return Str; }
+
+private:
+ ASTContext &Ctx;
+ std::string Str;
+};
+} // namespace
+
+// This function creates the mangled name of a special function of a non-trivial
+// C struct. Since there is no ODR in C, the function is mangled based on the
+// struct contents and not the name. The mangled name has the following
+// structure:
+//
+// <function-name> ::= <prefix> <alignment-info> '_' <struct-field-info>
+// <prefix> ::= "__destructor_" | "__default_constructor_" |
+// "__copy_constructor_" | "__move_constructor_" |
+// "__copy_assignment_" | "__move_assignment_"
+// <alignment-info> ::= <dst-alignment> ["_" <src-alignment>]
+
+template <class T>
+static std::string
+getSpecialFuncName(QualType QT, bool IsVolatile, CharUnits DstAlignment,
+ CharUnits SrcAlignment, bool IsBinary, CodeGenModule &CGM) {
+ StringRef Prefix = T::getFuncPrefix();
+ std::string S = FieldInfoToString<T>(QT, IsVolatile, CGM.getContext());
+ std::string A = llvm::to_string(DstAlignment.getQuantity());
+ if (IsBinary)
+ A += "_" + llvm::to_string(SrcAlignment.getQuantity());
+ return std::string(Prefix) + A + S;
+}
+
+// Helper function to create a null constant.
+static llvm::Constant *getNullForVariable(Address Addr) {
+ llvm::Type *Ty = Addr.getElementType();
+ return llvm::ConstantPointerNull::get(cast<llvm::PointerType>(Ty));
+}
+
+namespace {
+
+template <class T> class IRGen {
+public:
+ IRGen()
+ : CGF(nullptr), DstStart(Address::invalid()),
+ SrcStart(Address::invalid()) {}
+
+ IRGen(CodeGenFunction &F)
+ : CGF(&F), DstStart(Address::invalid()), SrcStart(Address::invalid()) {}
+
+ void setFunction(CodeGenFunction &F, FunctionArgList &Args,
+ CharUnits DstAlignment, CharUnits SrcAlignment) {
+ CGF = &F;
+ llvm::Value *D = CGF->Builder.CreateLoad(CGF->GetAddrOfLocalVar(Args[0]));
+ DstStart = Address(D, DstAlignment);
+ if (isBinary()) {
+ assert(CGF->CurFn->arg_size() == 2 &&
+ "Binary functions expected to have two arguments");
+ llvm::Value *S = CGF->Builder.CreateLoad(CGF->GetAddrOfLocalVar(Args[1]));
+ SrcStart = Address(S, SrcAlignment);
+ }
+ }
+
+ void visitMostOuterStruct(QualType QT, bool IsVolatile) {
+ visitStruct(DstStart, SrcStart, QT, IsVolatile, false);
+ }
+
+ void visitField(Address DstAddr, Address SrcAddr, QualType QT,
+ bool IsVolatile) {
+ switch (*getFieldKind<T>(QT, CGF->getContext())) {
+ case FK_Struct:
+ visitStruct(DstAddr, SrcAddr, QT, IsVolatile);
+ break;
+ case FK_Array:
+ visitArray(DstAddr, SrcAddr, QT, IsVolatile);
+ break;
+ case FK_Strong:
+ if (IsVolatile)
+ QT = QT.withVolatile();
+ T::emitIRStrong(DstAddr, SrcAddr, QT, *CGF);
+ break;
+ }
+ }
+
+ void visitStruct(Address DstAddr, Address SrcAddr, QualType QT,
+ bool IsVolatile, bool IsField = true) {
+ // Just call the special function if this is a struct field contained in
+ // another struct.
+ if (IsField) {
+ T::callSpecialFunction(DstAddr, SrcAddr, QT, IsVolatile, *CGF);
+ return;
+ }
+
+ const RecordDecl *RD = QT->castAs<RecordType>()->getDecl();
+ ASTContext &Ctx = CGF->getContext();
+ const ASTRecordLayout &RL = Ctx.getASTRecordLayout(RD);
+
+ // Iterate over the fields of the struct.
+ size_t FieldNo = 0;
+ for (const FieldDecl *FD : RD->fields()) {
+ unsigned FOffset = RL.getFieldOffset(FieldNo++) / Ctx.getCharWidth();
+ Address FieldDstAddr = getAddrWithOffset(DstAddr, FOffset, *CGF);
+ Address FieldSrcAddr = getAddrWithOffset(SrcAddr, FOffset, *CGF);
+ QualType FT = FD->getType();
+ if (getFieldKind<T>(FT, CGF->getContext()))
+ visitField(FieldDstAddr, FieldSrcAddr, FT,
+ FT.isVolatileQualified() || IsVolatile);
+ }
+ }
+
+ void visitArray(Address DstAddr, Address SrcAddr, QualType QT,
+ bool IsVolatile) {
+ // Compute the end address.
+ ASTContext &Ctx = CGF->getContext();
+ QualType BaseEltQT;
+ Address TmpAddr = DstAddr;
+ llvm::Value *NumElts =
+ CGF->emitArrayLength(Ctx.getAsArrayType(QT), BaseEltQT, TmpAddr);
+ unsigned BaseEltSize = Ctx.getTypeSizeInChars(BaseEltQT).getQuantity();
+ llvm::Value *BaseEltSizeVal =
+ llvm::ConstantInt::get(NumElts->getType(), BaseEltSize);
+ llvm::Value *SizeInBytes =
+ CGF->Builder.CreateNUWMul(BaseEltSizeVal, NumElts);
+ Address BC = CGF->Builder.CreateBitCast(DstAddr, CGF->CGM.Int8PtrTy);
+ llvm::Value *DstArrayEnd =
+ CGF->Builder.CreateInBoundsGEP(BC.getPointer(), SizeInBytes);
+ DstArrayEnd = CGF->Builder.CreateBitCast(DstArrayEnd, CGF->CGM.Int8PtrPtrTy,
+ "dstarray.end");
+ llvm::BasicBlock *PreheaderBB = CGF->Builder.GetInsertBlock();
+
+ // Create the header block and insert the phi instructions.
+ llvm::BasicBlock *HeaderBB = CGF->createBasicBlock("loop.header");
+ CGF->EmitBlock(HeaderBB);
+ llvm::Type *Ty = DstAddr.getPointer()->getType();
+ llvm::PHINode *DstPHI = CGF->Builder.CreatePHI(Ty, 2, "dstaddr.cur");
+ DstPHI->addIncoming(DstAddr.getPointer(), PreheaderBB);
+ llvm::PHINode *SrcPHI = nullptr;
+ if (SrcAddr.isValid()) {
+ SrcPHI = CGF->Builder.CreatePHI(Ty, 2, "srcaddr.cur");
+ SrcPHI->addIncoming(SrcAddr.getPointer(), PreheaderBB);
+ }
+
+ // Create the exit and loop body blocks.
+ llvm::BasicBlock *ExitBB = CGF->createBasicBlock("loop.exit");
+ llvm::BasicBlock *LoopBB = CGF->createBasicBlock("loop.body");
+
+ // Emit the comparison and conditional branch instruction that jumps to
+ // either the exit or the loop body.
+ llvm::Value *Done = CGF->Builder.CreateICmpEQ(DstPHI, DstArrayEnd, "done");
+ CGF->Builder.CreateCondBr(Done, ExitBB, LoopBB);
+
+ // Visit the element of the array in the loop body.
+ CGF->EmitBlock(LoopBB);
+ QualType EltQT = Ctx.getAsArrayType(QT)->getElementType();
+ CharUnits EltSize = Ctx.getTypeSizeInChars(EltQT);
+ Address Dst =
+ Address(DstPHI, DstAddr.getAlignment().alignmentAtOffset(EltSize));
+ Address Src = Address::invalid();
+ if (SrcAddr.isValid())
+ Src = Address(SrcPHI, SrcAddr.getAlignment().alignmentAtOffset(EltSize));
+ visitField(Dst, Src, EltQT, IsVolatile);
+
+ // Instrs to update the destination and source addresses.
+ Address NextDst = getAddrWithOffset(Dst, EltSize.getQuantity(), *CGF);
+ Address NextSrc = getAddrWithOffset(Src, EltSize.getQuantity(), *CGF);
+
+ // Update phi instructions.
+ LoopBB = CGF->Builder.GetInsertBlock();
+ DstPHI->addIncoming(NextDst.getPointer(), LoopBB);
+ if (NextSrc.isValid())
+ SrcPHI->addIncoming(NextSrc.getPointer(), LoopBB);
+
+ // Insert an unconditional branch to the header block.
+ CGF->Builder.CreateBr(HeaderBB);
+ CGF->EmitBlock(ExitBB);
+ }
+
+ static bool isBinary() { return T::isBinary(); }
+
+ static const char *getFuncPrefix() { return T::getFuncPrefix(); }
+
+ static bool isInterestingType(QualType QT) {
+ return T::isInterestingType(QT);
+ }
+
+private:
+ CodeGenFunction *CGF;
+ Address DstStart, SrcStart;
+};
+
+template <bool IsBinary> struct SpecialFunc {
+ // Emit IR for objc __strong pointers.
+ static void emitIRStrong(Address DstAddr, Address SrcAddr, QualType QT,
+ CodeGenFunction &CGF) {}
+
+ // This function returns true if the subclass is used to generate special
+ // functions that need two arguments (source and destination arguments for
+ // copy/move constructors/assignment operators).
+ static bool isBinary() { return IsBinary; }
+};
+
+// Various subclasses of SpecialFunc that are used to customize
+// the IR IRGen generates.
+struct Destructor : SpecialFunc<false> {
+ static void emitIRStrong(Address DstAddr, Address SrcAddr, QualType QT,
+ CodeGenFunction &CGF) {
+ CGF.destroyARCStrongImprecise(CGF, DstAddr, QT);
+ }
+ static const char *getFuncPrefix() { return "__destructor_"; }
+
+ static bool isInterestingType(QualType T) { return T.nonTrivialToDestroy(); }
+ static void callSpecialFunction(Address DstAddr, Address SrcAddr, QualType QT,
+ bool IsVolatile, CodeGenFunction &CGF) {
+ CGF.callDestructor(DstAddr, QT, IsVolatile);
+ }
+};
+
+struct DefaultConstructor : SpecialFunc<false> {
+ static void emitIRStrong(Address DstAddr, Address SrcAddr, QualType QT,
+ CodeGenFunction &CGF) {
+ CGF.EmitNullInitialization(DstAddr, QT);
+ }
+ static const char *getFuncPrefix() { return "__default_constructor_"; }
+
+ static bool isInterestingType(QualType T) {
+ return T.nonTrivialToDefaultInitialize();
+ }
+ static void callSpecialFunction(Address DstAddr, Address SrcAddr, QualType QT,
+ bool IsVolatile, CodeGenFunction &CGF) {
+ CGF.callDefaultConstructor(DstAddr, QT, IsVolatile);
+ }
+};
+
+struct CopyConstructor : SpecialFunc<true> {
+ static void emitIRStrong(Address DstAddr, Address SrcAddr, QualType QT,
+ CodeGenFunction &CGF) {
+ llvm::Value *SrcVal = CGF.EmitLoadOfScalar(
+ SrcAddr, QT.isVolatileQualified(), QT, SourceLocation());
+ llvm::Value *Val = CGF.EmitARCRetain(QT, SrcVal);
+ CGF.EmitStoreOfScalar(Val, CGF.MakeAddrLValue(DstAddr, QT), true);
+ }
+ static const char *getFuncPrefix() { return "__copy_constructor_"; }
+
+ static bool isInterestingType(QualType T) { return T.nonTrivialToCopy(); }
+ static void callSpecialFunction(Address DstAddr, Address SrcAddr, QualType QT,
+ bool IsVolatile, CodeGenFunction &CGF) {
+ CGF.callCopyConstructor(DstAddr, SrcAddr, QT, IsVolatile);
+ }
+};
+
+struct MoveConstructor : SpecialFunc<true> {
+ static void emitIRStrong(Address DstAddr, Address SrcAddr, QualType QT,
+ CodeGenFunction &CGF) {
+ LValue SrcLV = CGF.MakeAddrLValue(SrcAddr, QT);
+ llvm::Value *SrcVal =
+ CGF.EmitLoadOfLValue(SrcLV, SourceLocation()).getScalarVal();
+ CGF.EmitStoreOfScalar(getNullForVariable(SrcLV.getAddress()), SrcLV);
+ CGF.EmitStoreOfScalar(SrcVal, CGF.MakeAddrLValue(DstAddr, QT),
+ /* isInitialization */ true);
+ }
+ static const char *getFuncPrefix() { return "__move_constructor_"; }
+
+ static bool isInterestingType(QualType T) {
+ return T.nonTrivialToDestructiveMove();
+ }
+ static void callSpecialFunction(Address DstAddr, Address SrcAddr, QualType QT,
+ bool IsVolatile, CodeGenFunction &CGF) {
+ CGF.callMoveConstructor(DstAddr, SrcAddr, QT, IsVolatile);
+ }
+};
+
+struct CopyAssignment : SpecialFunc<true> {
+ static void emitIRStrong(Address DstAddr, Address SrcAddr, QualType QT,
+ CodeGenFunction &CGF) {
+ llvm::Value *SrcVal = CGF.EmitLoadOfScalar(
+ SrcAddr, QT.isVolatileQualified(), QT, SourceLocation());
+ CGF.EmitARCStoreStrong(CGF.MakeAddrLValue(DstAddr, QT), SrcVal, false);
+ }
+ static const char *getFuncPrefix() { return "__copy_assignment_"; }
+
+ static bool isInterestingType(QualType T) { return T.nonTrivialToCopy(); }
+ static void callSpecialFunction(Address DstAddr, Address SrcAddr, QualType QT,
+ bool IsVolatile, CodeGenFunction &CGF) {
+ CGF.callCopyAssignmentOperator(DstAddr, SrcAddr, QT, IsVolatile);
+ }
+};
+
+struct MoveAssignment : SpecialFunc<true> {
+ static void emitIRStrong(Address DstAddr, Address SrcAddr, QualType QT,
+ CodeGenFunction &CGF) {
+ LValue SrcLV = CGF.MakeAddrLValue(SrcAddr, QT);
+ llvm::Value *SrcVal =
+ CGF.EmitLoadOfLValue(SrcLV, SourceLocation()).getScalarVal();
+ CGF.EmitStoreOfScalar(getNullForVariable(SrcLV.getAddress()), SrcLV);
+ LValue DstLV = CGF.MakeAddrLValue(DstAddr, QT);
+ llvm::Value *DstVal =
+ CGF.EmitLoadOfLValue(DstLV, SourceLocation()).getScalarVal();
+ CGF.EmitStoreOfScalar(SrcVal, DstLV);
+ CGF.EmitARCRelease(DstVal, ARCImpreciseLifetime);
+ }
+ static const char *getFuncPrefix() { return "__move_assignment_"; }
+
+ static bool isInterestingType(QualType T) {
+ return T.nonTrivialToDestructiveMove();
+ }
+ static void callSpecialFunction(Address DstAddr, Address SrcAddr, QualType QT,
+ bool IsVolatile, CodeGenFunction &CGF) {
+ CGF.callMoveAssignmentOperator(DstAddr, SrcAddr, QT, IsVolatile);
+ }
+};
+} // namespace
+
+void CodeGenFunction::destroyNonTrivialCStruct(CodeGenFunction &CGF,
+ Address Addr, QualType Type) {
+ CGF.callDestructor(Addr, Type, Type.isVolatileQualified());
+}
+
+// A template function to create the special function for a non-trivial C
+// struct. Template parameter 'T' is an instantiation of IRGen.
+template <class T>
+static llvm::Function *
+getSpecialFunction(QualType QT, bool IsVolatile, T &Gen, CharUnits DstAlignment,
+ CharUnits SrcAlignment, CodeGenModule &CGM) {
+ bool IsBinary = T::isBinary();
+ std::string FuncName = getSpecialFuncName<T>(QT, IsVolatile, DstAlignment,
+ SrcAlignment, IsBinary, CGM);
+
+ // If the special function already exists in the module, return it here.
+ if (llvm::Function *F = CGM.getModule().getFunction(FuncName))
+ return F;
+
+ // Create the special function.
+ ASTContext &Ctx = CGM.getContext();
+ CodeGenFunction CGF(CGM);
+ FunctionArgList Args;
+ const CGFunctionInfo &FI = getFunctionInfo(CGM, IsBinary, Args);
+ llvm::FunctionType *FuncTy = CGM.getTypes().GetFunctionType(FI);
+ llvm::Function *F =
+ llvm::Function::Create(FuncTy, llvm::GlobalValue::LinkOnceODRLinkage,
+ FuncName, &CGM.getModule());
+ F->setVisibility(llvm::GlobalValue::HiddenVisibility);
+ CGF.CGM.SetLLVMFunctionAttributes(nullptr, FI, F);
+ CGF.CGM.SetLLVMFunctionAttributesForDefinition(nullptr, F);
+ IdentifierInfo *II = &Ctx.Idents.get(FuncName);
+ FunctionDecl *FD = FunctionDecl::Create(
+ Ctx, Ctx.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II,
+ Ctx.VoidTy, nullptr, SC_PrivateExtern, false, false);
+ CGF.StartFunction(FD, Ctx.VoidTy, F, FI, Args);
+ Gen.setFunction(CGF, Args, DstAlignment, SrcAlignment);
+ Gen.visitMostOuterStruct(QT, IsVolatile);
+ CGF.FinishFunction();
+ return F;
+}
+
+// Default-initialize a non-trivial struct or an array.
+void CodeGenFunction::defaultInitNonTrivialCStructVar(Address DstPtr,
+ QualType QT,
+ bool IsVolatile) {
+ if (getContext().getAsArrayType(QT)) {
+ IRGen<DefaultConstructor> Gen(*this);
+ DstPtr = Builder.CreateBitCast(DstPtr, CGM.Int8PtrPtrTy);
+ Gen.visitArray(DstPtr, Address::invalid(), QT, IsVolatile);
+ } else {
+ callDefaultConstructor(DstPtr, QT, IsVolatile);
+ }
+}
+
+// Functions to emit calls to the special functions of a non-trivial C struct.
+void CodeGenFunction::callDefaultConstructor(Address DstPtr, QualType QT,
+ bool IsVolatile) {
+ IRGen<DefaultConstructor> Gen;
+ llvm::Function *Fn = getSpecialFunction(
+ QT, IsVolatile, Gen, DstPtr.getAlignment(), CharUnits::Zero(), CGM);
+ DstPtr = Builder.CreateBitCast(DstPtr, CGM.Int8PtrPtrTy);
+ EmitNounwindRuntimeCall(Fn, DstPtr.getPointer());
+}
+
+void CodeGenFunction::callDestructor(Address DstPtr, QualType QT,
+ bool IsVolatile) {
+ IRGen<Destructor> Gen;
+ llvm::Function *Fn = getSpecialFunction(
+ QT, IsVolatile, Gen, DstPtr.getAlignment(), CharUnits::Zero(), CGM);
+ DstPtr = Builder.CreateBitCast(DstPtr, CGM.Int8PtrPtrTy);
+ EmitNounwindRuntimeCall(Fn, DstPtr.getPointer());
+}
+
+void CodeGenFunction::callCopyConstructor(Address DstPtr, Address SrcPtr,
+ QualType QT, bool IsVolatile) {
+ IRGen<CopyConstructor> Gen;
+ llvm::Function *Fn = getSpecialFunction(
+ QT, IsVolatile, Gen, DstPtr.getAlignment(), SrcPtr.getAlignment(), CGM);
+ DstPtr = Builder.CreateBitCast(DstPtr, CGM.Int8PtrPtrTy);
+ SrcPtr = Builder.CreateBitCast(SrcPtr, CGM.Int8PtrPtrTy);
+ EmitNounwindRuntimeCall(Fn, {DstPtr.getPointer(), SrcPtr.getPointer()});
+}
+
+void CodeGenFunction::callCopyAssignmentOperator(Address DstPtr, Address SrcPtr,
+ QualType QT, bool IsVolatile) {
+ IRGen<CopyAssignment> Gen;
+ llvm::Function *Fn = getSpecialFunction(
+ QT, IsVolatile, Gen, DstPtr.getAlignment(), SrcPtr.getAlignment(), CGM);
+ DstPtr = Builder.CreateBitCast(DstPtr, CGM.Int8PtrPtrTy);
+ SrcPtr = Builder.CreateBitCast(SrcPtr, CGM.Int8PtrPtrTy);
+ EmitNounwindRuntimeCall(Fn, {DstPtr.getPointer(), SrcPtr.getPointer()});
+}
+
+void CodeGenFunction::callMoveConstructor(Address DstPtr, Address SrcPtr,
+ QualType QT, bool IsVolatile) {
+ IRGen<MoveConstructor> Gen;
+ llvm::Function *Fn = getSpecialFunction(
+ QT, IsVolatile, Gen, DstPtr.getAlignment(), SrcPtr.getAlignment(), CGM);
+ DstPtr = Builder.CreateBitCast(DstPtr, CGM.Int8PtrPtrTy);
+ SrcPtr = Builder.CreateBitCast(SrcPtr, CGM.Int8PtrPtrTy);
+ EmitNounwindRuntimeCall(Fn, {DstPtr.getPointer(), SrcPtr.getPointer()});
+}
+
+void CodeGenFunction::callMoveAssignmentOperator(Address DstPtr, Address SrcPtr,
+ QualType QT, bool IsVolatile) {
+ IRGen<MoveAssignment> Gen;
+ llvm::Function *Fn = getSpecialFunction(
+ QT, IsVolatile, Gen, DstPtr.getAlignment(), SrcPtr.getAlignment(), CGM);
+ DstPtr = Builder.CreateBitCast(DstPtr, CGM.Int8PtrPtrTy);
+ SrcPtr = Builder.CreateBitCast(SrcPtr, CGM.Int8PtrPtrTy);
+ EmitNounwindRuntimeCall(Fn, {DstPtr.getPointer(), SrcPtr.getPointer()});
+}
Index: lib/CodeGen/CMakeLists.txt
===================================================================
--- lib/CodeGen/CMakeLists.txt
+++ lib/CodeGen/CMakeLists.txt
@@ -70,6 +70,7 @@
CGVTables.cpp
CodeGenABITypes.cpp
CodeGenAction.cpp
+ CodeGenCStruct.cpp
CodeGenFunction.cpp
CodeGenModule.cpp
CodeGenPGO.cpp
Index: lib/CodeGen/CGExprAgg.cpp
===================================================================
--- lib/CodeGen/CGExprAgg.cpp
+++ lib/CodeGen/CGExprAgg.cpp
@@ -77,7 +77,9 @@
void EmitAggLoadOfLValue(const Expr *E);
/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
- void EmitFinalDestCopy(QualType type, const LValue &src);
+ /// SrcIsRValue is true if source comes from an RValue.
+ void EmitFinalDestCopy(QualType type, const LValue &src,
+ bool SrcIsRValue = false);
void EmitFinalDestCopy(QualType type, RValue src);
void EmitCopy(QualType type, const AggValueSlot &dest,
const AggValueSlot &src);
@@ -245,6 +247,13 @@
/// directly into the return value slot. Otherwise, a final move
/// will be performed.
void AggExprEmitter::EmitMoveFromReturnSlot(const Expr *E, RValue src) {
+ // Push destructor if the result is ignored and the type is a C struct that
+ // is non-trivial to destroy.
+ QualType Ty = E->getType();
+ if (Dest.isIgnored() && Ty.hasNonTrivialToDestroyStruct())
+ CGF.pushDestroy(QualType::DK_non_trivial_c_struct,
+ src.getAggregateAddress(), Ty);
+
if (shouldUseDestForReturnSlot()) {
// Logically, Dest.getAddr() should equal Src.getAggregateAddr().
// The possibility of undef rvalues complicates that a lot,
@@ -261,11 +270,12 @@
void AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src) {
assert(src.isAggregate() && "value must be aggregate value!");
LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddress(), type);
- EmitFinalDestCopy(type, srcLV);
+ EmitFinalDestCopy(type, srcLV, true);
}
/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
-void AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src) {
+void AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src,
+ bool SrcIsRValue) {
// If Dest is ignored, then we're evaluating an aggregate expression
// in a context that doesn't care about the result. Note that loads
// from volatile l-values force the existence of a non-ignored
@@ -277,6 +287,32 @@
AggValueSlot::forLValue(src, AggValueSlot::IsDestructed,
needsGC(type), AggValueSlot::IsAliased);
EmitCopy(type, Dest, srcAgg);
+
+ // Copy non-trivial C structs here.
+
+ // For simplicity, both the destination and the source are treated as being
+ // volatile if either is volatile.
+ bool IsVolatile = Dest.isVolatile() || src.isVolatile();
+
+ if (SrcIsRValue) {
+ if (type.hasNonTrivialToDestructiveMoveStruct()) {
+ if (Dest.isPotentiallyAliased())
+ CGF.callMoveAssignmentOperator(Dest.getAddress(), src.getAddress(),
+ type, IsVolatile);
+ else
+ CGF.callMoveConstructor(Dest.getAddress(), src.getAddress(), type,
+ IsVolatile);
+ }
+ } else {
+ if (type.hasNonTrivialToCopyStruct()) {
+ if (Dest.isPotentiallyAliased())
+ CGF.callCopyAssignmentOperator(Dest.getAddress(), src.getAddress(),
+ type, IsVolatile);
+ else
+ CGF.callCopyConstructor(Dest.getAddress(), src.getAddress(), type,
+ IsVolatile);
+ }
+ }
}
/// Perform a copy from the source into the destination.
Index: lib/CodeGen/CGDeclCXX.cpp
===================================================================
--- lib/CodeGen/CGDeclCXX.cpp
+++ lib/CodeGen/CGDeclCXX.cpp
@@ -79,6 +79,7 @@
case QualType::DK_objc_strong_lifetime:
case QualType::DK_objc_weak_lifetime:
+ case QualType::DK_non_trivial_c_struct:
// We don't care about releasing objects during process teardown.
assert(!D.getTLSKind() && "should have rejected this");
return;
Index: lib/CodeGen/CGDecl.cpp
===================================================================
--- lib/CodeGen/CGDecl.cpp
+++ lib/CodeGen/CGDecl.cpp
@@ -1232,6 +1232,15 @@
if (emission.IsByRef)
emitByrefStructureInit(emission);
+ // Initialize the variable here if it doesn't have a initializer and it is a
+ // C struct that is non-trivial to initialize or an array containing such a
+ // struct.
+ if (!Init && type.hasNonTrivialToDefaultInitializeStruct()) {
+ defaultInitNonTrivialCStructVar(emission.getAllocatedAddress(), type,
+ type.isVolatileQualified());
+ return;
+ }
+
if (isTrivialInitializer(Init))
return;
@@ -1406,6 +1415,11 @@
case QualType::DK_objc_weak_lifetime:
break;
+
+ case QualType::DK_non_trivial_c_struct:
+ destroyer = CodeGenFunction::destroyNonTrivialCStruct;
+ cleanupKind = getARCCleanupKind();
+ break;
}
// If we haven't chosen a more specific destroyer, use the default.
@@ -1467,6 +1481,8 @@
return destroyARCStrongPrecise;
case QualType::DK_objc_weak_lifetime:
return destroyARCWeak;
+ case QualType::DK_non_trivial_c_struct:
+ return destroyNonTrivialCStruct;
}
llvm_unreachable("Unknown DestructionKind");
}
Index: lib/CodeGen/CGCall.cpp
===================================================================
--- lib/CodeGen/CGCall.cpp
+++ lib/CodeGen/CGCall.cpp
@@ -3532,6 +3532,16 @@
cast<CastExpr>(E)->getCastKind() == CK_LValueToRValue) {
LValue L = EmitLValue(cast<CastExpr>(E)->getSubExpr());
assert(L.isSimple());
+
+ // If type is a C struct that is non-trivial to copy, emit a call to its
+ // copy constructor to build the argument in the temporary slot.
+ if (type.hasNonTrivialToCopyStruct()) {
+ AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
+ EmitAggExpr(E, Slot);
+ args.add(Slot.asRValue(), type);
+ return;
+ }
+
if (L.getAlignment() >= getContext().getTypeAlignInChars(type)) {
args.add(L.asAggregateRValue(), type, /*NeedsCopy*/true);
} else {
Index: lib/CodeGen/CGBlocks.cpp
===================================================================
--- lib/CodeGen/CGBlocks.cpp
+++ lib/CodeGen/CGBlocks.cpp
@@ -2020,6 +2020,36 @@
id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
}
};
+
+/// Emits the copy/dispose helpers for a __block variable that is a non-trivial
+/// C struct.
+class NonTrivialCStructByrefHelpers final : public BlockByrefHelpers {
+ QualType VarType;
+
+public:
+ NonTrivialCStructByrefHelpers(CharUnits alignment, QualType type)
+ : BlockByrefHelpers(alignment), VarType(type) {}
+
+ void emitCopy(CodeGenFunction &CGF, Address destField,
+ Address srcField) override {
+ CGF.callMoveConstructor(destField, srcField, VarType,
+ VarType.isVolatileQualified());
+ }
+
+ bool needsDispose() const override {
+ return VarType.hasNonTrivialToDestroyStruct();
+ }
+
+ void emitDispose(CodeGenFunction &CGF, Address field) override {
+ EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin();
+ CGF.pushDestroy(QualType::DK_non_trivial_c_struct, field, VarType);
+ CGF.PopCleanupBlocks(cleanupDepth);
+ }
+
+ void profileImpl(llvm::FoldingSetNodeID &id) const override {
+ id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
+ }
+};
} // end anonymous namespace
static llvm::Constant *
@@ -2205,6 +2235,13 @@
CGM, byrefInfo, CXXByrefHelpers(valueAlignment, type, copyExpr));
}
+ // If type is a non-trivial C struct type that is non-trivial to
+ // destructly move or destroy, build the copy and dispose helpers.
+ if (type.hasNonTrivialToDestructiveMoveStruct() ||
+ type.hasNonTrivialToDestroyStruct())
+ return ::buildByrefHelpers(
+ CGM, byrefInfo, NonTrivialCStructByrefHelpers(valueAlignment, type));
+
// Otherwise, if we don't have a retainable type, there's nothing to do.
// that the runtime does extra copies.
if (!type->isObjCRetainableType()) return nullptr;
Index: lib/AST/Type.cpp
===================================================================
--- lib/AST/Type.cpp
+++ lib/AST/Type.cpp
@@ -2207,6 +2207,66 @@
getObjCLifetime() != Qualifiers::OCL_Weak;
}
+bool QualType::hasNonTrivialToDefaultInitializeStruct() const {
+ if (const auto *RT =
+ getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>())
+ return RT->getDecl()->nonTrivialToDefaultInitialize();
+ return false;
+}
+
+bool QualType::hasNonTrivialToCopyStruct() const {
+ if (const auto *RT =
+ getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>())
+ return RT->getDecl()->nonTrivialToCopy();
+ return false;
+}
+
+bool QualType::hasNonTrivialToDestructiveMoveStruct() const {
+ if (const auto *RT =
+ getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>())
+ return RT->getDecl()->nonTrivialToDestructiveMove();
+ return false;
+}
+
+bool QualType::hasNonTrivialToDestroyStruct() const {
+ if (const auto *RT =
+ getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>())
+ return RT->getDecl()->nonTrivialToDestroy();
+ return false;
+}
+
+bool QualType::nonTrivialToDefaultInitialize() const {
+ if (hasNonTrivialToDefaultInitializeStruct())
+ return true;
+
+ Qualifiers::ObjCLifetime Lifetime = getQualifiers().getObjCLifetime();
+ return Lifetime == Qualifiers::OCL_Strong;
+}
+
+bool QualType::nonTrivialToCopy() const {
+ if (hasNonTrivialToCopyStruct())
+ return true;
+
+ Qualifiers::ObjCLifetime Lifetime = getQualifiers().getObjCLifetime();
+ return Lifetime == Qualifiers::OCL_Strong;
+}
+
+bool QualType::nonTrivialToDestructiveMove() const {
+ if (hasNonTrivialToDestructiveMoveStruct())
+ return true;
+
+ Qualifiers::ObjCLifetime Lifetime = getQualifiers().getObjCLifetime();
+ return Lifetime == Qualifiers::OCL_Strong;
+}
+
+bool QualType::nonTrivialToDestroy() const {
+ if (hasNonTrivialToDestroyStruct())
+ return true;
+
+ Qualifiers::ObjCLifetime Lifetime = getQualifiers().getObjCLifetime();
+ return Lifetime == Qualifiers::OCL_Strong;
+}
+
bool Type::isLiteralType(const ASTContext &Ctx) const {
if (isDependentType())
return false;
@@ -3895,6 +3955,11 @@
return DK_objc_weak_lifetime;
}
+ // See if this is a C struct that is non-trivial to destroy or an array that
+ // contains such a struct.
+ if (type.hasNonTrivialToDestroyStruct())
+ return DK_non_trivial_c_struct;
+
/// Currently, the only destruction kind we recognize is C++ objects
/// with non-trivial destructors.
const CXXRecordDecl *record =
Index: lib/AST/Decl.cpp
===================================================================
--- lib/AST/Decl.cpp
+++ lib/AST/Decl.cpp
@@ -3892,7 +3892,9 @@
: TagDecl(DK, TK, C, DC, IdLoc, Id, PrevDecl, StartLoc),
HasFlexibleArrayMember(false), AnonymousStructOrUnion(false),
HasObjectMember(false), HasVolatileMember(false),
- LoadedFieldsFromExternalStorage(false) {
+ LoadedFieldsFromExternalStorage(false),
+ NonTrivialToDefaultInitialize(false), NonTrivialToCopy(false),
+ NonTrivialToDestructiveMove(false), NonTrivialToDestroy(false) {
assert(classof(static_cast<Decl*>(this)) && "Invalid Kind!");
}
Index: lib/AST/ASTContext.cpp
===================================================================
--- lib/AST/ASTContext.cpp
+++ lib/AST/ASTContext.cpp
@@ -5776,6 +5776,12 @@
return true;
}
+ // Return true if Ty is a non-trivial C struct type that is non-trivial to
+ // destructly move or destroy.
+ if (Ty.hasNonTrivialToDestructiveMoveStruct() ||
+ Ty.hasNonTrivialToDestroyStruct())
+ return true;
+
if (!Ty->isObjCRetainableType()) return false;
Qualifiers qs = Ty.getQualifiers();
Index: include/clang/Basic/DiagnosticSemaKinds.td
===================================================================
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -5109,12 +5109,17 @@
"jump bypasses initialization of __strong variable">;
def note_protected_by_objc_weak_init : Note<
"jump bypasses initialization of __weak variable">;
+def note_protected_by_non_trivial_c_struct_init : Note<
+ "jump bypasses initialization of variable of non-trivial C struct type">;
def note_enters_block_captures_cxx_obj : Note<
"jump enters lifetime of block which captures a destructible C++ object">;
def note_enters_block_captures_strong : Note<
"jump enters lifetime of block which strongly captures a variable">;
def note_enters_block_captures_weak : Note<
"jump enters lifetime of block which weakly captures a variable">;
+def note_enters_block_captures_non_trivial_c_struct : Note<
+ "jump enters lifetime of block which captures a C struct that is non-trivial "
+ "to destroy">;
def note_exits_cleanup : Note<
"jump exits scope of variable with __attribute__((cleanup))">;
@@ -5155,6 +5160,9 @@
"jump exits lifetime of block which strongly captures a variable">;
def note_exits_block_captures_weak : Note<
"jump exits lifetime of block which weakly captures a variable">;
+def note_exits_block_captures_non_trivial_c_struct : Note<
+ "jump exits lifetime of block which captures a C struct that is non-trivial "
+ "to destroy">;
def err_func_returning_qualified_void : ExtWarn<
"function cannot return qualified void type %0">,
@@ -7173,6 +7181,10 @@
"cannot pass object with interface type %1 by value to variadic "
"%select{function|block|method|constructor}2; expected type from format "
"string was %3">;
+def err_cannot_pass_non_trivial_c_struct_to_vararg : Error<
+ "cannot pass non-trivial C object of type %0 by value to variadic "
+ "%select{function|block|method|constructor}1">;
+
def err_cannot_pass_objc_interface_to_vararg : Error<
"cannot pass object with interface type %0 by value through variadic "
Index: include/clang/AST/Type.h
===================================================================
--- include/clang/AST/Type.h
+++ include/clang/AST/Type.h
@@ -1084,11 +1084,47 @@
// true when Type is objc's weak and weak is enabled but ARC isn't.
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;
+ /// Functions to query basic properties of non-trivial C struct types.
+
+ /// Returns true if this type is a C struct that is non-trivial to
+ /// default-initialize or an array that contains such a struct.
+ bool hasNonTrivialToDefaultInitializeStruct() const;
+
+ /// Returns true if this type is a C struct that is non-trivial to copy or an
+ /// array that contains such a struct.
+ bool hasNonTrivialToCopyStruct() const;
+
+ /// Returns true if this type is a C struct that is non-trivial to
+ /// destructively move or an array that contains such a struct.
+ bool hasNonTrivialToDestructiveMoveStruct() const;
+
+ /// Returns true if this type is a C struct that is non-trivial to destroy or
+ /// an array that contains such a struct.
+ bool hasNonTrivialToDestroyStruct() const;
+
+ /// Returns true if this is a non-trivial type that would cause a struct
+ /// transitively containing this type to be non-trivial to default initialize.
+ bool nonTrivialToDefaultInitialize() const;
+
+ /// Returns true if this is a non-trivial type that would cause a struct
+ /// transitively containing this type to be non-trivial to copy.
+ bool nonTrivialToCopy() const;
+
+ /// Returns true if this is a non-trivial type that would cause a struct
+ /// transitively containing this type to be non-trivial to destructively
+ /// move.
+ bool nonTrivialToDestructiveMove() const;
+
+ /// Returns true if this is a non-trivial type that would cause a struct
+ /// transitively containing this type to be non-trivial to destroy.
+ bool nonTrivialToDestroy() const;
+
enum DestructionKind {
DK_none,
DK_cxx_destructor,
DK_objc_strong_lifetime,
- DK_objc_weak_lifetime
+ DK_objc_weak_lifetime,
+ DK_non_trivial_c_struct
};
/// Returns a nonzero value if objects of this type require
Index: include/clang/AST/Decl.h
===================================================================
--- include/clang/AST/Decl.h
+++ include/clang/AST/Decl.h
@@ -3506,6 +3506,12 @@
/// when needed.
mutable bool LoadedFieldsFromExternalStorage : 1;
+ /// Basic properties of non-trivial C structs.
+ bool NonTrivialToDefaultInitialize : 1;
+ bool NonTrivialToCopy : 1;
+ bool NonTrivialToDestructiveMove : 1;
+ bool NonTrivialToDestroy : 1;
+
protected:
RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
SourceLocation StartLoc, SourceLocation IdLoc,
@@ -3565,6 +3571,39 @@
LoadedFieldsFromExternalStorage = val;
}
+ /// Functions to query basic properties of non-trivial C structs.
+ bool nonTrivialToDefaultInitialize() const {
+ return NonTrivialToDefaultInitialize;
+ }
+
+ void setNonTrivialToDefaultInitialize(bool val) {
+ NonTrivialToDefaultInitialize = val;
+ }
+
+ bool nonTrivialToCopy() const {
+ return NonTrivialToCopy;
+ }
+
+ void setNonTrivialToCopy(bool val) {
+ NonTrivialToCopy = val;
+ }
+
+ bool nonTrivialToDestructiveMove() const {
+ return NonTrivialToDestructiveMove;
+ }
+
+ void setNonTrivialToDestructiveMove(bool val) {
+ NonTrivialToDestructiveMove = val;
+ }
+
+ bool nonTrivialToDestroy() const {
+ return NonTrivialToDestroy;
+ }
+
+ void setNonTrivialToDestroy(bool val) {
+ NonTrivialToDestroy = val;
+ }
+
/// \brief Determines whether this declaration represents the
/// injected class name.
///
_______________________________________________
cfe-commits mailing list
[email protected]
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
