This is an archive of the discontinued LLVM Phabricator instance.

Differential D64392

CodeGen: Use memset for bytewise values with any size
Changes PlannedPublic

Authored by vitalybuka on Jul 9 2019, 1:46 AM.

Details

Reviewers
eugenis
pcc
jfb
Summary

It was already done for zeros, now we support any bytes

Diff Detail

Revision Contents

PathSize
clang/
lib/
CodeGen/
15 lines
test/
CodeGen/
5 lines
3 lines
2 lines
9 lines
CodeGenCXX/
235 lines
2 lines

Diff 208613

clang/lib/CodeGen/CGDecl.cpp

Show First 20 Lines • Show All 948 Lines • ▼ Show 20 Lines
/// Decide whether we should use memset to initialize a local variable instead /// Decide whether we should use memset to initialize a local variable instead
/// of using a memcpy from a constant global. /// of using a memcpy from a constant global.
static llvm::Value *shouldUseMemSetToInitialize(CodeGenModule &CGM, static llvm::Value *shouldUseMemSetToInitialize(CodeGenModule &CGM,
llvm::Constant *Init, llvm::Constant *Init,
uint64_t GlobalSize) { uint64_t GlobalSize) {
llvm::MostFrequentByte MFB = llvm::MostFrequentByte MFB =
llvm::getMostFrequentByte(Init, CGM.getDataLayout()); llvm::getMostFrequentByte(Init, CGM.getDataLayout());
if (0) {
// TODO: Use this branch and remove 'else'. Now we can do that for any
// value, but it requires tests updates, so I'll enable it in a separate
// patch.
if (MFB.Value && !MFB.Other) if (MFB.Value && !MFB.Other)
return MFB.Value; return MFB.Value;
} else {
if (isa<llvm::ConstantAggregateZero>(Init)) {
assert(MFB.Value);
assert(!MFB.Other);
return MFB.Value;
}
}
// TODO: Tweak these constants or use "density". // TODO: Tweak these constants or use "density".
uint64_t SizeLimit = 32; uint64_t SizeLimit = 32;
if (GlobalSize <= SizeLimit) if (GlobalSize <= SizeLimit)
return nullptr; return nullptr;
// We don't know most frequent byte, we may still completely initialize it // We don't know most frequent byte, we may still completely initialize it
// with small number of stores. // with small number of stores.
▲ Show 20 Lines • Show All 1,554 Lines • Show Last 20 Lines

clang/test/CodeGen/arm-swiftcall.c

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Linestypedef struct {
char c0; char c0;
__attribute__((aligned(2))) char c1; __attribute__((aligned(2))) char c1;
float f0; float f0;
float f1; float f1;
} struct_2; } struct_2;
TEST(struct_2); TEST(struct_2);
// CHECK-LABEL: define {{.*}} @return_struct_2() // CHECK-LABEL: define {{.*}} @return_struct_2()
// CHECK: [[RET:%.*]] = alloca [[REC:%.*]], align 4 // CHECK: [[RET:%.*]] = alloca [[REC:%.*]], align 4
// CHECK: @llvm.memcpy // CHECK: @llvm.memset
// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ i32, i32, float, float }]]* // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ i32, i32, float, float }]]*
// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align 4 // CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align 4
// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
// CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align 4 // CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align 4
// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 2
// CHECK: [[THIRD:%.*]] = load float, float* [[T0]], align // CHECK: [[THIRD:%.*]] = load float, float* [[T0]], align
// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 3
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
typedef union { typedef union {
float f; float f;
double d; double d;
} union_het_fp; } union_het_fp;
TEST(union_het_fp) TEST(union_het_fp)
// CHECK-LABEL: define {{.*}} @return_union_het_fp() // CHECK-LABEL: define {{.*}} @return_union_het_fp()
// CHECK: [[RET:%.*]] = alloca [[REC:%.*]], align {{(4|8)}} // CHECK: [[RET:%.*]] = alloca [[REC:%.*]], align {{(4|8)}}
// CHECK: @llvm.memcpy // CHECK: @llvm.memset
// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ i32, i32 }]]* // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ i32, i32 }]]*
// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align {{(4|8)}} // CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align {{(4|8)}}
// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
// CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align {{(4|8)}} // CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align {{(4|8)}}
// CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ i32, i32 }]] undef, i32 [[FIRST]], 0 // CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ i32, i32 }]] undef, i32 [[FIRST]], 0
// CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], i32 [[SECOND]], 1 // CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], i32 [[SECOND]], 1
// CHECK: ret [[UAGG]] [[T1]] // CHECK: ret [[UAGG]] [[T1]]
Show All 18 Lines
// CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]* // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*
// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
// CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align {{(4|8)}} // CHECK: [[FIRST:%.*]] = load i32, i32* [[T0]], align {{(4|8)}}
// CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
// CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align {{(4|8)}} // CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align {{(4|8)}}
// CHECK: call [[SWIFTCC]] void @take_union_het_fp(i32 [[FIRST]], i32 [[SECOND]]) // CHECK: call [[SWIFTCC]] void @take_union_het_fp(i32 [[FIRST]], i32 [[SECOND]])
// CHECK: ret void // CHECK: ret void
typedef union { typedef union {
float f1; float f1;
float f2; float f2;
} union_hom_fp; } union_hom_fp;
TEST(union_hom_fp) TEST(union_hom_fp)
// CHECK-LABEL: define void @test_union_hom_fp() // CHECK-LABEL: define void @test_union_hom_fp()
// CHECK: [[TMP:%.*]] = alloca [[REC:%.*]], align 4 // CHECK: [[TMP:%.*]] = alloca [[REC:%.*]], align 4
// CHECK: [[CALL:%.*]] = call [[SWIFTCC]] float @return_union_hom_fp() // CHECK: [[CALL:%.*]] = call [[SWIFTCC]] float @return_union_hom_fp()
▲ Show 20 Lines • Show All 691 Lines • Show Last 20 Lines

clang/test/CodeGen/dump-struct-builtin.c

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
// CHECK-NEXT: [[END_STRUCT_U7:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00" // CHECK-NEXT: [[END_STRUCT_U7:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
// CHECK: @__const.unit8.a = private unnamed_addr constant %struct.U8A { i64 12 }, align 8 // CHECK: @__const.unit8.a = private unnamed_addr constant %struct.U8A { i64 12 }, align 8
// CHECK-NEXT: [[STRUCT_STR_U8:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U8A {\0A\00" // CHECK-NEXT: [[STRUCT_STR_U8:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U8A {\0A\00"
// CHECK-NEXT: [[FIELD_U8:@[0-9]+]] = private unnamed_addr constant [24 x i8] c"unsigned long long a : \00" // CHECK-NEXT: [[FIELD_U8:@[0-9]+]] = private unnamed_addr constant [24 x i8] c"unsigned long long a : \00"
// CHECK-NEXT: [[FORMAT_U8:@[0-9]+]] = private unnamed_addr constant [6 x i8] c"%llu\0A\00" // CHECK-NEXT: [[FORMAT_U8:@[0-9]+]] = private unnamed_addr constant [6 x i8] c"%llu\0A\00"
// CHECK-NEXT: [[END_STRUCT_U8:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00" // CHECK-NEXT: [[END_STRUCT_U8:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
// CHECK: @__const.unit9.a = private unnamed_addr constant %struct.U9A { i8 97 }, align 1
// CHECK-NEXT: [[STRUCT_STR_U9:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U9A {\0A\00" // CHECK-NEXT: [[STRUCT_STR_U9:@[0-9]+]] = private unnamed_addr constant [14 x i8] c"struct U9A {\0A\00"
// CHECK-NEXT: [[FIELD_U9:@[0-9]+]] = private unnamed_addr constant [10 x i8] c"char a : \00" // CHECK-NEXT: [[FIELD_U9:@[0-9]+]] = private unnamed_addr constant [10 x i8] c"char a : \00"
// CHECK-NEXT: [[FORMAT_U9:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%c\0A\00" // CHECK-NEXT: [[FORMAT_U9:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%c\0A\00"
// CHECK-NEXT: [[END_STRUCT_U9:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00" // CHECK-NEXT: [[END_STRUCT_U9:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
// CHECK: @.str = private unnamed_addr constant [4 x i8] c"LSE\00", align 1 // CHECK: @.str = private unnamed_addr constant [4 x i8] c"LSE\00", align 1
// CHECK: @__const.unit10.a = private unnamed_addr constant %struct.U10A { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0) }, align 8 // CHECK: @__const.unit10.a = private unnamed_addr constant %struct.U10A { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0) }, align 8
Show All 27 Lines
// CHECK-NEXT: [[END_STRUCT_U14:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00" // CHECK-NEXT: [[END_STRUCT_U14:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
// CHECK: @__const.unit15.a = private unnamed_addr constant %struct.U15A { [3 x i32] [i32 1, i32 2, i32 3] }, align 4 // CHECK: @__const.unit15.a = private unnamed_addr constant %struct.U15A { [3 x i32] [i32 1, i32 2, i32 3] }, align 4
// CHECK-NEXT: [[STRUCT_STR_U15:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U15A {\0A\00" // CHECK-NEXT: [[STRUCT_STR_U15:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U15A {\0A\00"
// CHECK-NEXT: [[FIELD_U15:@[0-9]+]] = private unnamed_addr constant [13 x i8] c"int [3] a : \00" // CHECK-NEXT: [[FIELD_U15:@[0-9]+]] = private unnamed_addr constant [13 x i8] c"int [3] a : \00"
// CHECK-NEXT: [[FORMAT_U15:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%p\0A\00" // CHECK-NEXT: [[FORMAT_U15:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%p\0A\00"
// CHECK-NEXT: [[END_STRUCT_U15:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00" // CHECK-NEXT: [[END_STRUCT_U15:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
// CHECK: @__const.unit16.a = private unnamed_addr constant %struct.U16A { i8 12 }, align 1
// CHECK-NEXT: [[STRUCT_STR_U16:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U16A {\0A\00" // CHECK-NEXT: [[STRUCT_STR_U16:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U16A {\0A\00"
// CHECK-NEXT: [[FIELD_U16:@[0-9]+]] = private unnamed_addr constant [13 x i8] c"uint8_t a : \00" // CHECK-NEXT: [[FIELD_U16:@[0-9]+]] = private unnamed_addr constant [13 x i8] c"uint8_t a : \00"
// CHECK-NEXT: [[FORMAT_U16:@[0-9]+]] = private unnamed_addr constant [6 x i8] c"%hhu\0A\00" // CHECK-NEXT: [[FORMAT_U16:@[0-9]+]] = private unnamed_addr constant [6 x i8] c"%hhu\0A\00"
// CHECK-NEXT: [[END_STRUCT_U16:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00" // CHECK-NEXT: [[END_STRUCT_U16:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
// CHECK: @__const.unit17.a = private unnamed_addr constant %struct.U17A { i8 12 }, align 1
// CHECK-NEXT: [[STRUCT_STR_U17:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U17A {\0A\00" // CHECK-NEXT: [[STRUCT_STR_U17:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U17A {\0A\00"
// CHECK-NEXT: [[FIELD_U17:@[0-9]+]] = private unnamed_addr constant [12 x i8] c"int8_t a : \00" // CHECK-NEXT: [[FIELD_U17:@[0-9]+]] = private unnamed_addr constant [12 x i8] c"int8_t a : \00"
// CHECK-NEXT: [[FORMAT_U17:@[0-9]+]] = private unnamed_addr constant [6 x i8] c"%hhd\0A\00" // CHECK-NEXT: [[FORMAT_U17:@[0-9]+]] = private unnamed_addr constant [6 x i8] c"%hhd\0A\00"
// CHECK-NEXT: [[END_STRUCT_U17:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00" // CHECK-NEXT: [[END_STRUCT_U17:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00"
// CHECK: @__const.unit18.a = private unnamed_addr constant %struct.U18A { x86_fp80 0xK3FFF8FCD67FD3F5B6000 }, align 16 // CHECK: @__const.unit18.a = private unnamed_addr constant %struct.U18A { x86_fp80 0xK3FFF8FCD67FD3F5B6000 }, align 16
// CHECK-NEXT: [[STRUCT_STR_U18:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U18A {\0A\00" // CHECK-NEXT: [[STRUCT_STR_U18:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U18A {\0A\00"
// CHECK-NEXT: [[FIELD_U18:@[0-9]+]] = private unnamed_addr constant [17 x i8] c"long double a : \00" // CHECK-NEXT: [[FIELD_U18:@[0-9]+]] = private unnamed_addr constant [17 x i8] c"long double a : \00"
▲ Show 20 Lines • Show All 443 Lines • Show Last 20 Lines

clang/test/CodeGen/init-memset.c

// RUN: %clang_cc1 -triple x86_64-unknown-unknown -O0 -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple x86_64-unknown-unknown -O0 -emit-llvm -o - %s | FileCheck %s
void use(void *); void use(void *);
void test_small() { void test_small() {
// CHECK-LABEL: define void @test_small() // CHECK-LABEL: define void @test_small()
int a[] = {1, 2, 3, 4}; int a[] = {1, 2, 3, 4};
// CHECK: call void @llvm.memcpy.{{.*}} // CHECK: call void @llvm.memcpy.{{.*}}
use(a); use(a);
} }
void test_small_same() { void test_small_same() {
// CHECK-LABEL: define void @test_small_same() // CHECK-LABEL: define void @test_small_same()
char a[] = {'a', 'a', 'a', 'a'}; char a[] = {'a', 'a', 'a', 'a'};
// CHECK: call void @llvm.memcpy.{{.*}} // CHECK: call void @llvm.memset.{{.*}}
use(a); use(a);
} }
void test_different() { void test_different() {
// CHECK-LABEL: define void @test_different() // CHECK-LABEL: define void @test_different()
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
// CHECK: call void @llvm.memcpy.{{.*}} // CHECK: call void @llvm.memcpy.{{.*}}
use(a); use(a);
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

clang/test/CodeGen/windows-swiftcall.c

// RUN: %clang_cc1 -triple x86_64-unknown-windows -emit-llvm -target-cpu core2 -o - %s | FileCheck %s // RUN: %clang_cc1 -triple x86_64-unknown-windows -emit-llvm -target-cpu core2 -o - %s | FileCheck %s
#define SWIFTCALL __attribute__((swiftcall)) #define SWIFTCALL __attribute__((swiftcall))
#define OUT __attribute__((swift_indirect_result)) #define OUT __attribute__((swift_indirect_result))
#define ERROR __attribute__((swift_error_result)) #define ERROR __attribute__((swift_error_result))
#define CONTEXT __attribute__((swift_context)) #define CONTEXT __attribute__((swift_context))
// CHECK: [[STRUCT2_RESULT:@.*]] = private {{.*}} constant [[STRUCT2_TYPE:%.*]] { i32 0, i8 0, i8 undef, i8 0, i32 0, i32 0 }
/*****************************************************************************/ /*****************************************************************************/
/****************************** PARAMETER ABIS *******************************/ /****************************** PARAMETER ABIS *******************************/
/*****************************************************************************/ /*****************************************************************************/
SWIFTCALL void indirect_result_1(OUT int *arg0, OUT float *arg1) {} SWIFTCALL void indirect_result_1(OUT int *arg0, OUT float *arg1) {}
// CHECK-LABEL: define {{.*}} void @indirect_result_1(i32* noalias sret align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}}) // CHECK-LABEL: define {{.*}} void @indirect_result_1(i32* noalias sret align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}})
// TODO: maybe this shouldn't suppress sret. // TODO: maybe this shouldn't suppress sret.
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Linestypedef struct {
int x; int x;
char c0; char c0;
__attribute__((aligned(2))) char c1; __attribute__((aligned(2))) char c1;
int f0; int f0;
int f1; int f1;
} struct_2; } struct_2;
TEST(struct_2); TEST(struct_2);
// CHECK-LABEL: define dso_local swiftcc { i64, i64 } @return_struct_2() {{.*}}{ // CHECK-LABEL: define dso_local swiftcc { i64, i64 } @return_struct_2() {{.*}}{
// CHECK: [[RET:%.*]] = alloca [[STRUCT2_TYPE]], align 4 // CHECK: [[RET:%.*]] = alloca [[STRUCT2_TYPE:%.*]], align 4
// CHECK: [[CASTVAR:%.*]] = bitcast {{.*}} [[RET]] // CHECK: [[CASTVAR:%.*]] = bitcast {{.*}} [[RET]]
// CHECK: call void @llvm.memcpy{{.*}}({{.*}}[[CASTVAR]], {{.*}}[[STRUCT2_RESULT]] // CHECK: call void @llvm.memset{{.*}}({{.*}}[[CASTVAR]], {{.*}}
// CHECK: [[CAST:%.*]] = bitcast [[STRUCT2_TYPE]]* [[RET]] to { i64, i64 }* // CHECK: [[CAST:%.*]] = bitcast [[STRUCT2_TYPE]]* [[RET]] to { i64, i64 }*
// CHECK: [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 // CHECK: [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0
// CHECK: [[T0:%.*]] = load i64, i64* [[GEP0]], align 4 // CHECK: [[T0:%.*]] = load i64, i64* [[GEP0]], align 4
// CHECK: [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 // CHECK: [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1
// CHECK: [[T1:%.*]] = load i64, i64* [[GEP1]], align 4 // CHECK: [[T1:%.*]] = load i64, i64* [[GEP1]], align 4
// CHECK: [[R0:%.*]] = insertvalue { i64, i64 } undef, i64 [[T0]], 0 // CHECK: [[R0:%.*]] = insertvalue { i64, i64 } undef, i64 [[T0]], 0
// CHECK: [[R1:%.*]] = insertvalue { i64, i64 } [[R0]], i64 [[T1]], 1 // CHECK: [[R1:%.*]] = insertvalue { i64, i64 } [[R0]], i64 [[T1]], 1
// CHECK: ret { i64, i64 } [[R1]] // CHECK: ret { i64, i64 } [[R1]]
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
typedef union { typedef union {
float f; float f;
double d; double d;
} union_het_fp; } union_het_fp;
TEST(union_het_fp) TEST(union_het_fp)
// CHECK-LABEL: define dso_local swiftcc i64 @return_union_het_fp() // CHECK-LABEL: define dso_local swiftcc i64 @return_union_het_fp()
// CHECK: [[RET:%.*]] = alloca [[UNION:%.*]], align 8 // CHECK: [[RET:%.*]] = alloca [[UNION:%.*]], align 8
// CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[RET]] to i8* // CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[RET]] to i8*
// CHECK: call void @llvm.memcpy{{.*}}(i8* align {{[0-9]+}} [[CAST]] // CHECK: call void @llvm.memset{{.*}}(i8* align {{[0-9]+}} [[CAST]]
// CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[RET]] to { i64 }* // CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[RET]] to { i64 }*
// CHECK: [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0 // CHECK: [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0
// CHECK: [[R0:%.*]] = load i64, i64* [[GEP]], align 8 // CHECK: [[R0:%.*]] = load i64, i64* [[GEP]], align 8
// CHECK: ret i64 [[R0]] // CHECK: ret i64 [[R0]]
// CHECK-LABEL: define dso_local swiftcc void @take_union_het_fp(i64) {{.*}}{ // CHECK-LABEL: define dso_local swiftcc void @take_union_het_fp(i64) {{.*}}{
// CHECK: [[V:%.*]] = alloca [[UNION:%.*]], align 8 // CHECK: [[V:%.*]] = alloca [[UNION:%.*]], align 8
// CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[V]] to { i64 }* // CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[V]] to { i64 }*
// CHECK: [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0 // CHECK: [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0
// CHECK: store i64 %0, i64* [[GEP]], align 8 // CHECK: store i64 %0, i64* [[GEP]], align 8
// CHECK: ret void // CHECK: ret void
// CHECK: } // CHECK: }
// CHECK-LABEL: define dso_local void @test_union_het_fp() {{.*}}{ // CHECK-LABEL: define dso_local void @test_union_het_fp() {{.*}}{
// CHECK: [[AGG:%.*]] = alloca [[UNION:%.*]], align 8 // CHECK: [[AGG:%.*]] = alloca [[UNION:%.*]], align 8
// CHECK: [[CALL:%.*]] = call swiftcc i64 @return_union_het_fp() // CHECK: [[CALL:%.*]] = call swiftcc i64 @return_union_het_fp()
// CHECK: [[T0:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64 }* // CHECK: [[T0:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64 }*
// CHECK: [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0 // CHECK: [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0
// CHECK: store i64 [[CALL]], i64* [[T1]], align 8 // CHECK: store i64 [[CALL]], i64* [[T1]], align 8
// CHECK: [[T0:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64 }* // CHECK: [[T0:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64 }*
// CHECK: [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0 // CHECK: [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0
// CHECK: [[V0:%.*]] = load i64, i64* [[T1]], align 8 // CHECK: [[V0:%.*]] = load i64, i64* [[T1]], align 8
// CHECK: call swiftcc void @take_union_het_fp(i64 [[V0]]) // CHECK: call swiftcc void @take_union_het_fp(i64 [[V0]])
// CHECK: ret void // CHECK: ret void
// CHECK: } // CHECK: }
typedef union { typedef union {
float f1; float f1;
float f2; float f2;
} union_hom_fp; } union_hom_fp;
TEST(union_hom_fp) TEST(union_hom_fp)
// CHECK-LABEL: define dso_local void @test_union_hom_fp() // CHECK-LABEL: define dso_local void @test_union_hom_fp()
// CHECK: [[TMP:%.*]] = alloca [[REC:%.*]], align 4 // CHECK: [[TMP:%.*]] = alloca [[REC:%.*]], align 4
// CHECK: [[CALL:%.*]] = call [[SWIFTCC]] float @return_union_hom_fp() // CHECK: [[CALL:%.*]] = call [[SWIFTCC]] float @return_union_hom_fp()
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

clang/test/CodeGenCXX/auto-var-init.cpp

Show All 28 Lines void test_##NAME##_custom() { \
type_##NAME custom __VA_ARGS__; \ type_##NAME custom __VA_ARGS__; \
used(custom); \ used(custom); \
} }
// None of the synthesized globals should contain `undef`. // None of the synthesized globals should contain `undef`.
// PATTERN-NOT: undef // PATTERN-NOT: undef
// ZERO-NOT: undef // ZERO-NOT: undef
// PATTERN-O0: @__const.test_empty_uninit.uninit = private unnamed_addr constant %struct.empty { i8 -86 }, align 1
// PATTERN-O1-NOT: @__const.test_empty_uninit.uninit
struct empty {}; struct empty {};
// PATTERN-O0: @__const.test_small_uninit.uninit = private unnamed_addr constant %struct.small { i8 -86 }, align 1
// PATTERN-O0: @__const.test_small_custom.custom = private unnamed_addr constant %struct.small { i8 42 }, align 1
// ZERO-O0: @__const.test_small_custom.custom = private unnamed_addr constant %struct.small { i8 42 }, align 1
// PATTERN-O1-NOT: @__const.test_small_uninit.uninit
// PATTERN-O1-NOT: @__const.test_small_custom.custom
// ZERO-O1-NOT: @__const.test_small_custom.custom
struct small { char c; }; struct small { char c; };
// PATTERN-O0: @__const.test_smallinit_uninit.uninit = private unnamed_addr constant %struct.smallinit { i8 -86 }, align 1
// PATTERN-O0: @__const.test_smallinit_braces.braces = private unnamed_addr constant %struct.smallinit { i8 -86 }, align 1
// PATTERN-O0: @__const.test_smallinit_custom.custom = private unnamed_addr constant %struct.smallinit { i8 -86 }, align 1
// PATTERN-O1-NOT: @__const.test_smallinit_uninit.uninit
// PATTERN-O1-NOT: @__const.test_smallinit_braces.braces
// PATTERN-O1-NOT: @__const.test_smallinit_custom.custom
struct smallinit { char c = 42; }; struct smallinit { char c = 42; };
// PATTERN-O0: @__const.test_smallpartinit_uninit.uninit = private unnamed_addr constant %struct.smallpartinit { i8 -86, i8 -86 }, align 1
// PATTERN-O0: @__const.test_smallpartinit_braces.braces = private unnamed_addr constant %struct.smallpartinit { i8 -86, i8 -86 }, align 1
// PATTERN-O0: @__const.test_smallpartinit_custom.custom = private unnamed_addr constant %struct.smallpartinit { i8 -86, i8 -86 }, align 1
// PATTERN-O1-NOT: @__const.test_smallpartinit_uninit.uninit
// PATTERN-O1-NOT: @__const.test_smallpartinit_braces.braces
// PATTERN-O1-NOT: @__const.test_smallpartinit_custom.custom
struct smallpartinit { char c = 42, d; }; struct smallpartinit { char c = 42, d; };
// PATTERN-O0: @__const.test_nullinit_uninit.uninit = private unnamed_addr constant %struct.nullinit { i8* inttoptr (i64 -6148914691236517206 to i8*) }, align 8
// PATTERN-O0: @__const.test_nullinit_braces.braces = private unnamed_addr constant %struct.nullinit { i8* inttoptr (i64 -6148914691236517206 to i8*) }, align 8
// PATTERN-O0: @__const.test_nullinit_custom.custom = private unnamed_addr constant %struct.nullinit { i8* inttoptr (i64 -6148914691236517206 to i8*) }, align 8
// PATTERN-O1-NOT: @__const.test_nullinit_uninit.uninit
// PATTERN-O1-NOT: @__const.test_nullinit_braces.braces
// PATTERN-O1-NOT: @__const.test_nullinit_custom.custom
struct nullinit { char* null = nullptr; }; struct nullinit { char* null = nullptr; };
// PATTERN-O0: @__const.test_padded_uninit.uninit = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 -86, [3 x i8] c"\AA\AA\AA", i32 -1431655766 }, align 4
// PATTERN-O0: @__const.test_padded_custom.custom = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 42, [3 x i8] zeroinitializer, i32 13371337 }, align 4 // PATTERN-O0: @__const.test_padded_custom.custom = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 42, [3 x i8] zeroinitializer, i32 13371337 }, align 4
// ZERO-O0: @__const.test_padded_custom.custom = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 42, [3 x i8] zeroinitializer, i32 13371337 }, align 4 // ZERO-O0: @__const.test_padded_custom.custom = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 42, [3 x i8] zeroinitializer, i32 13371337 }, align 4
// PATTERN-O1-NOT: @__const.test_padded_uninit.uninit
// PATTERN-O1-NOT: @__const.test_padded_custom.custom
// ZERO-O1-NOT: @__const.test_padded_custom.custom
struct padded { char c; int i; }; struct padded { char c; int i; };
// PATTERN-O0: @__const.test_paddednullinit_uninit.uninit = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 -86, [3 x i8] c"\AA\AA\AA", i32 -1431655766 }, align 4
// PATTERN-O0: @__const.test_paddednullinit_braces.braces = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 -86, [3 x i8] c"\AA\AA\AA", i32 -1431655766 }, align 4
// PATTERN-O0: @__const.test_paddednullinit_custom.custom = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 -86, [3 x i8] c"\AA\AA\AA", i32 -1431655766 }, align 4
// PATTERN-O1-NOT: @__const.test_paddednullinit_uninit.uninit
// PATTERN-O1-NOT: @__const.test_paddednullinit_braces.braces
// PATTERN-O1-NOT: @__const.test_paddednullinit_custom.custom
struct paddednullinit { char c = 0; int i = 0; }; struct paddednullinit { char c = 0; int i = 0; };
// PATTERN-O0: @__const.test_paddedpacked_uninit.uninit = private unnamed_addr constant %struct.paddedpacked <{ i8 -86, i32 -1431655766 }>, align 1
// PATTERN: @__const.test_paddedpacked_custom.custom = private unnamed_addr constant %struct.paddedpacked <{ i8 42, i32 13371337 }>, align 1 // PATTERN: @__const.test_paddedpacked_custom.custom = private unnamed_addr constant %struct.paddedpacked <{ i8 42, i32 13371337 }>, align 1
// ZERO: @__const.test_paddedpacked_custom.custom = private unnamed_addr constant %struct.paddedpacked <{ i8 42, i32 13371337 }>, align 1 // ZERO: @__const.test_paddedpacked_custom.custom = private unnamed_addr constant %struct.paddedpacked <{ i8 42, i32 13371337 }>, align 1
struct paddedpacked { char c; int i; } __attribute__((packed)); struct paddedpacked { char c; int i; } __attribute__((packed));
// PATTERN-O0: @__const.test_paddedpackedarray_uninit.uninit = private unnamed_addr constant %struct.paddedpackedarray { [2 x %struct.paddedpacked] [%struct.paddedpacked <{ i8 -86, i32 -1431655766 }>, %struct.paddedpacked <{ i8 -86, i32 -1431655766 }>] }, align 1
// PATTERN: @__const.test_paddedpackedarray_custom.custom = private unnamed_addr constant %struct.paddedpackedarray { [2 x %struct.paddedpacked] [%struct.paddedpacked <{ i8 42, i32 13371337 }>, %struct.paddedpacked <{ i8 43, i32 13371338 }>] }, align 1 // PATTERN: @__const.test_paddedpackedarray_custom.custom = private unnamed_addr constant %struct.paddedpackedarray { [2 x %struct.paddedpacked] [%struct.paddedpacked <{ i8 42, i32 13371337 }>, %struct.paddedpacked <{ i8 43, i32 13371338 }>] }, align 1
// ZERO: @__const.test_paddedpackedarray_custom.custom = private unnamed_addr constant %struct.paddedpackedarray { [2 x %struct.paddedpacked] [%struct.paddedpacked <{ i8 42, i32 13371337 }>, %struct.paddedpacked <{ i8 43, i32 13371338 }>] }, align 1 // ZERO: @__const.test_paddedpackedarray_custom.custom = private unnamed_addr constant %struct.paddedpackedarray { [2 x %struct.paddedpacked] [%struct.paddedpacked <{ i8 42, i32 13371337 }>, %struct.paddedpacked <{ i8 43, i32 13371338 }>] }, align 1
struct paddedpackedarray { struct paddedpacked p[2]; }; struct paddedpackedarray { struct paddedpacked p[2]; };
// PATTERN-O0: @__const.test_unpackedinpacked_uninit.uninit = private unnamed_addr constant <{ { i8, [3 x i8], i32 }, i8 }> <{ { i8, [3 x i8], i32 } { i8 -86, [3 x i8] c"\AA\AA\AA", i32 -1431655766 }, i8 -86 }>, align 1
struct unpackedinpacked { padded a; char b; } __attribute__((packed)); struct unpackedinpacked { padded a; char b; } __attribute__((packed));
// PATTERN-O0: @__const.test_paddednested_uninit.uninit = private unnamed_addr constant { { i8, [3 x i8], i32 }, { i8, [3 x i8], i32 } } { { i8, [3 x i8], i32 } { i8 -86, [3 x i8] c"\AA\AA\AA", i32 -1431655766 }, { i8, [3 x i8], i32 } { i8 -86, [3 x i8] c"\AA\AA\AA", i32 -1431655766 } }, align 4
// PATTERN: @__const.test_paddednested_custom.custom = private unnamed_addr constant { { i8, [3 x i8], i32 }, { i8, [3 x i8], i32 } } { { i8, [3 x i8], i32 } { i8 42, [3 x i8] zeroinitializer, i32 13371337 }, { i8, [3 x i8], i32 } { i8 43, [3 x i8] zeroinitializer, i32 13371338 } }, align 4 // PATTERN: @__const.test_paddednested_custom.custom = private unnamed_addr constant { { i8, [3 x i8], i32 }, { i8, [3 x i8], i32 } } { { i8, [3 x i8], i32 } { i8 42, [3 x i8] zeroinitializer, i32 13371337 }, { i8, [3 x i8], i32 } { i8 43, [3 x i8] zeroinitializer, i32 13371338 } }, align 4
// ZERO: @__const.test_paddednested_custom.custom = private unnamed_addr constant { { i8, [3 x i8], i32 }, { i8, [3 x i8], i32 } } { { i8, [3 x i8], i32 } { i8 42, [3 x i8] zeroinitializer, i32 13371337 }, { i8, [3 x i8], i32 } { i8 43, [3 x i8] zeroinitializer, i32 13371338 } }, align 4 // ZERO: @__const.test_paddednested_custom.custom = private unnamed_addr constant { { i8, [3 x i8], i32 }, { i8, [3 x i8], i32 } } { { i8, [3 x i8], i32 } { i8 42, [3 x i8] zeroinitializer, i32 13371337 }, { i8, [3 x i8], i32 } { i8 43, [3 x i8] zeroinitializer, i32 13371338 } }, align 4
struct paddednested { struct padded p1, p2; }; struct paddednested { struct padded p1, p2; };
// PATTERN-O0: @__const.test_paddedpackednested_uninit.uninit = private unnamed_addr constant %struct.paddedpackednested { %struct.paddedpacked <{ i8 -86, i32 -1431655766 }>, %struct.paddedpacked <{ i8 -86, i32 -1431655766 }> }, align 1
// PATTERN: @__const.test_paddedpackednested_custom.custom = private unnamed_addr constant %struct.paddedpackednested { %struct.paddedpacked <{ i8 42, i32 13371337 }>, %struct.paddedpacked <{ i8 43, i32 13371338 }> }, align 1 // PATTERN: @__const.test_paddedpackednested_custom.custom = private unnamed_addr constant %struct.paddedpackednested { %struct.paddedpacked <{ i8 42, i32 13371337 }>, %struct.paddedpacked <{ i8 43, i32 13371338 }> }, align 1
// ZERO: @__const.test_paddedpackednested_custom.custom = private unnamed_addr constant %struct.paddedpackednested { %struct.paddedpacked <{ i8 42, i32 13371337 }>, %struct.paddedpacked <{ i8 43, i32 13371338 }> }, align 1 // ZERO: @__const.test_paddedpackednested_custom.custom = private unnamed_addr constant %struct.paddedpackednested { %struct.paddedpacked <{ i8 42, i32 13371337 }>, %struct.paddedpacked <{ i8 43, i32 13371338 }> }, align 1
struct paddedpackednested { struct paddedpacked p1, p2; }; struct paddedpackednested { struct paddedpacked p1, p2; };
// PATTERN-O0: @__const.test_bitfield_uninit.uninit = private unnamed_addr constant %struct.bitfield { i8 -86, [3 x i8] c"\AA\AA\AA" }, align 4
// PATTERN-O0: @__const.test_bitfield_custom.custom = private unnamed_addr constant %struct.bitfield { i8 20, [3 x i8] c"\AA\AA\AA" }, align 4 // PATTERN-O0: @__const.test_bitfield_custom.custom = private unnamed_addr constant %struct.bitfield { i8 20, [3 x i8] c"\AA\AA\AA" }, align 4
// ZERO-O0: @__const.test_bitfield_custom.custom = private unnamed_addr constant %struct.bitfield { i8 20, [3 x i8] zeroinitializer }, align 4 // ZERO-O0: @__const.test_bitfield_custom.custom = private unnamed_addr constant %struct.bitfield { i8 20, [3 x i8] zeroinitializer }, align 4
// PATTERN-O1-NOT: @__const.test_bitfield_uninit.uninit
// PATTERN-O1-NOT: @__const.test_bitfield_custom.custom
// ZERO-O1-NOT: @__const.test_bitfield_custom.custom
struct bitfield { int i : 4; int j : 2; }; struct bitfield { int i : 4; int j : 2; };
// PATTERN-O0: @__const.test_bitfieldaligned_uninit.uninit = private unnamed_addr constant %struct.bitfieldaligned { i8 -86, [3 x i8] c"\AA\AA\AA", i8 -86, [3 x i8] c"\AA\AA\AA" }, align 4
// PATTERN-O0: @__const.test_bitfieldaligned_custom.custom = private unnamed_addr constant %struct.bitfieldaligned { i8 4, [3 x i8] c"\AA\AA\AA", i8 1, [3 x i8] c"\AA\AA\AA" }, align 4 // PATTERN-O0: @__const.test_bitfieldaligned_custom.custom = private unnamed_addr constant %struct.bitfieldaligned { i8 4, [3 x i8] c"\AA\AA\AA", i8 1, [3 x i8] c"\AA\AA\AA" }, align 4
// ZERO-O0: @__const.test_bitfieldaligned_custom.custom = private unnamed_addr constant %struct.bitfieldaligned { i8 4, [3 x i8] zeroinitializer, i8 1, [3 x i8] zeroinitializer }, align 4 // ZERO-O0: @__const.test_bitfieldaligned_custom.custom = private unnamed_addr constant %struct.bitfieldaligned { i8 4, [3 x i8] zeroinitializer, i8 1, [3 x i8] zeroinitializer }, align 4
// PATTERN-O1-NOT: @__const.test_bitfieldaligned_uninit.uninit
// PATTERN-O1-NOT: @__const.test_bitfieldaligned_custom.custom
// ZERO-O1-NOT: @__const.test_bitfieldaligned_custom.custom
struct bitfieldaligned { int i : 4; int : 0; int j : 2; }; struct bitfieldaligned { int i : 4; int : 0; int j : 2; };
struct big { unsigned a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z; }; struct big { unsigned a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z; };
// PATTERN-O0: @__const.test_arraytail_uninit.uninit = private unnamed_addr constant %struct.arraytail { i32 -1431655766, [0 x i32] zeroinitializer }, align 4
// PATTERN-O0: @__const.test_arraytail_custom.custom = private unnamed_addr constant %struct.arraytail { i32 57005, [0 x i32] zeroinitializer }, align 4 // PATTERN-O0: @__const.test_arraytail_custom.custom = private unnamed_addr constant %struct.arraytail { i32 57005, [0 x i32] zeroinitializer }, align 4
// ZERO-O0: @__const.test_arraytail_custom.custom = private unnamed_addr constant %struct.arraytail { i32 57005, [0 x i32] zeroinitializer }, align 4 // ZERO-O0: @__const.test_arraytail_custom.custom = private unnamed_addr constant %struct.arraytail { i32 57005, [0 x i32] zeroinitializer }, align 4
// PATTERN-O1-NOT: @__const.test_arraytail_uninit.uninit
// PATTERN-O1-NOT: @__const.test_arraytail_custom.custom
// ZERO-O1-NOT: @__const.test_arraytail_custom.custom
struct arraytail { int i; int arr[]; }; struct arraytail { int i; int arr[]; };
// PATTERN-O0: @__const.test_int1_uninit.uninit = private unnamed_addr constant [1 x i32] [i32 -1431655766], align 4
// PATTERN-O0: @__const.test_int1_custom.custom = private unnamed_addr constant [1 x i32] [i32 858993459], align 4
// ZERO-O0: @__const.test_int1_custom.custom = private unnamed_addr constant [1 x i32] [i32 858993459], align 4
// PATTERN-O1-NOT: @__const.test_int1_uninit.uninit
// PATTERN-O1-NOT: @__const.test_int1_custom.custom
// ZERO-O1-NOT: @__const.test_int1_custom.custom
// PATTERN-O0: @__const.test_bool4_uninit.uninit = private unnamed_addr constant [4 x i8] c"\AA\AA\AA\AA", align 1
// PATTERN-O0: @__const.test_bool4_custom.custom = private unnamed_addr constant [4 x i8] c"\01\01\01\01", align 1
// ZERO-O0: @__const.test_bool4_custom.custom = private unnamed_addr constant [4 x i8] c"\01\01\01\01", align 1
// PATTERN-O1-NOT: @__const.test_bool4_uninit.uninit
// PATTERN-O1-NOT: @__const.test_bool4_custom.custom
// ZERO-O1-NOT: @__const.test_bool4_custom.custom
// PATTERN: @__const.test_intptr4_custom.custom = private unnamed_addr constant [4 x i32*] [i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*)], align 16 // PATTERN: @__const.test_intptr4_custom.custom = private unnamed_addr constant [4 x i32*] [i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*)], align 16
// ZERO: @__const.test_intptr4_custom.custom = private unnamed_addr constant [4 x i32*] [i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*)], align 16 // ZERO: @__const.test_intptr4_custom.custom = private unnamed_addr constant [4 x i32*] [i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*), i32* inttoptr (i64 572662306 to i32*)], align 16
// PATTERN-O0: @__const.test_tailpad4_uninit.uninit = private unnamed_addr constant [4 x { i16, i8, [1 x i8] }] [{ i16, i8, [1 x i8] } { i16 -21846, i8 -86, [1 x i8] c"\AA" }, { i16, i8, [1 x i8] } { i16 -21846, i8 -86, [1 x i8] c"\AA" }, { i16, i8, [1 x i8] } { i16 -21846, i8 -86, [1 x i8] c"\AA" }, { i16, i8, [1 x i8] } { i16 -21846, i8 -86, [1 x i8] c"\AA" }], align 16
// PATTERN-O1-NOT: @__const.test_tailpad4_uninit.uninit
// PATTERN: @__const.test_tailpad4_custom.custom = private unnamed_addr constant [4 x { i16, i8, [1 x i8] }] [{ i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }], align 16 // PATTERN: @__const.test_tailpad4_custom.custom = private unnamed_addr constant [4 x { i16, i8, [1 x i8] }] [{ i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }], align 16
// ZERO: @__const.test_tailpad4_custom.custom = private unnamed_addr constant [4 x { i16, i8, [1 x i8] }] [{ i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }], align 16 // ZERO: @__const.test_tailpad4_custom.custom = private unnamed_addr constant [4 x { i16, i8, [1 x i8] }] [{ i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }, { i16, i8, [1 x i8] } { i16 257, i8 1, [1 x i8] zeroinitializer }], align 16
struct tailpad { short s; char c; }; struct tailpad { short s; char c; };
// PATTERN-O0: @__const.test_atomicnotlockfree_uninit.uninit = private unnamed_addr constant %struct.notlockfree { [4 x i64] [i64 -6148914691236517206, i64 -6148914691236517206, i64 -6148914691236517206, i64 -6148914691236517206] }, align 8
// PATTERN-O1-NOT: @__const.test_atomicnotlockfree_uninit.uninit
struct notlockfree { long long a[4]; }; struct notlockfree { long long a[4]; };
// PATTERN-O0: @__const.test_atomicpadded_uninit.uninit = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 -86, [3 x i8] c"\AA\AA\AA", i32 -1431655766 }, align 8
// PATTERN-O1-NOT: @__const.test_atomicpadded_uninit.uninit
// PATTERN-O0: @__const.test_atomictailpad_uninit.uninit = private unnamed_addr constant { i16, i8, [1 x i8] } { i16 -21846, i8 -86, [1 x i8] c"\AA" }, align 4
// PATTERN-O1-NOT: @__const.test_atomictailpad_uninit.uninit
// PATTERN-O0: @__const.test_complexfloat_uninit.uninit = private unnamed_addr constant { float, float } { float 0xFFFFFFFFE0000000, float 0xFFFFFFFFE0000000 }, align 4
// PATTERN-O1-NOT: @__const.test_complexfloat_uninit.uninit
// PATTERN-O0: @__const.test_complexfloat_braces.braces = private unnamed_addr constant { float, float } { float 0xFFFFFFFFE0000000, float 0xFFFFFFFFE0000000 }, align 4
// PATTERN-O1-NOT: @__const.test_complexfloat_braces.braces
// PATTERN-O0: @__const.test_complexfloat_custom.custom = private unnamed_addr constant { float, float } { float 0xFFFFFFFFE0000000, float 0xFFFFFFFFE0000000 }, align 4
// PATTERN-O1-NOT: @__const.test_complexfloat_custom.custom
// PATTERN-O0: @__const.test_complexdouble_uninit.uninit = private unnamed_addr constant { double, double } { double 0xFFFFFFFFFFFFFFFF, double 0xFFFFFFFFFFFFFFFF }, align 8
// PATTERN-O1-NOT: @__const.test_complexdouble_uninit.uninit
// PATTERN-O0: @__const.test_complexdouble_braces.braces = private unnamed_addr constant { double, double } { double 0xFFFFFFFFFFFFFFFF, double 0xFFFFFFFFFFFFFFFF }, align 8
// PATTERN-O1-NOT: @__const.test_complexdouble_braces.braces
// PATTERN-O0: @__const.test_complexdouble_custom.custom = private unnamed_addr constant { double, double } { double 0xFFFFFFFFFFFFFFFF, double 0xFFFFFFFFFFFFFFFF }, align 8
// PATTERN-O1-NOT: @__const.test_complexdouble_custom.custom
// PATTERN-O0: @__const.test_semivolatile_uninit.uninit = private unnamed_addr constant %struct.semivolatile { i32 -1431655766, i32 -1431655766 }, align 4
// PATTERN-O0: @__const.test_semivolatile_custom.custom = private unnamed_addr constant %struct.semivolatile { i32 1145324612, i32 1145324612 }, align 4
// PATTERN-O1-NOT: @__const.test_semivolatile_custom.custom
struct semivolatile { int i; volatile int vi; }; struct semivolatile { int i; volatile int vi; };
// PATTERN-O0: @__const.test_semivolatileinit_uninit.uninit = private unnamed_addr constant %struct.semivolatileinit { i32 -1431655766, i32 -1431655766 }, align 4
// PATTERN-O1-NOT: @__const.test_semivolatileinit_uninit.uninit
// PATTERN-O0: @__const.test_semivolatileinit_braces.braces = private unnamed_addr constant %struct.semivolatileinit { i32 -1431655766, i32 -1431655766 }, align 4
// PATTERN-O1-NOT: @__const.test_semivolatileinit_braces.braces
// PATTERN-O0: @__const.test_semivolatileinit_custom.custom = private unnamed_addr constant %struct.semivolatileinit { i32 -1431655766, i32 -1431655766 }, align 4
// PATTERN-O1-NOT: @__const.test_semivolatileinit_custom.custom = private unnamed_addr constant %struct.semivolatileinit { i32 -1431655766, i32 -1431655766 }, align 4
// ZERO-O0: @__const.test_semivolatile_custom.custom = private unnamed_addr constant %struct.semivolatile { i32 1145324612, i32 1145324612 }, align 4
// ZERO-O1-NOT: @__const.test_semivolatile_custom.custom
struct semivolatileinit { int i = 0x11111111; volatile int vi = 0x11111111; }; struct semivolatileinit { int i = 0x11111111; volatile int vi = 0x11111111; };
// PATTERN-O0: @__const.test_base_uninit.uninit = private unnamed_addr constant %struct.base { i32 (...)** inttoptr (i64 -6148914691236517206 to i32 (...)**) }, align 8
// PATTERN-O1-NOT: @__const.test_base_uninit.uninit
// PATTERN-O0: @__const.test_base_braces.braces = private unnamed_addr constant %struct.base { i32 (...)** inttoptr (i64 -6148914691236517206 to i32 (...)**) }, align 8
// PATTERN-O1-NOT: @__const.test_base_braces.braces
struct base { virtual ~base(); }; struct base { virtual ~base(); };
// PATTERN-O0: @__const.test_derived_uninit.uninit = private unnamed_addr constant %struct.derived { %struct.base { i32 (...)** inttoptr (i64 -6148914691236517206 to i32 (...)**) } }, align 8
// PATTERN-O1-NOT: @__const.test_derived_uninit.uninit
// PATTERN-O0: @__const.test_derived_braces.braces = private unnamed_addr constant %struct.derived { %struct.base { i32 (...)** inttoptr (i64 -6148914691236517206 to i32 (...)**) } }, align 8
// PATTERN-O1-NOT: @__const.test_derived_braces.braces
struct derived : public base {}; struct derived : public base {};
// PATTERN-O0: @__const.test_virtualderived_uninit.uninit = private unnamed_addr constant %struct.virtualderived { %struct.base { i32 (...)** inttoptr (i64 -6148914691236517206 to i32 (...)**) }, %struct.derived { %struct.base { i32 (...)** inttoptr (i64 -6148914691236517206 to i32 (...)**) } } }, align 8
// PATTERN-O1-NOT: @__const.test_virtualderived_uninit.uninit
// PATTERN-O0: @__const.test_virtualderived_braces.braces = private unnamed_addr constant %struct.virtualderived { %struct.base { i32 (...)** inttoptr (i64 -6148914691236517206 to i32 (...)**) }, %struct.derived { %struct.base { i32 (...)** inttoptr (i64 -6148914691236517206 to i32 (...)**) } } }, align 8
// PATTERN-O1-NOT: @__const.test_virtualderived_braces.braces
struct virtualderived : public virtual base, public virtual derived {}; struct virtualderived : public virtual base, public virtual derived {};
// PATTERN-O0: @__const.test_matching_uninit.uninit = private unnamed_addr constant %union.matching { i32 -1431655766 }, align 4
// PATTERN-O1-NOT: @__const.test_matching_uninit.uninit
// PATTERN-O0: @__const.test_matching_custom.custom = private unnamed_addr constant { float } { float 6.145500e+04 }, align 4 // PATTERN-O0: @__const.test_matching_custom.custom = private unnamed_addr constant { float } { float 6.145500e+04 }, align 4
// PATTERN-O1-NOT: @__const.test_matching_custom.custom
// ZERO-O0: @__const.test_matching_custom.custom = private unnamed_addr constant { float } { float 6.145500e+04 }, align 4 // ZERO-O0: @__const.test_matching_custom.custom = private unnamed_addr constant { float } { float 6.145500e+04 }, align 4
// ZERO-O1-NOT: @__const.test_matching_custom.custom
union matching { int i; float f; }; union matching { int i; float f; };
// PATTERN-O0: @__const.test_matchingreverse_uninit.uninit = private unnamed_addr constant %union.matchingreverse { float 0xFFFFFFFFE0000000 }, align 4
// PATTERN-O1-NOT: @__const.test_matchingreverse_uninit.uninit
// PATTERN-O0: @__const.test_matchingreverse_custom.custom = private unnamed_addr constant { i32 } { i32 61455 }, align 4 // PATTERN-O0: @__const.test_matchingreverse_custom.custom = private unnamed_addr constant { i32 } { i32 61455 }, align 4
// PATTERN-O1-NOT: @__const.test_matchingreverse_custom.custom
// ZERO-O0: @__const.test_matchingreverse_custom.custom = private unnamed_addr constant { i32 } { i32 61455 }, align 4 // ZERO-O0: @__const.test_matchingreverse_custom.custom = private unnamed_addr constant { i32 } { i32 61455 }, align 4
// ZERO-O1-NOT: @__const.test_matchingreverse_custom.custom
union matchingreverse { float f; int i; }; union matchingreverse { float f; int i; };
// PATTERN-O0: @__const.test_unmatched_uninit.uninit = private unnamed_addr constant %union.unmatched { i32 -1431655766 }, align 4
// PATTERN-O1-NOT: @__const.test_unmatched_uninit.uninit
// PATTERN-O0: @__const.test_unmatched_custom.custom = private unnamed_addr constant %union.unmatched { i32 1001242351 }, align 4 // PATTERN-O0: @__const.test_unmatched_custom.custom = private unnamed_addr constant %union.unmatched { i32 1001242351 }, align 4
// PATTERN-O1-NOT: @__const.test_unmatched_custom.custom
// ZERO-O0: @__const.test_unmatched_custom.custom = private unnamed_addr constant %union.unmatched { i32 1001242351 }, align 4 // ZERO-O0: @__const.test_unmatched_custom.custom = private unnamed_addr constant %union.unmatched { i32 1001242351 }, align 4
// ZERO-O1-NOT: @__const.test_unmatched_custom.custom
union unmatched { char c; int i; }; union unmatched { char c; int i; };
// PATTERN-O0: @__const.test_unmatchedreverse_uninit.uninit = private unnamed_addr constant %union.unmatchedreverse { i32 -1431655766 }, align 4
// PATTERN-O1-NOT: @__const.test_unmatchedreverse_uninit.uninit
// PATTERN-O0: @__const.test_unmatchedreverse_custom.custom = private unnamed_addr constant { i8, [3 x i8] } { i8 42, [3 x i8] c"\AA\AA\AA" }, align 4 // PATTERN-O0: @__const.test_unmatchedreverse_custom.custom = private unnamed_addr constant { i8, [3 x i8] } { i8 42, [3 x i8] c"\AA\AA\AA" }, align 4
// PATTERN-O1-NOT: @__const.test_unmatchedreverse_custom.custom
// ZERO-O0: @__const.test_unmatchedreverse_custom.custom = private unnamed_addr constant { i8, [3 x i8] } { i8 42, [3 x i8] zeroinitializer }, align 4 // ZERO-O0: @__const.test_unmatchedreverse_custom.custom = private unnamed_addr constant { i8, [3 x i8] } { i8 42, [3 x i8] zeroinitializer }, align 4
// ZERO-O1-NOT: @__const.test_unmatchedreverse_custom.custom
union unmatchedreverse { int i; char c; }; union unmatchedreverse { int i; char c; };
// PATTERN-O0: @__const.test_unmatchedfp_uninit.uninit = private unnamed_addr constant %union.unmatchedfp { double 0xFFFFFFFFFFFFFFFF }, align 8
// PATTERN-O1-NOT: @__const.test_unmatchedfp_uninit.uninit
// PATTERN-O0: @__const.test_unmatchedfp_custom.custom = private unnamed_addr constant %union.unmatchedfp { double 0x400921FB54442D18 }, align 8 // PATTERN-O0: @__const.test_unmatchedfp_custom.custom = private unnamed_addr constant %union.unmatchedfp { double 0x400921FB54442D18 }, align 8
// PATTERN-O1-NOT: @__const.test_unmatchedfp_custom.custom
// ZERO-O0: @__const.test_unmatchedfp_custom.custom = private unnamed_addr constant %union.unmatchedfp { double 0x400921FB54442D18 }, align 8 // ZERO-O0: @__const.test_unmatchedfp_custom.custom = private unnamed_addr constant %union.unmatchedfp { double 0x400921FB54442D18 }, align 8
// ZERO-O1-NOT: @__const.test_unmatchedfp_custom.custom
union unmatchedfp { float f; double d; }; union unmatchedfp { float f; double d; };
enum emptyenum {}; enum emptyenum {};
enum smallenum { VALUE }; enum smallenum { VALUE };
extern "C" { extern "C" {
TEST_UNINIT(char, char); TEST_UNINIT(char, char);
// CHECK-LABEL: @test_char_uninit() // CHECK-LABEL: @test_char_uninit()
▲ Show 20 Lines • Show All 328 Lines • ▼ Show 20 Lines
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_UNINIT(empty, empty); TEST_UNINIT(empty, empty);
// CHECK-LABEL: @test_empty_uninit() // CHECK-LABEL: @test_empty_uninit()
// CHECK: %uninit = alloca %struct.empty, align // CHECK: %uninit = alloca %struct.empty, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_empty_uninit() // PATTERN-LABEL: @test_empty_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_empty_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 1, i1 false)
// PATTERN-O1: store i8 -86, {{.*}} align 1 // PATTERN-O1: store i8 -86, {{.*}} align 1
// ZERO-LABEL: @test_empty_uninit() // ZERO-LABEL: @test_empty_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i8 0, {{.*}} align 1 // ZERO-O1: store i8 0, {{.*}} align 1
TEST_BRACES(empty, empty); TEST_BRACES(empty, empty);
// CHECK-LABEL: @test_empty_braces() // CHECK-LABEL: @test_empty_braces()
// CHECK: %braces = alloca %struct.empty, align // CHECK: %braces = alloca %struct.empty, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK1-NEXT: call void @llvm.memcpy
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_UNINIT(small, small); TEST_UNINIT(small, small);
// CHECK-LABEL: @test_small_uninit() // CHECK-LABEL: @test_small_uninit()
// CHECK: %uninit = alloca %struct.small, align // CHECK: %uninit = alloca %struct.small, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_small_uninit() // PATTERN-LABEL: @test_small_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_small_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 1, i1 false)
// PATTERN-O1: store i8 -86, {{.*}} align 1 // PATTERN-O1: store i8 -86, {{.*}} align 1
// ZERO-LABEL: @test_small_uninit() // ZERO-LABEL: @test_small_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i8 0, {{.*}} align 1 // ZERO-O1: store i8 0, {{.*}} align 1
TEST_BRACES(small, small); TEST_BRACES(small, small);
// CHECK-LABEL: @test_small_braces() // CHECK-LABEL: @test_small_braces()
// CHECK: %braces = alloca %struct.small, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.small, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 1, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 1, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(small, small, { 42 }); TEST_CUSTOM(small, small, { 42 });
// CHECK-LABEL: @test_small_custom() // CHECK-LABEL: @test_small_custom()
// CHECK: %custom = alloca %struct.small, align // CHECK: %custom = alloca %struct.small, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memset
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(smallinit, smallinit); TEST_UNINIT(smallinit, smallinit);
// CHECK-LABEL: @test_smallinit_uninit() // CHECK-LABEL: @test_smallinit_uninit()
// CHECK: %uninit = alloca %struct.smallinit, align // CHECK: %uninit = alloca %struct.smallinit, align
// CHECK-NEXT: call void @{{.*}}smallinit{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}smallinit{{.*}}%uninit)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
Show All 12 Lines
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(smallpartinit, smallpartinit); TEST_UNINIT(smallpartinit, smallpartinit);
// CHECK-LABEL: @test_smallpartinit_uninit() // CHECK-LABEL: @test_smallpartinit_uninit()
// CHECK: %uninit = alloca %struct.smallpartinit, align // CHECK: %uninit = alloca %struct.smallpartinit, align
// CHECK-NEXT: call void @{{.*}}smallpartinit{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}smallpartinit{{.*}}%uninit)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_smallpartinit_uninit() // PATTERN-LABEL: @test_smallpartinit_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_smallpartinit_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 2, i1 false)
// PATTERN-O1: store i8 -86, {{.*}} align 1 // PATTERN-O1-LEGACY: store i16 -21846, {{.*}} align 2
// PATTERN-O1: store i8 42, {{.*}} align 1 // PATTERN-O1-LEGACY: call void @_ZN13smallpartinitC1Ev
// PATTERN-O1-NEWPM: store i16 -21974, {{.*}} align 2
// ZERO-LABEL: @test_smallpartinit_uninit() // ZERO-LABEL: @test_smallpartinit_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1-LEGACY: store i16 0, i16* %uninit, align 2 // ZERO-O1-LEGACY: store i16 0, i16* %uninit, align 2
// ZERO-O1-NEWPM: store i16 42, i16* %uninit, align 2 // ZERO-O1-NEWPM: store i16 42, i16* %uninit, align 2
TEST_BRACES(smallpartinit, smallpartinit); TEST_BRACES(smallpartinit, smallpartinit);
// CHECK-LABEL: @test_smallpartinit_braces() // CHECK-LABEL: @test_smallpartinit_braces()
// CHECK: %braces = alloca %struct.smallpartinit, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.smallpartinit, align [[ALIGN:[0-9]*]]
Show All 32 Lines
// CHECK-NEXT: store i8* getelementptr inbounds {{.*}}, i8** %[[N]], align [[ALIGN]] // CHECK-NEXT: store i8* getelementptr inbounds {{.*}}, i8** %[[N]], align [[ALIGN]]
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(padded, padded); TEST_UNINIT(padded, padded);
// CHECK-LABEL: @test_padded_uninit() // CHECK-LABEL: @test_padded_uninit()
// CHECK: %uninit = alloca %struct.padded, align // CHECK: %uninit = alloca %struct.padded, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_padded_uninit() // PATTERN-LABEL: @test_padded_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_padded_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 8, i1 false)
// PATTERN-O1: store i64 -6148914691236517206, i64* %uninit, align 8 // PATTERN-O1: store i64 -6148914691236517206, i64* %uninit, align 8
// ZERO-LABEL: @test_padded_uninit() // ZERO-LABEL: @test_padded_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i64 0, i64* %uninit, align 8 // ZERO-O1: store i64 0, i64* %uninit, align 8
TEST_BRACES(padded, padded); TEST_BRACES(padded, padded);
// CHECK-LABEL: @test_padded_braces() // CHECK-LABEL: @test_padded_braces()
// CHECK: %braces = alloca %struct.padded, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.padded, align [[ALIGN:[0-9]*]]
Show All 9 Lines
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(paddednullinit, paddednullinit); TEST_UNINIT(paddednullinit, paddednullinit);
// CHECK-LABEL: @test_paddednullinit_uninit() // CHECK-LABEL: @test_paddednullinit_uninit()
// CHECK: %uninit = alloca %struct.paddednullinit, align // CHECK: %uninit = alloca %struct.paddednullinit, align
// CHECK-NEXT: call void @{{.*}}paddednullinit{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}paddednullinit{{.*}}%uninit)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_paddednullinit_uninit() // PATTERN-LABEL: @test_paddednullinit_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_paddednullinit_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 8, i1 false)
// PATTERN-O1-LEGACY: store i64 -6148914691236517206, i64* %uninit, align 8 // PATTERN-O1-LEGACY: store i64 -6148914691236517206, i64* %uninit, align 8
// PATTERN-O1-NEWPM: store i64 2863311360, i64* %uninit, align 8 // PATTERN-O1-NEWPM: store i64 2863311360, i64* %uninit, align 8
// ZERO-LABEL: @test_paddednullinit_uninit() // ZERO-LABEL: @test_paddednullinit_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i64 0, i64* %uninit, align 8 // ZERO-O1: store i64 0, i64* %uninit, align 8
TEST_BRACES(paddednullinit, paddednullinit); TEST_BRACES(paddednullinit, paddednullinit);
// CHECK-LABEL: @test_paddednullinit_braces() // CHECK-LABEL: @test_paddednullinit_braces()
Show All 13 Lines
// CHECK-NEXT: store i32 13371337, i32* %[[I]], align [[ALIGN]] // CHECK-NEXT: store i32 13371337, i32* %[[I]], align [[ALIGN]]
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(paddedpacked, paddedpacked); TEST_UNINIT(paddedpacked, paddedpacked);
// CHECK-LABEL: @test_paddedpacked_uninit() // CHECK-LABEL: @test_paddedpacked_uninit()
// CHECK: %uninit = alloca %struct.paddedpacked, align // CHECK: %uninit = alloca %struct.paddedpacked, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_paddedpacked_uninit() // PATTERN-LABEL: @test_paddedpacked_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_paddedpacked_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 5, i1 false)
// PATTERN-O1: %[[C:[^ ]*]] = getelementptr inbounds {{.*}}%uninit, i64 0, i32 0 // PATTERN-O1: call void @llvm.memset{{.*}}, i8 -86, i64 5, i1 false)
// PATTERN-O1 store i8 -86, i8* %[[C]], align
// PATTERN-O1: %[[I:[^ ]*]] = getelementptr inbounds {{.*}}%uninit, i64 0, i32 1
// PATTERN-O1: store i32 -1431655766, i32* %[[I]], align
// ZERO-LABEL: @test_paddedpacked_uninit() // ZERO-LABEL: @test_paddedpacked_uninit()
// ZERO: call void @llvm.memset{{.*}}, i8 0, // ZERO: call void @llvm.memset{{.*}}, i8 0,
TEST_BRACES(paddedpacked, paddedpacked); TEST_BRACES(paddedpacked, paddedpacked);
// CHECK-LABEL: @test_paddedpacked_braces() // CHECK-LABEL: @test_paddedpacked_braces()
// CHECK: %braces = alloca %struct.paddedpacked, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.paddedpacked, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 5, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 5, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(paddedpacked, paddedpacked, { 42, 13371337 }); TEST_CUSTOM(paddedpacked, paddedpacked, { 42, 13371337 });
// CHECK-LABEL: @test_paddedpacked_custom() // CHECK-LABEL: @test_paddedpacked_custom()
// CHECK: %custom = alloca %struct.paddedpacked, align // CHECK: %custom = alloca %struct.paddedpacked, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddedpacked_custom.custom // CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddedpacked_custom.custom
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(paddedpackedarray, paddedpackedarray); TEST_UNINIT(paddedpackedarray, paddedpackedarray);
// CHECK-LABEL: @test_paddedpackedarray_uninit() // CHECK-LABEL: @test_paddedpackedarray_uninit()
// CHECK: %uninit = alloca %struct.paddedpackedarray, align // CHECK: %uninit = alloca %struct.paddedpackedarray, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_paddedpackedarray_uninit() // PATTERN-LABEL: @test_paddedpackedarray_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_paddedpackedarray_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 10, i1 false)
// PATTERN-O1: getelementptr // PATTERN-O1: getelementptr
// PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}i8 -86, i64 10 // PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}i8 -86, i64 10
// ZERO-LABEL: @test_paddedpackedarray_uninit() // ZERO-LABEL: @test_paddedpackedarray_uninit()
// ZERO: call void @llvm.memset{{.*}}, i8 0, // ZERO: call void @llvm.memset{{.*}}, i8 0,
TEST_BRACES(paddedpackedarray, paddedpackedarray); TEST_BRACES(paddedpackedarray, paddedpackedarray);
// CHECK-LABEL: @test_paddedpackedarray_braces() // CHECK-LABEL: @test_paddedpackedarray_braces()
// CHECK: %braces = alloca %struct.paddedpackedarray, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.paddedpackedarray, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 10, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 10, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(paddedpackedarray, paddedpackedarray, { {{ 42, 13371337 }, { 43, 13371338 }} }); TEST_CUSTOM(paddedpackedarray, paddedpackedarray, { {{ 42, 13371337 }, { 43, 13371338 }} });
// CHECK-LABEL: @test_paddedpackedarray_custom() // CHECK-LABEL: @test_paddedpackedarray_custom()
// CHECK: %custom = alloca %struct.paddedpackedarray, align // CHECK: %custom = alloca %struct.paddedpackedarray, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddedpackedarray_custom.custom // CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddedpackedarray_custom.custom
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(unpackedinpacked, unpackedinpacked); TEST_UNINIT(unpackedinpacked, unpackedinpacked);
// CHECK-LABEL: @test_unpackedinpacked_uninit() // CHECK-LABEL: @test_unpackedinpacked_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}}, i64 9, i1 false) // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 9, i1 false)
TEST_UNINIT(paddednested, paddednested); TEST_UNINIT(paddednested, paddednested);
// CHECK-LABEL: @test_paddednested_uninit() // CHECK-LABEL: @test_paddednested_uninit()
// CHECK: %uninit = alloca %struct.paddednested, align // CHECK: %uninit = alloca %struct.paddednested, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_paddednested_uninit() // PATTERN-LABEL: @test_paddednested_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_paddednested_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 16, i1 false)
// PATTERN-O1: getelementptr // PATTERN-O1: getelementptr
// PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}, i8 -86, i64 16 // PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}, i8 -86, i64 16
// ZERO-LABEL: @test_paddednested_uninit() // ZERO-LABEL: @test_paddednested_uninit()
// ZERO: call void @llvm.memset{{.*}}, i8 0, // ZERO: call void @llvm.memset{{.*}}, i8 0,
TEST_BRACES(paddednested, paddednested); TEST_BRACES(paddednested, paddednested);
// CHECK-LABEL: @test_paddednested_braces() // CHECK-LABEL: @test_paddednested_braces()
// CHECK: %braces = alloca %struct.paddednested, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.paddednested, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 16, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 16, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(paddednested, paddednested, { { 42, 13371337 }, { 43, 13371338 } }); TEST_CUSTOM(paddednested, paddednested, { { 42, 13371337 }, { 43, 13371338 } });
// CHECK-LABEL: @test_paddednested_custom() // CHECK-LABEL: @test_paddednested_custom()
// CHECK: %custom = alloca %struct.paddednested, align // CHECK: %custom = alloca %struct.paddednested, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddednested_custom.custom // CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddednested_custom.custom
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(paddedpackednested, paddedpackednested); TEST_UNINIT(paddedpackednested, paddedpackednested);
// CHECK-LABEL: @test_paddedpackednested_uninit() // CHECK-LABEL: @test_paddedpackednested_uninit()
// CHECK: %uninit = alloca %struct.paddedpackednested, align // CHECK: %uninit = alloca %struct.paddedpackednested, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_paddedpackednested_uninit() // PATTERN-LABEL: @test_paddedpackednested_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_paddedpackednested_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 10, i1 false)
// PATTERN-O1: getelementptr // PATTERN-O1: getelementptr
// PATTERN-O1: call void @llvm.memset.p0i8.i64(i8* nonnull align 1 %0, i8 -86, i64 10, i1 false // PATTERN-O1: call void @llvm.memset.p0i8.i64(i8* nonnull align 1 %0, i8 -86, i64 10, i1 false
// ZERO-LABEL: @test_paddedpackednested_uninit() // ZERO-LABEL: @test_paddedpackednested_uninit()
// ZERO: call void @llvm.memset{{.*}}, i8 0, // ZERO: call void @llvm.memset{{.*}}, i8 0,
TEST_BRACES(paddedpackednested, paddedpackednested); TEST_BRACES(paddedpackednested, paddedpackednested);
// CHECK-LABEL: @test_paddedpackednested_braces() // CHECK-LABEL: @test_paddedpackednested_braces()
// CHECK: %braces = alloca %struct.paddedpackednested, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.paddedpackednested, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 10, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 10, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(paddedpackednested, paddedpackednested, { { 42, 13371337 }, { 43, 13371338 } }); TEST_CUSTOM(paddedpackednested, paddedpackednested, { { 42, 13371337 }, { 43, 13371338 } });
// CHECK-LABEL: @test_paddedpackednested_custom() // CHECK-LABEL: @test_paddedpackednested_custom()
// CHECK: %custom = alloca %struct.paddedpackednested, align // CHECK: %custom = alloca %struct.paddedpackednested, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddedpackednested_custom.custom // CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddedpackednested_custom.custom
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(bitfield, bitfield); TEST_UNINIT(bitfield, bitfield);
// CHECK-LABEL: @test_bitfield_uninit() // CHECK-LABEL: @test_bitfield_uninit()
// CHECK: %uninit = alloca %struct.bitfield, align // CHECK: %uninit = alloca %struct.bitfield, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_bitfield_uninit() // PATTERN-LABEL: @test_bitfield_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_bitfield_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 4, i1 false)
// PATTERN-O1: store i32 -1431655766, i32* %uninit, align 4 // PATTERN-O1: store i32 -1431655766, i32* %uninit, align 4
// ZERO-LABEL: @test_bitfield_uninit() // ZERO-LABEL: @test_bitfield_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i32 0, i32* %uninit, align 4 // ZERO-O1: store i32 0, i32* %uninit, align 4
TEST_BRACES(bitfield, bitfield); TEST_BRACES(bitfield, bitfield);
// CHECK-LABEL: @test_bitfield_braces() // CHECK-LABEL: @test_bitfield_braces()
// CHECK: %braces = alloca %struct.bitfield, align // CHECK: %braces = alloca %struct.bitfield, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memset
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(bitfield, bitfield, { 4, 1 }); TEST_CUSTOM(bitfield, bitfield, { 4, 1 });
// CHECK-LABEL: @test_bitfield_custom() // CHECK-LABEL: @test_bitfield_custom()
// CHECK: %custom = alloca %struct.bitfield, align // CHECK: %custom = alloca %struct.bitfield, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memset
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(bitfieldaligned, bitfieldaligned); TEST_UNINIT(bitfieldaligned, bitfieldaligned);
// CHECK-LABEL: @test_bitfieldaligned_uninit() // CHECK-LABEL: @test_bitfieldaligned_uninit()
// CHECK: %uninit = alloca %struct.bitfieldaligned, align // CHECK: %uninit = alloca %struct.bitfieldaligned, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_bitfieldaligned_uninit() // PATTERN-LABEL: @test_bitfieldaligned_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_bitfieldaligned_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 8, i1 false)
// PATTERN-O1: store i64 -6148914691236517206, i64* %uninit, align 8 // PATTERN-O1: store i64 -6148914691236517206, i64* %uninit, align 8
// ZERO-LABEL: @test_bitfieldaligned_uninit() // ZERO-LABEL: @test_bitfieldaligned_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i64 0, i64* %uninit, align 8 // ZERO-O1: store i64 0, i64* %uninit, align 8
TEST_BRACES(bitfieldaligned, bitfieldaligned); TEST_BRACES(bitfieldaligned, bitfieldaligned);
// CHECK-LABEL: @test_bitfieldaligned_braces() // CHECK-LABEL: @test_bitfieldaligned_braces()
// CHECK: %braces = alloca %struct.bitfieldaligned, align // CHECK: %braces = alloca %struct.bitfieldaligned, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memset
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(bitfieldaligned, bitfieldaligned, { 4, 1 }); TEST_CUSTOM(bitfieldaligned, bitfieldaligned, { 4, 1 });
// CHECK-LABEL: @test_bitfieldaligned_custom() // CHECK-LABEL: @test_bitfieldaligned_custom()
// CHECK: %custom = alloca %struct.bitfieldaligned, align // CHECK: %custom = alloca %struct.bitfieldaligned, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memcpy
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
Show All 21 Lines
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 -86, i64 104, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 -86, i64 104, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(arraytail, arraytail); TEST_UNINIT(arraytail, arraytail);
// CHECK-LABEL: @test_arraytail_uninit() // CHECK-LABEL: @test_arraytail_uninit()
// CHECK: %uninit = alloca %struct.arraytail, align // CHECK: %uninit = alloca %struct.arraytail, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_arraytail_uninit() // PATTERN-LABEL: @test_arraytail_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_arraytail_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 4, i1 false)
// PATTERN-O1: store i32 -1431655766, {{.*}} align 4 // PATTERN-O1: store i32 -1431655766, {{.*}} align 4
// ZERO-LABEL: @test_arraytail_uninit() // ZERO-LABEL: @test_arraytail_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i32 0, {{.*}} align 4 // ZERO-O1: store i32 0, {{.*}} align 4
TEST_BRACES(arraytail, arraytail); TEST_BRACES(arraytail, arraytail);
// CHECK-LABEL: @test_arraytail_braces() // CHECK-LABEL: @test_arraytail_braces()
// CHECK: %braces = alloca %struct.arraytail, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.arraytail, align [[ALIGN:[0-9]*]]
Show All 26 Lines
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_UNINIT(int1, int[1]); TEST_UNINIT(int1, int[1]);
// CHECK-LABEL: @test_int1_uninit() // CHECK-LABEL: @test_int1_uninit()
// CHECK: %uninit = alloca [1 x i32], align [[ALIGN:[0-9]*]] // CHECK: %uninit = alloca [1 x i32], align [[ALIGN:[0-9]*]]
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_int1_uninit() // PATTERN-LABEL: @test_int1_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_int1_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 4, i1 false)
// PATTERN-O1: store i32 -1431655766, {{.*}} align 4 // PATTERN-O1: store i32 -1431655766, {{.*}} align 4
// ZERO-LABEL: @test_int1_uninit() // ZERO-LABEL: @test_int1_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i32 0, {{.*}} align 4 // ZERO-O1: store i32 0, {{.*}} align 4
TEST_BRACES(int1, int[1]); TEST_BRACES(int1, int[1]);
// CHECK-LABEL: @test_int1_braces() // CHECK-LABEL: @test_int1_braces()
// CHECK: %braces = alloca [1 x i32], align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca [1 x i32], align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(int1, int[1], { 0x33333333 }); TEST_CUSTOM(int1, int[1], { 0x33333333 });
// CHECK-LABEL: @test_int1_custom() // CHECK-LABEL: @test_int1_custom()
// CHECK: %custom = alloca [1 x i32], align // CHECK: %custom = alloca [1 x i32], align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memset
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(int64, int[64]); TEST_UNINIT(int64, int[64]);
// CHECK-LABEL: @test_int64_uninit() // CHECK-LABEL: @test_int64_uninit()
// CHECK: %uninit = alloca [64 x i32], align // CHECK: %uninit = alloca [64 x i32], align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_int64_uninit() // PATTERN-LABEL: @test_int64_uninit()
// PATTERN: call void @llvm.memset{{.*}}, i8 -86, // PATTERN: call void @llvm.memset{{.*}}, i8 -86,
Show All 14 Lines
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 17, i64 256, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 17, i64 256, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(bool4, bool[4]); TEST_UNINIT(bool4, bool[4]);
// CHECK-LABEL: @test_bool4_uninit() // CHECK-LABEL: @test_bool4_uninit()
// CHECK: %uninit = alloca [4 x i8], align // CHECK: %uninit = alloca [4 x i8], align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_bool4_uninit() // PATTERN-LABEL: @test_bool4_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_bool4_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 4, i1 false)
// PATTERN-O1: store i32 -1431655766, i32* %uninit, align 4 // PATTERN-O1: store i32 -1431655766, i32* %uninit, align 4
// ZERO-LABEL: @test_bool4_uninit() // ZERO-LABEL: @test_bool4_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i32 0, i32* %uninit, align 4 // ZERO-O1: store i32 0, i32* %uninit, align 4
TEST_BRACES(bool4, bool[4]); TEST_BRACES(bool4, bool[4]);
// CHECK-LABEL: @test_bool4_braces() // CHECK-LABEL: @test_bool4_braces()
// CHECK: %braces = alloca [4 x i8], align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca [4 x i8], align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(bool4, bool[4], { true, true, true, true }); TEST_CUSTOM(bool4, bool[4], { true, true, true, true });
// CHECK-LABEL: @test_bool4_custom() // CHECK-LABEL: @test_bool4_custom()
// CHECK: %custom = alloca [4 x i8], align // CHECK: %custom = alloca [4 x i8], align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memset
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(intptr4, int*[4]); TEST_UNINIT(intptr4, int*[4]);
// CHECK-LABEL: @test_intptr4_uninit() // CHECK-LABEL: @test_intptr4_uninit()
// CHECK: %uninit = alloca [4 x i32*], align // CHECK: %uninit = alloca [4 x i32*], align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-O1-LABEL: @test_intptr4_uninit() // PATTERN-O1-LABEL: @test_intptr4_uninit()
// PATTERN-O1: %1 = bitcast [4 x i32*]* %uninit to i8* // PATTERN-O1: [[C:%[0-9]+]] = bitcast [4 x i32*]* %uninit to i8*
// PATTERN-O1-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 16 %1, i8 -86, i64 32, i1 false) // PATTERN-O1: call void @llvm.memset.p0i8.i64(i8* nonnull align 16 [[C]], i8 -86, i64 32, i1 false)
// ZERO-LABEL: @test_intptr4_uninit() // ZERO-LABEL: @test_intptr4_uninit()
// ZERO: call void @llvm.memset{{.*}}, i8 0, // ZERO: call void @llvm.memset{{.*}}, i8 0,
TEST_BRACES(intptr4, int*[4]); TEST_BRACES(intptr4, int*[4]);
// CHECK-LABEL: @test_intptr4_braces() // CHECK-LABEL: @test_intptr4_braces()
// CHECK: %braces = alloca [4 x i32*], align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca [4 x i32*], align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 32, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 32, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(intptr4, int*[4], = { (int*)0x22222222, (int*)0x22222222, (int*)0x22222222, (int*)0x22222222 }); TEST_CUSTOM(intptr4, int*[4], = { (int*)0x22222222, (int*)0x22222222, (int*)0x22222222, (int*)0x22222222 });
// CHECK-LABEL: @test_intptr4_custom() // CHECK-LABEL: @test_intptr4_custom()
// CHECK: %custom = alloca [4 x i32*], align // CHECK: %custom = alloca [4 x i32*], align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memcpy
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(tailpad4, tailpad[4]); TEST_UNINIT(tailpad4, tailpad[4]);
// CHECK-LABEL: @test_tailpad4_uninit() // CHECK-LABEL: @test_tailpad4_uninit()
// CHECK: %uninit = alloca [4 x %struct.tailpad], align // CHECK: %uninit = alloca [4 x %struct.tailpad], align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_tailpad4_uninit() // PATTERN-LABEL: @test_tailpad4_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_tailpad4_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 16, i1 false)
// PATTERN-O1: bitcast // PATTERN-O1: bitcast
// PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}0, i8 -86, i64 16 // PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}0, i8 -86, i64 16
// ZERO-LABEL: @test_tailpad4_uninit() // ZERO-LABEL: @test_tailpad4_uninit()
// ZERO: call void @llvm.memset{{.*}}, i8 0, // ZERO: call void @llvm.memset{{.*}}, i8 0,
TEST_BRACES(tailpad4, tailpad[4]); TEST_BRACES(tailpad4, tailpad[4]);
// CHECK-LABEL: @test_tailpad4_braces() // CHECK-LABEL: @test_tailpad4_braces()
// CHECK: %braces = alloca [4 x %struct.tailpad], align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca [4 x %struct.tailpad], align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 16, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 16, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(tailpad4, tailpad[4], { {257, 1}, {257, 1}, {257, 1}, {257, 1} }); TEST_CUSTOM(tailpad4, tailpad[4], { {257, 1}, {257, 1}, {257, 1}, {257, 1} });
// CHECK-LABEL: @test_tailpad4_custom() // CHECK-LABEL: @test_tailpad4_custom()
// CHECK: %custom = alloca [4 x %struct.tailpad], align // CHECK: %custom = alloca [4 x %struct.tailpad], align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memset
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(tailpad9, tailpad[9]); TEST_UNINIT(tailpad9, tailpad[9]);
// CHECK-LABEL: @test_tailpad9_uninit() // CHECK-LABEL: @test_tailpad9_uninit()
// CHECK: %uninit = alloca [9 x %struct.tailpad], align // CHECK: %uninit = alloca [9 x %struct.tailpad], align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_tailpad9_uninit() // PATTERN-LABEL: @test_tailpad9_uninit()
// PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86,
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
// ZERO-LABEL: @test_atomicdouble_uninit() // ZERO-LABEL: @test_atomicdouble_uninit()
// ZERO: store double 0.000000e+00, double* %uninit, align 8 // ZERO: store double 0.000000e+00, double* %uninit, align 8
TEST_UNINIT(atomicnotlockfree, _Atomic(notlockfree)); TEST_UNINIT(atomicnotlockfree, _Atomic(notlockfree));
// CHECK-LABEL: @test_atomicnotlockfree_uninit() // CHECK-LABEL: @test_atomicnotlockfree_uninit()
// CHECK: %uninit = alloca %struct.notlockfree, align // CHECK: %uninit = alloca %struct.notlockfree, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_atomicnotlockfree_uninit() // PATTERN-LABEL: @test_atomicnotlockfree_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_atomicnotlockfree_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 32, i1 false)
// PATTERN-O1: bitcast // PATTERN-O1: bitcast
// PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}, i8 -86, i64 32 // PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}, i8 -86, i64 32
// ZERO-LABEL: @test_atomicnotlockfree_uninit() // ZERO-LABEL: @test_atomicnotlockfree_uninit()
// ZERO: call void @llvm.memset{{.*}}, i8 0, // ZERO: call void @llvm.memset{{.*}}, i8 0,
TEST_UNINIT(atomicpadded, _Atomic(padded)); TEST_UNINIT(atomicpadded, _Atomic(padded));
// CHECK-LABEL: @test_atomicpadded_uninit() // CHECK-LABEL: @test_atomicpadded_uninit()
// CHECK: %uninit = alloca %struct.padded, align // CHECK: %uninit = alloca %struct.padded, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_atomicpadded_uninit() // PATTERN-LABEL: @test_atomicpadded_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_atomicpadded_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 8, i1 false)
// PATTERN-O1: store i64 -6148914691236517206, i64* %uninit, align 8 // PATTERN-O1: store i64 -6148914691236517206, i64* %uninit, align 8
// ZERO-LABEL: @test_atomicpadded_uninit() // ZERO-LABEL: @test_atomicpadded_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i64 0, i64* %uninit, align 8 // ZERO-O1: store i64 0, i64* %uninit, align 8
TEST_UNINIT(atomictailpad, _Atomic(tailpad)); TEST_UNINIT(atomictailpad, _Atomic(tailpad));
// CHECK-LABEL: @test_atomictailpad_uninit() // CHECK-LABEL: @test_atomictailpad_uninit()
// CHECK: %uninit = alloca %struct.tailpad, align // CHECK: %uninit = alloca %struct.tailpad, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_atomictailpad_uninit() // PATTERN-LABEL: @test_atomictailpad_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_atomictailpad_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 4, i1 false)
// ZERO-LABEL: @test_atomictailpad_uninit() // ZERO-LABEL: @test_atomictailpad_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i32 0, i32* %uninit, align 4 // ZERO-O1: store i32 0, i32* %uninit, align 4
TEST_UNINIT(complexfloat, _Complex float); TEST_UNINIT(complexfloat, _Complex float);
// CHECK-LABEL: @test_complexfloat_uninit() // CHECK-LABEL: @test_complexfloat_uninit()
// CHECK: %uninit = alloca { float, float }, align // CHECK: %uninit = alloca { float, float }, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_complexfloat_uninit() // PATTERN-LABEL: @test_complexfloat_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_complexfloat_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -1, i64 8, i1 false)
// PATTERN-O1: %[[F1:[^ ]*]] = getelementptr inbounds {{.*}}%uninit, i64 0, i32 0 // PATTERN-O1: store i64 -1, i64* %uninit, align 8
// PATTERN-O1 store float 0xFFFFFFFFE0000000, float* %[[F1]], align
// PATTERN-O1: %[[F2:[^ ]*]] = getelementptr inbounds {{.*}}%uninit, i64 0, i32 1
// PATTERN-O1: store float 0xFFFFFFFFE0000000, float* %[[F2]], align
// ZERO-LABEL: @test_complexfloat_uninit() // ZERO-LABEL: @test_complexfloat_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i64 0, i64* %uninit, align 8 // ZERO-O1: store i64 0, i64* %uninit, align 8
TEST_BRACES(complexfloat, _Complex float); TEST_BRACES(complexfloat, _Complex float);
// CHECK-LABEL: @test_complexfloat_braces() // CHECK-LABEL: @test_complexfloat_braces()
// CHECK: %braces = alloca { float, float }, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca { float, float }, align [[ALIGN:[0-9]*]]
Show All 12 Lines
// CHECK-NEXT: store float 0x400921FB60000000, float* %[[I]], align [[ALIGN]] // CHECK-NEXT: store float 0x400921FB60000000, float* %[[I]], align [[ALIGN]]
// CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom)
TEST_UNINIT(complexdouble, _Complex double); TEST_UNINIT(complexdouble, _Complex double);
// CHECK-LABEL: @test_complexdouble_uninit() // CHECK-LABEL: @test_complexdouble_uninit()
// CHECK: %uninit = alloca { double, double }, align // CHECK: %uninit = alloca { double, double }, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_complexdouble_uninit() // PATTERN-LABEL: @test_complexdouble_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_complexdouble_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -1, i64 16, i1 false)
// ZERO-LABEL: @test_complexdouble_uninit() // ZERO-LABEL: @test_complexdouble_uninit()
// ZERO: call void @llvm.memset{{.*}}, i8 0, // ZERO: call void @llvm.memset{{.*}}, i8 0,
TEST_BRACES(complexdouble, _Complex double); TEST_BRACES(complexdouble, _Complex double);
// CHECK-LABEL: @test_complexdouble_braces() // CHECK-LABEL: @test_complexdouble_braces()
// CHECK: %braces = alloca { double, double }, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca { double, double }, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: %[[R:[^ ]*]] = getelementptr inbounds { double, double }, { double, double }* %braces, i32 0, i32 0 // CHECK-NEXT: %[[R:[^ ]*]] = getelementptr inbounds { double, double }, { double, double }* %braces, i32 0, i32 0
// CHECK-NEXT: %[[I:[^ ]*]] = getelementptr inbounds { double, double }, { double, double }* %braces, i32 0, i32 1 // CHECK-NEXT: %[[I:[^ ]*]] = getelementptr inbounds { double, double }, { double, double }* %braces, i32 0, i32 1
Show All 26 Lines
// CHECK-NEXT: store volatile i32 0, i32* %braces, align [[ALIGN]] // CHECK-NEXT: store volatile i32 0, i32* %braces, align [[ALIGN]]
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_UNINIT(semivolatile, semivolatile); TEST_UNINIT(semivolatile, semivolatile);
// CHECK-LABEL: @test_semivolatile_uninit() // CHECK-LABEL: @test_semivolatile_uninit()
// CHECK: %uninit = alloca %struct.semivolatile, align // CHECK: %uninit = alloca %struct.semivolatile, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_semivolatile_uninit() // PATTERN-LABEL: @test_semivolatile_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_semivolatile_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 8, i1 false)
// ZERO-LABEL: @test_semivolatile_uninit() // ZERO-LABEL: @test_semivolatile_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i64 0, i64* %uninit, align 8 // ZERO-O1: store i64 0, i64* %uninit, align 8
TEST_BRACES(semivolatile, semivolatile); TEST_BRACES(semivolatile, semivolatile);
// CHECK-LABEL: @test_semivolatile_braces() // CHECK-LABEL: @test_semivolatile_braces()
// CHECK: %braces = alloca %struct.semivolatile, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.semivolatile, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 8, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 8, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(semivolatile, semivolatile, { 0x44444444, 0x44444444 }); TEST_CUSTOM(semivolatile, semivolatile, { 0x44444444, 0x44444444 });
// CHECK-LABEL: @test_semivolatile_custom() // CHECK-LABEL: @test_semivolatile_custom()
// CHECK: %custom = alloca %struct.semivolatile, align // CHECK: %custom = alloca %struct.semivolatile, align
// CHECK-O0: bitcast // CHECK-O0: bitcast
// CHECK-O0: call void @llvm.memcpy // CHECK-O0: call void @llvm.memset
// CHECK-O0: call void @{{.*}}used{{.*}}%custom) // CHECK-O0: call void @{{.*}}used{{.*}}%custom)
// CHECK-O1: store i64 4919131752989213764, i64* %custom, align 8 // CHECK-O1: store i64 4919131752989213764, i64* %custom, align 8
TEST_UNINIT(semivolatileinit, semivolatileinit); TEST_UNINIT(semivolatileinit, semivolatileinit);
// CHECK-LABEL: @test_semivolatileinit_uninit() // CHECK-LABEL: @test_semivolatileinit_uninit()
// CHECK: %uninit = alloca %struct.semivolatileinit, align // CHECK: %uninit = alloca %struct.semivolatileinit, align
// CHECK-NEXT: call void @{{.*}}semivolatileinit{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}semivolatileinit{{.*}}%uninit)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
Show All 18 Lines
TEST_UNINIT(base, base); TEST_UNINIT(base, base);
// CHECK-LABEL: @test_base_uninit() // CHECK-LABEL: @test_base_uninit()
// CHECK: %uninit = alloca %struct.base, align // CHECK: %uninit = alloca %struct.base, align
// CHECK-NEXT: call void @{{.*}}base{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}base{{.*}}%uninit)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_base_uninit() // PATTERN-LABEL: @test_base_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_base_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 8, i1 false)
// ZERO-LABEL: @test_base_uninit() // ZERO-LABEL: @test_base_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1-LEGACY: store i64 0, {{.*}} align 8 // ZERO-O1-LEGACY: store i64 0, {{.*}} align 8
// ZERO-O1-NEWPM: store i32 (...)** bitcast (i8** getelementptr inbounds ({ [4 x i8*] }, { [4 x i8*] }* @_ZTV4base, i64 0, inrange i32 0, i64 2) to i32 (...)**), {{.*}}, align 8 // ZERO-O1-NEWPM: store i32 (...)** bitcast (i8** getelementptr inbounds ({ [4 x i8*] }, { [4 x i8*] }* @_ZTV4base, i64 0, inrange i32 0, i64 2) to i32 (...)**), {{.*}}, align 8
TEST_BRACES(base, base); TEST_BRACES(base, base);
// CHECK-LABEL: @test_base_braces() // CHECK-LABEL: @test_base_braces()
// CHECK: %braces = alloca %struct.base, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.base, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 8, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 8, i1 false)
// CHECK-NEXT: call void @{{.*}}base{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}base{{.*}}%braces)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_UNINIT(derived, derived); TEST_UNINIT(derived, derived);
// CHECK-LABEL: @test_derived_uninit() // CHECK-LABEL: @test_derived_uninit()
// CHECK: %uninit = alloca %struct.derived, align // CHECK: %uninit = alloca %struct.derived, align
// CHECK-NEXT: call void @{{.*}}derived{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}derived{{.*}}%uninit)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_derived_uninit() // PATTERN-LABEL: @test_derived_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_derived_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 8, i1 false)
// ZERO-LABEL: @test_derived_uninit() // ZERO-LABEL: @test_derived_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1-LEGACY: store i64 0, {{.*}} align 8 // ZERO-O1-LEGACY: store i64 0, {{.*}} align 8
// ZERO-O1-NEWPM: store i32 (...)** bitcast (i8** getelementptr inbounds ({ [4 x i8*] }, { [4 x i8*] }* @_ZTV7derived, i64 0, inrange i32 0, i64 2) to i32 (...)**), {{.*}} align 8 // ZERO-O1-NEWPM: store i32 (...)** bitcast (i8** getelementptr inbounds ({ [4 x i8*] }, { [4 x i8*] }* @_ZTV7derived, i64 0, inrange i32 0, i64 2) to i32 (...)**), {{.*}} align 8
TEST_BRACES(derived, derived); TEST_BRACES(derived, derived);
// CHECK-LABEL: @test_derived_braces() // CHECK-LABEL: @test_derived_braces()
// CHECK: %braces = alloca %struct.derived, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.derived, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 8, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 8, i1 false)
// CHECK-NEXT: call void @{{.*}}derived{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}derived{{.*}}%braces)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_UNINIT(virtualderived, virtualderived); TEST_UNINIT(virtualderived, virtualderived);
// CHECK-LABEL: @test_virtualderived_uninit() // CHECK-LABEL: @test_virtualderived_uninit()
// CHECK: %uninit = alloca %struct.virtualderived, align // CHECK: %uninit = alloca %struct.virtualderived, align
// CHECK-NEXT: call void @{{.*}}virtualderived{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}virtualderived{{.*}}%uninit)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_virtualderived_uninit() // PATTERN-LABEL: @test_virtualderived_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_virtualderived_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 16, i1 false)
// ZERO-LABEL: @test_virtualderived_uninit() // ZERO-LABEL: @test_virtualderived_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1-LEGACY: call void @llvm.memset{{.*}}, i8 0, // ZERO-O1-LEGACY: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1-NEWPM: [[FIELD1:%.*]] = getelementptr inbounds %struct.virtualderived, %struct.virtualderived* %uninit, i64 0, i32 1, i32 0, i32 0 // ZERO-O1-NEWPM: [[FIELD1:%.*]] = getelementptr inbounds %struct.virtualderived, %struct.virtualderived* %uninit, i64 0, i32 1, i32 0, i32 0
// ZERO-O1-NEWPM: [[FIELD0:%.*]] = getelementptr inbounds %struct.virtualderived, %struct.virtualderived* %uninit, i64 0, i32 0, i32 0 // ZERO-O1-NEWPM: [[FIELD0:%.*]] = getelementptr inbounds %struct.virtualderived, %struct.virtualderived* %uninit, i64 0, i32 0, i32 0
// ZERO-O1-NEWPM: store i32 (...)** bitcast (i8** getelementptr inbounds ({ [7 x i8*], [5 x i8*] }, { [7 x i8*], [5 x i8*] }* @_ZTV14virtualderived, i64 0, inrange i32 0, i64 5) to i32 (...)**), i32 (...)*** [[FIELD0]], align 8 // ZERO-O1-NEWPM: store i32 (...)** bitcast (i8** getelementptr inbounds ({ [7 x i8*], [5 x i8*] }, { [7 x i8*], [5 x i8*] }* @_ZTV14virtualderived, i64 0, inrange i32 0, i64 5) to i32 (...)**), i32 (...)*** [[FIELD0]], align 8
// ZERO-O1-NEWPM: store i32 (...)** bitcast (i8** getelementptr inbounds ({ [7 x i8*], [5 x i8*] }, { [7 x i8*], [5 x i8*] }* @_ZTV14virtualderived, i64 0, inrange i32 1, i64 3) to i32 (...)**), i32 (...)*** [[FIELD1]], align 8 // ZERO-O1-NEWPM: store i32 (...)** bitcast (i8** getelementptr inbounds ({ [7 x i8*], [5 x i8*] }, { [7 x i8*], [5 x i8*] }* @_ZTV14virtualderived, i64 0, inrange i32 1, i64 3) to i32 (...)**), i32 (...)*** [[FIELD1]], align 8
TEST_BRACES(virtualderived, virtualderived); TEST_BRACES(virtualderived, virtualderived);
// CHECK-LABEL: @test_virtualderived_braces() // CHECK-LABEL: @test_virtualderived_braces()
// CHECK: %braces = alloca %struct.virtualderived, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %struct.virtualderived, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 16, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 16, i1 false)
// CHECK-NEXT: call void @{{.*}}virtualderived{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}virtualderived{{.*}}%braces)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_UNINIT(matching, matching); TEST_UNINIT(matching, matching);
// CHECK-LABEL: @test_matching_uninit() // CHECK-LABEL: @test_matching_uninit()
// CHECK: %uninit = alloca %union.matching, align // CHECK: %uninit = alloca %union.matching, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_matching_uninit() // PATTERN-LABEL: @test_matching_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_matching_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 4, i1 false)
// ZERO-LABEL: @test_matching_uninit() // ZERO-LABEL: @test_matching_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i32 0, {{.*}} align 4 // ZERO-O1: store i32 0, {{.*}} align 4
TEST_BRACES(matching, matching); TEST_BRACES(matching, matching);
// CHECK-LABEL: @test_matching_braces() // CHECK-LABEL: @test_matching_braces()
// CHECK: %braces = alloca %union.matching, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %union.matching, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
Show All 9 Lines
// CHECK-O1: getelementptr // CHECK-O1: getelementptr
// CHECK-O1: store i32 1198526208, i32* {{.*}}, align 4 // CHECK-O1: store i32 1198526208, i32* {{.*}}, align 4
TEST_UNINIT(matchingreverse, matchingreverse); TEST_UNINIT(matchingreverse, matchingreverse);
// CHECK-LABEL: @test_matchingreverse_uninit() // CHECK-LABEL: @test_matchingreverse_uninit()
// CHECK: %uninit = alloca %union.matchingreverse, align // CHECK: %uninit = alloca %union.matchingreverse, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_matchingreverse_uninit() // PATTERN-LABEL: @test_matchingreverse_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_matchingreverse_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -1, i64 4, i1 false)
// PATTERN-O1: store float 0xFFFFFFFFE0000000 // PATTERN-O1: [[F:%[0-9]+]] = bitcast %union.matchingreverse* %uninit to i32*
// PATTERN-O1: store i32 -1, i32* [[F]], align 4
// ZERO-LABEL: @test_matchingreverse_uninit() // ZERO-LABEL: @test_matchingreverse_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i32 0, {{.*}} align 4 // ZERO-O1: store i32 0, {{.*}} align 4
TEST_BRACES(matchingreverse, matchingreverse); TEST_BRACES(matchingreverse, matchingreverse);
// CHECK-LABEL: @test_matchingreverse_braces() // CHECK-LABEL: @test_matchingreverse_braces()
// CHECK: %braces = alloca %union.matchingreverse, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %union.matchingreverse, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(matchingreverse, matchingreverse, { .i = 0xf00f }); TEST_CUSTOM(matchingreverse, matchingreverse, { .i = 0xf00f });
// CHECK-LABEL: @test_matchingreverse_custom() // CHECK-LABEL: @test_matchingreverse_custom()
// CHECK: %custom = alloca %union.matchingreverse, align // CHECK: %custom = alloca %union.matchingreverse, align
// CHECK-O0: bitcast // CHECK-O0: bitcast
// CHECK-O0: call void @llvm.memcpy // CHECK-O0: call void @llvm.memcpy
// CHECK-O0: call void @{{.*}}used{{.*}}%custom) // CHECK-O0: call void @{{.*}}used{{.*}}%custom)
// CHECK-O1: store i32 61455, i32* %1, align 4 // CHECK-O1: store i32 61455, i32* %1, align 4
TEST_UNINIT(unmatched, unmatched); TEST_UNINIT(unmatched, unmatched);
// CHECK-LABEL: @test_unmatched_uninit() // CHECK-LABEL: @test_unmatched_uninit()
// CHECK: %uninit = alloca %union.unmatched, align // CHECK: %uninit = alloca %union.unmatched, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_unmatched_uninit() // PATTERN-LABEL: @test_unmatched_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_unmatched_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 4, i1 false)
// ZERO-LABEL: @test_unmatched_uninit() // ZERO-LABEL: @test_unmatched_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i32 0, {{.*}} align 4 // ZERO-O1: store i32 0, {{.*}} align 4
TEST_BRACES(unmatched, unmatched); TEST_BRACES(unmatched, unmatched);
// CHECK-LABEL: @test_unmatched_braces() // CHECK-LABEL: @test_unmatched_braces()
// CHECK: %braces = alloca %union.unmatched, align // CHECK: %braces = alloca %union.unmatched, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memset
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(unmatched, unmatched, { .i = 0x3badbeef }); TEST_CUSTOM(unmatched, unmatched, { .i = 0x3badbeef });
// CHECK-LABEL: @test_unmatched_custom() // CHECK-LABEL: @test_unmatched_custom()
// CHECK: %custom = alloca %union.unmatched, align // CHECK: %custom = alloca %union.unmatched, align
// CHECK-O0: bitcast // CHECK-O0: bitcast
// CHECK-O0: call void @llvm.memcpy // CHECK-O0: call void @llvm.memcpy
// CHECK-O0: call void @{{.*}}used{{.*}}%custom) // CHECK-O0: call void @{{.*}}used{{.*}}%custom)
// CHECK-O1: store i32 1001242351, i32* {{.*}}, align 4 // CHECK-O1: store i32 1001242351, i32* {{.*}}, align 4
TEST_UNINIT(unmatchedreverse, unmatchedreverse); TEST_UNINIT(unmatchedreverse, unmatchedreverse);
// CHECK-LABEL: @test_unmatchedreverse_uninit() // CHECK-LABEL: @test_unmatchedreverse_uninit()
// CHECK: %uninit = alloca %union.unmatchedreverse, align // CHECK: %uninit = alloca %union.unmatchedreverse, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_unmatchedreverse_uninit() // PATTERN-LABEL: @test_unmatchedreverse_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_unmatchedreverse_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -86, i64 4, i1 false)
// ZERO-LABEL: @test_unmatchedreverse_uninit() // ZERO-LABEL: @test_unmatchedreverse_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i32 0, {{.*}} align 4 // ZERO-O1: store i32 0, {{.*}} align 4
TEST_BRACES(unmatchedreverse, unmatchedreverse); TEST_BRACES(unmatchedreverse, unmatchedreverse);
// CHECK-LABEL: @test_unmatchedreverse_braces() // CHECK-LABEL: @test_unmatchedreverse_braces()
// CHECK: %braces = alloca %union.unmatchedreverse, align [[ALIGN:[0-9]*]] // CHECK: %braces = alloca %union.unmatchedreverse, align [[ALIGN:[0-9]*]]
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false) // CHECK-NEXT: call void @llvm.memset{{.*}}(i8* align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false)
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(unmatchedreverse, unmatchedreverse, { .c = 42 }); TEST_CUSTOM(unmatchedreverse, unmatchedreverse, { .c = 42 });
// CHECK-LABEL: @test_unmatchedreverse_custom() // CHECK-LABEL: @test_unmatchedreverse_custom()
// CHECK: %custom = alloca %union.unmatchedreverse, align // CHECK: %custom = alloca %union.unmatchedreverse, align
// CHECK-O0: bitcast // CHECK-O0: bitcast
// CHECK-O0: call void @llvm.memcpy // CHECK-O0: call void @llvm.memset
// CHECK-O0: call void @{{.*}}used{{.*}}%custom) // CHECK-O0: call void @{{.*}}used{{.*}}%custom)
// PATTERN-O1: store i32 -1431655894, i32* {{.*}}, align 4 // PATTERN-O1: store i32 -1431655894, i32* {{.*}}, align 4
// ZERO-O1: store i32 42, i32* {{.*}}, align 4 // ZERO-O1: store i32 42, i32* {{.*}}, align 4
TEST_UNINIT(unmatchedfp, unmatchedfp); TEST_UNINIT(unmatchedfp, unmatchedfp);
// CHECK-LABEL: @test_unmatchedfp_uninit() // CHECK-LABEL: @test_unmatchedfp_uninit()
// CHECK: %uninit = alloca %union.unmatchedfp, align // CHECK: %uninit = alloca %union.unmatchedfp, align
// CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit)
// PATTERN-LABEL: @test_unmatchedfp_uninit() // PATTERN-LABEL: @test_unmatchedfp_uninit()
// PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_unmatchedfp_uninit.uninit // PATTERN-O0: call void @llvm.memset{{.*}}, i8 -1, i64 8, i1 false)
// ZERO-LABEL: @test_unmatchedfp_uninit() // ZERO-LABEL: @test_unmatchedfp_uninit()
// ZERO-O0: call void @llvm.memset{{.*}}, i8 0, // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,
// ZERO-O1: store i64 0, {{.*}} align 8 // ZERO-O1: store i64 0, {{.*}} align 8
TEST_BRACES(unmatchedfp, unmatchedfp); TEST_BRACES(unmatchedfp, unmatchedfp);
// CHECK-LABEL: @test_unmatchedfp_braces() // CHECK-LABEL: @test_unmatchedfp_braces()
// CHECK: %braces = alloca %union.unmatchedfp, align // CHECK: %braces = alloca %union.unmatchedfp, align
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memcpy // CHECK-NEXT: call void @llvm.memset
// CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces)
TEST_CUSTOM(unmatchedfp, unmatchedfp, { .d = 3.1415926535897932384626433 }); TEST_CUSTOM(unmatchedfp, unmatchedfp, { .d = 3.1415926535897932384626433 });
// CHECK-LABEL: @test_unmatchedfp_custom() // CHECK-LABEL: @test_unmatchedfp_custom()
// CHECK: %custom = alloca %union.unmatchedfp, align // CHECK: %custom = alloca %union.unmatchedfp, align
// CHECK-O0: bitcast // CHECK-O0: bitcast
// CHECK-O0: call void @llvm.memcpy // CHECK-O0: call void @llvm.memcpy
// CHECK-O0: call void @{{.*}}used{{.*}}%custom) // CHECK-O0: call void @{{.*}}used{{.*}}%custom)
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

clang/test/CodeGenCXX/references.cpp

Show First 20 Lines • Show All 275 Lines • ▼ Show 20 Lines
} }
} }
// PR9565 // PR9565
namespace PR9565 { namespace PR9565 {
struct a { int a : 10, b : 10; }; struct a { int a : 10, b : 10; };
// CHECK-LABEL: define void @_ZN6PR95651fEv() // CHECK-LABEL: define void @_ZN6PR95651fEv()
void f() { void f() {
// CHECK: call void @llvm.memcpy // CHECK: call void @llvm.memset
a x = { 0, 0 }; a x = { 0, 0 };
// CHECK: [[WITH_SEVENTEEN:%[.a-zA-Z0-9]+]] = or i32 [[WITHOUT_SEVENTEEN:%[.a-zA-Z0-9]+]], 17 // CHECK: [[WITH_SEVENTEEN:%[.a-zA-Z0-9]+]] = or i32 [[WITHOUT_SEVENTEEN:%[.a-zA-Z0-9]+]], 17
// CHECK: store i32 [[WITH_SEVENTEEN]], i32* [[XA:%[.a-zA-Z0-9]+]] // CHECK: store i32 [[WITH_SEVENTEEN]], i32* [[XA:%[.a-zA-Z0-9]+]]
x.a = 17; x.a = 17;
// CHECK-NEXT: bitcast // CHECK-NEXT: bitcast
// CHECK-NEXT: load // CHECK-NEXT: load
// CHECK-NEXT: shl // CHECK-NEXT: shl
// CHECK-NEXT: ashr // CHECK-NEXT: ashr
Show All 20 Lines