maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGenCXX/compound-literals.cpp

58 lines
2.0 KiB
C++
Raw Normal View History

CodeGen: Compound literals with funny types shouldn't crash CodeGen assumed that a compound literal with array type should have a corresponding LLVM IR array type. We had two bugs in this area: - Zero sized arrays in compound literals would lead to the creation of an opaque type. This is unnecessary, we should just create an array type with a bound of zero. - Funny record types (like unions) lead to exotic IR types for compound literals. In this case, CodeGen must be prepared to deal with the possibility that it might not have an array IR type. This fixes PR21912. llvm-svn: 224219
2014-12-14 20:16:43 +08:00
// RUN: %clang_cc1 -std=c++11 -triple armv7-none-eabi -emit-llvm -o - %s | FileCheck %s
Implement proper support for generating code for compound literals in C++, which means: - binding the temporary as needed in Sema, so that we generate the appropriate call to the destructor, and - emitting the compound literal into the appropriate location for the aggregate, rather than trying to emit it as a temporary and memcpy() it. Fixes PR10138 / <rdar://problem/9615901>. llvm-svn: 133235
2011-06-17 12:59:12 +08:00
struct X {
X();
X(const X&);
X(const char*);
~X();
};
struct Y {
int i;
X x;
};
CHECK-LABEL-ify some code gen tests to improve diagnostic experience when tests fail. llvm-svn: 188447
2013-08-15 14:47:53 +08:00
// CHECK-LABEL: define i32 @_Z1fv()
Implement proper support for generating code for compound literals in C++, which means: - binding the temporary as needed in Sema, so that we generate the appropriate call to the destructor, and - emitting the compound literal into the appropriate location for the aggregate, rather than trying to emit it as a temporary and memcpy() it. Fixes PR10138 / <rdar://problem/9615901>. llvm-svn: 133235
2011-06-17 12:59:12 +08:00
int f() {
// CHECK: [[LVALUE:%[a-z0-9.]+]] = alloca
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[I:%[a-z0-9]+]] = getelementptr inbounds {{.*}}, {{.*}}* [[LVALUE]], i32 0, i32 0
Implement proper support for generating code for compound literals in C++, which means: - binding the temporary as needed in Sema, so that we generate the appropriate call to the destructor, and - emitting the compound literal into the appropriate location for the aggregate, rather than trying to emit it as a temporary and memcpy() it. Fixes PR10138 / <rdar://problem/9615901>. llvm-svn: 133235
2011-06-17 12:59:12 +08:00
// CHECK-NEXT: store i32 17, i32* [[I]]
// CHECK-NEXT: [[X:%[a-z0-9]+]] = getelementptr inbounds {{.*}} [[LVALUE]], i32 0, i32 1
Fix ABI dependent tests by providing an explicit target triple. Patch by Joey Gouly. llvm-svn: 164239
2012-09-20 02:46:03 +08:00
// CHECK-NEXT: call %struct.X* @_ZN1XC1EPKc({{.*}}[[X]]
Implement proper support for generating code for compound literals in C++, which means: - binding the temporary as needed in Sema, so that we generate the appropriate call to the destructor, and - emitting the compound literal into the appropriate location for the aggregate, rather than trying to emit it as a temporary and memcpy() it. Fixes PR10138 / <rdar://problem/9615901>. llvm-svn: 133235
2011-06-17 12:59:12 +08:00
// CHECK-NEXT: [[I:%[a-z0-9]+]] = getelementptr inbounds {{.*}} [[LVALUE]], i32 0, i32 0
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: [[RESULT:%[a-z0-9]+]] = load i32, i32*
Fix ABI dependent tests by providing an explicit target triple. Patch by Joey Gouly. llvm-svn: 164239
2012-09-20 02:46:03 +08:00
// CHECK-NEXT: call %struct.Y* @_ZN1YD1Ev
Implement proper support for generating code for compound literals in C++, which means: - binding the temporary as needed in Sema, so that we generate the appropriate call to the destructor, and - emitting the compound literal into the appropriate location for the aggregate, rather than trying to emit it as a temporary and memcpy() it. Fixes PR10138 / <rdar://problem/9615901>. llvm-svn: 133235
2011-06-17 12:59:12 +08:00
// CHECK-NEXT: ret i32 [[RESULT]]
return ((Y){17, "seventeen"}).i;
}
When reference binding array rvalues, such as those created by compound literals of array type, materialise a temporary. llvm-svn: 144483
2011-11-13 08:51:30 +08:00
CHECK-LABEL-ify some code gen tests to improve diagnostic experience when tests fail. llvm-svn: 188447
2013-08-15 14:47:53 +08:00
// CHECK-LABEL: define i32 @_Z1gv()
When reference binding array rvalues, such as those created by compound literals of array type, materialise a temporary. llvm-svn: 144483
2011-11-13 08:51:30 +08:00
int g() {
Reapply r231508 "CodeGen: Emit constant temporaries into read-only globals." I disabled putting the new global into the same COMDAT as the function for now. There's a fundamental problem when we inline references to the global but still have the global in a COMDAT linked to the inlined function. Since this is only an optimization there may be other versions of the COMDAT around that are missing the new global and hell breaks loose at link time. I hope the chromium build doesn't break this time :) llvm-svn: 231564
2015-03-07 21:37:13 +08:00
// CHECK: store [2 x i32]* @{{.*}}, [2 x i32]** [[V:%[a-z0-9.]+]]
When reference binding array rvalues, such as those created by compound literals of array type, materialise a temporary. llvm-svn: 144483
2011-11-13 08:51:30 +08:00
const int (&v)[2] = (int [2]) {1,2};
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[A:%[a-z0-9.]+]] = load [2 x i32]*, [2 x i32]** [[V]]
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[A0ADDR:%[a-z0-9.]+]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i32 0, {{.*}} 0
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: [[A0:%[a-z0-9.]+]] = load i32, i32* [[A0ADDR]]
When reference binding array rvalues, such as those created by compound literals of array type, materialise a temporary. llvm-svn: 144483
2011-11-13 08:51:30 +08:00
// CHECK-NEXT: ret i32 [[A0]]
return v[0];
}
Use static storage duration for file-scope compound literals, even when they appear in non-constant initializers in C++. llvm-svn: 145087
2011-11-23 06:48:32 +08:00
struct Z { int i[3]; };
int *p = (Z){ {1, 2, 3} }.i;
// CHECK: define {{.*}}__cxx_global_var_init()
Don't check alignment, it's irrelevant to this test. llvm-svn: 145093
2011-11-23 10:12:00 +08:00
// CHECK: store i32* getelementptr inbounds (%struct.Z* @.compoundliteral, i32 0, i32 0, i32 0), i32** @p
CodeGen: Compound literals with funny types shouldn't crash CodeGen assumed that a compound literal with array type should have a corresponding LLVM IR array type. We had two bugs in this area: - Zero sized arrays in compound literals would lead to the creation of an opaque type. This is unnecessary, we should just create an array type with a bound of zero. - Funny record types (like unions) lead to exotic IR types for compound literals. In this case, CodeGen must be prepared to deal with the possibility that it might not have an array IR type. This fixes PR21912. llvm-svn: 224219
2014-12-14 20:16:43 +08:00
int *PR21912_1 = (int []){};
// CHECK-LABEL: define {{.*}}__cxx_global_var_init1()
// CHECK: store i32* getelementptr inbounds ([0 x i32]* @.compoundliteral2, i32 0, i32 0), i32** @PR21912_1
union PR21912Ty {
long long l;
double d;
};
union PR21912Ty *PR21912_2 = (union PR21912Ty[]){{.d = 2.0}, {.l = 3}};
// CHECK-LABEL: define {{.*}}__cxx_global_var_init3()
// CHECK: store %union.PR21912Ty* getelementptr inbounds ([2 x %union.PR21912Ty]* bitcast (<{ { double }, %union.PR21912Ty }>* @.compoundliteral4 to [2 x %union.PR21912Ty]*), i32 0, i32 0), %union.PR21912Ty** @PR21912_2