1 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown -fblocks %s -emit-llvm -o - | FileCheck %s -check-prefixes=CHECK,CHECK-O0 2 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown -fblocks -ftrivial-auto-var-init=pattern %s -emit-llvm -o - | FileCheck %s -check-prefixes=CHECK-O0,PATTERN,PATTERN-O0 3 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown -fblocks -ftrivial-auto-var-init=pattern %s -O1 -emit-llvm -o - | FileCheck %s -check-prefixes=PATTERN,PATTERN-O1 4 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown -fblocks -ftrivial-auto-var-init=zero %s -emit-llvm -o - | FileCheck %s -check-prefixes=CHECK-O0,ZERO,ZERO-O0 5 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown -fblocks -ftrivial-auto-var-init=zero %s -O1 -emit-llvm -o - | FileCheck %s -check-prefixes=ZERO,ZERO-O1 6 // RUN: %clang_cc1 -std=c++14 -triple i386-unknown-unknown -fblocks -ftrivial-auto-var-init=pattern %s -emit-llvm -o - | FileCheck %s -check-prefixes=CHECK-O0,PATTERN,PATTERN-O0 7 8 #pragma clang diagnostic ignored "-Winaccessible-base" 9 10 #ifdef __x86_64__ 11 char inits[] = {"-86/-21846/-1431655766/i64/-6148914691236517206/-6148914691236517206/i128/-113427455640312821154458202477256070486/i64/-6148914691236517206/AA/"}; 12 #else 13 char inits[] = {"-1/-1/-1/i32/-1/-1/i32/-1/i32/-1/FF/"}; 14 #define __int128 int; 15 #endif 16 // PATTERN: @inits = {{.*}} c"[[I8:[^/]+]]/[[I16:[^/]+]]/[[I32:[^/]+]]/[[ILONGT:[^/]+]]/[[ILONG:[^/]+]]/[[I64:[^/]+]]/[[I128T:[^/]+]]/[[I128:[^/]+]]/[[IPTRT:[^/]+]]/[[IPTR:[^/]+]]/[[IC:[^/]+]]/\00", align 1 17 18 template<typename T> void used(T &) noexcept; 19 20 #define TEST_UNINIT(NAME, TYPE) \ 21 using type_##NAME = TYPE; \ 22 void test_##NAME##_uninit() { \ 23 type_##NAME uninit; \ 24 used(uninit); \ 25 } 26 27 // Value initialization on scalars, aggregate initialization on aggregates. 28 #define TEST_BRACES(NAME, TYPE) \ 29 using type_##NAME = TYPE; \ 30 void test_##NAME##_braces() { \ 31 type_##NAME braces = {}; \ 32 used(braces); \ 33 } 34 35 #define TEST_CUSTOM(NAME, TYPE, ...) \ 36 using type_##NAME = TYPE; \ 37 void test_##NAME##_custom() { \ 38 type_##NAME custom __VA_ARGS__; \ 39 used(custom); \ 40 } 41 42 // None of the synthesized globals should contain `undef`. 43 // PATTERN-NOT: undef 44 // ZERO-NOT: undef 45 46 // PATTERN-O0: @__const.test_empty_uninit.uninit = private unnamed_addr constant %struct.empty { i8 [[I8]] }, align 1 47 // PATTERN-O1-NOT: @__const.test_empty_uninit.uninit 48 struct empty {}; 49 // PATTERN-O0: @__const.test_small_uninit.uninit = private unnamed_addr constant %struct.small { i8 [[I8]] }, align 1 50 // PATTERN-O0: @__const.test_small_custom.custom = private unnamed_addr constant %struct.small { i8 42 }, align 1 51 // ZERO-O0: @__const.test_small_custom.custom = private unnamed_addr constant %struct.small { i8 42 }, align 1 52 // PATTERN-O1-NOT: @__const.test_small_uninit.uninit 53 // PATTERN-O1-NOT: @__const.test_small_custom.custom 54 // ZERO-O1-NOT: @__const.test_small_custom.custom 55 struct small { char c; }; 56 // PATTERN-O0: @__const.test_smallinit_uninit.uninit = private unnamed_addr constant %struct.smallinit { i8 [[I8]] }, align 1 57 // PATTERN-O0: @__const.test_smallinit_braces.braces = private unnamed_addr constant %struct.smallinit { i8 [[I8]] }, align 1 58 // PATTERN-O0: @__const.test_smallinit_custom.custom = private unnamed_addr constant %struct.smallinit { i8 [[I8]] }, align 1 59 // PATTERN-O1-NOT: @__const.test_smallinit_uninit.uninit 60 // PATTERN-O1-NOT: @__const.test_smallinit_braces.braces 61 // PATTERN-O1-NOT: @__const.test_smallinit_custom.custom 62 struct smallinit { char c = 42; }; 63 // PATTERN-O0: @__const.test_smallpartinit_uninit.uninit = private unnamed_addr constant %struct.smallpartinit { i8 [[I8]], i8 [[I8]] }, align 1 64 // PATTERN-O0: @__const.test_smallpartinit_braces.braces = private unnamed_addr constant %struct.smallpartinit { i8 [[I8]], i8 [[I8]] }, align 1 65 // PATTERN-O0: @__const.test_smallpartinit_custom.custom = private unnamed_addr constant %struct.smallpartinit { i8 [[I8]], i8 [[I8]] }, align 1 66 // PATTERN-O1-NOT: @__const.test_smallpartinit_uninit.uninit 67 // PATTERN-O1-NOT: @__const.test_smallpartinit_braces.braces 68 // PATTERN-O1-NOT: @__const.test_smallpartinit_custom.custom 69 struct smallpartinit { char c = 42, d; }; 70 // PATTERN-O0: @__const.test_nullinit_uninit.uninit = private unnamed_addr constant %struct.nullinit { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) }, align 71 // PATTERN-O0: @__const.test_nullinit_braces.braces = private unnamed_addr constant %struct.nullinit { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) }, align 72 // PATTERN-O0: @__const.test_nullinit_custom.custom = private unnamed_addr constant %struct.nullinit { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) }, align 73 // PATTERN-O1-NOT: @__const.test_nullinit_uninit.uninit 74 // PATTERN-O1-NOT: @__const.test_nullinit_braces.braces 75 // PATTERN-O1-NOT: @__const.test_nullinit_custom.custom 76 struct nullinit { char* null = nullptr; }; 77 // PATTERN-O0: @__const.test_padded_uninit.uninit = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]", i32 [[I32]] }, align 4 78 // 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 79 // 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 80 // PATTERN-O1-NOT: @__const.test_padded_uninit.uninit 81 // PATTERN-O1-NOT: @__const.test_padded_custom.custom 82 // ZERO-O1-NOT: @__const.test_padded_custom.custom 83 struct padded { char c; int i; }; 84 // PATTERN-O0: @__const.test_paddednullinit_uninit.uninit = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]", i32 [[I32]] }, align 4 85 // PATTERN-O0: @__const.test_paddednullinit_braces.braces = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]", i32 [[I32]] }, align 4 86 // PATTERN-O0: @__const.test_paddednullinit_custom.custom = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]", i32 [[I32]] }, align 4 87 // PATTERN-O1-NOT: @__const.test_paddednullinit_uninit.uninit 88 // PATTERN-O1-NOT: @__const.test_paddednullinit_braces.braces 89 // PATTERN-O1-NOT: @__const.test_paddednullinit_custom.custom 90 struct paddednullinit { char c = 0; int i = 0; }; 91 // PATTERN-O0: @__const.test_paddedpacked_uninit.uninit = private unnamed_addr constant %struct.paddedpacked <{ i8 [[I8]], i32 [[I32]] }>, align 1 92 struct paddedpacked { char c; int i; } __attribute__((packed)); 93 // PATTERN-O0: @__const.test_paddedpackedarray_uninit.uninit = private unnamed_addr constant %struct.paddedpackedarray { [2 x %struct.paddedpacked] [%struct.paddedpacked <{ i8 [[I8]], i32 [[I32]] }>, %struct.paddedpacked <{ i8 [[I8]], i32 [[I32]] }>] }, align 1 94 struct paddedpackedarray { struct paddedpacked p[2]; }; 95 // PATTERN-O0: @__const.test_unpackedinpacked_uninit.uninit = private unnamed_addr constant <{ { i8, [3 x i8], i32 }, i8 }> <{ { i8, [3 x i8], i32 } { i8 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]", i32 [[I32]] }, i8 [[I8]] }>, align 1 96 struct unpackedinpacked { padded a; char b; } __attribute__((packed)); 97 // 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 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]", i32 [[I32]] }, { i8, [3 x i8], i32 } { i8 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]", i32 [[I32]] } }, align 4 98 struct paddednested { struct padded p1, p2; }; 99 // PATTERN-O0: @__const.test_paddedpackednested_uninit.uninit = private unnamed_addr constant %struct.paddedpackednested { %struct.paddedpacked <{ i8 [[I8]], i32 [[I32]] }>, %struct.paddedpacked <{ i8 [[I8]], i32 [[I32]] }> }, align 1 100 struct paddedpackednested { struct paddedpacked p1, p2; }; 101 // PATTERN-O0: @__const.test_bitfield_uninit.uninit = private unnamed_addr constant %struct.bitfield { i8 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]" }, align 4 102 // PATTERN-O0: @__const.test_bitfield_custom.custom = private unnamed_addr constant %struct.bitfield { i8 20, [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]" }, align 4 103 // ZERO-O0: @__const.test_bitfield_custom.custom = private unnamed_addr constant %struct.bitfield { i8 20, [3 x i8] zeroinitializer }, align 4 104 // PATTERN-O1-NOT: @__const.test_bitfield_uninit.uninit 105 // PATTERN-O1-NOT: @__const.test_bitfield_custom.custom 106 // ZERO-O1-NOT: @__const.test_bitfield_custom.custom 107 struct bitfield { int i : 4; int j : 2; }; 108 // PATTERN-O0: @__const.test_bitfieldaligned_uninit.uninit = private unnamed_addr constant %struct.bitfieldaligned { i8 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]", i8 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]" }, align 4 109 // PATTERN-O0: @__const.test_bitfieldaligned_custom.custom = private unnamed_addr constant %struct.bitfieldaligned { i8 4, [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]", i8 1, [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]" }, align 4 110 // 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 111 // PATTERN-O1-NOT: @__const.test_bitfieldaligned_uninit.uninit 112 // PATTERN-O1-NOT: @__const.test_bitfieldaligned_custom.custom 113 // ZERO-O1-NOT: @__const.test_bitfieldaligned_custom.custom 114 struct bitfieldaligned { int i : 4; int : 0; int j : 2; }; 115 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; }; 116 // PATTERN-O0: @__const.test_arraytail_uninit.uninit = private unnamed_addr constant %struct.arraytail { i32 [[I32]], [0 x i32] zeroinitializer }, align 4 117 // PATTERN-O0: @__const.test_arraytail_custom.custom = private unnamed_addr constant %struct.arraytail { i32 57005, [0 x i32] zeroinitializer }, align 4 118 // ZERO-O0: @__const.test_arraytail_custom.custom = private unnamed_addr constant %struct.arraytail { i32 57005, [0 x i32] zeroinitializer }, align 4 119 // PATTERN-O1-NOT: @__const.test_arraytail_uninit.uninit 120 // PATTERN-O1-NOT: @__const.test_arraytail_custom.custom 121 // ZERO-O1-NOT: @__const.test_arraytail_custom.custom 122 struct arraytail { int i; int arr[]; }; 123 // PATTERN-O0: @__const.test_int1_uninit.uninit = private unnamed_addr constant [1 x i32] {{\[}}i32 [[I32]]], align 4 124 // PATTERN-O0: @__const.test_int1_custom.custom = private unnamed_addr constant [1 x i32] [i32 858993459], align 4 125 // ZERO-O0: @__const.test_int1_custom.custom = private unnamed_addr constant [1 x i32] [i32 858993459], align 4 126 // PATTERN-O1-NOT: @__const.test_int1_uninit.uninit 127 // PATTERN-O1-NOT: @__const.test_int1_custom.custom 128 // ZERO-O1-NOT: @__const.test_int1_custom.custom 129 130 // PATTERN-O0: @__const.test_bool4_uninit.uninit = private unnamed_addr constant [4 x i8] c"\[[IC]]\[[IC]]\[[IC]]\[[IC]]", align 1 131 // PATTERN-O0: @__const.test_bool4_custom.custom = private unnamed_addr constant [4 x i8] c"\01\01\01\01", align 1 132 // ZERO-O0: @__const.test_bool4_custom.custom = private unnamed_addr constant [4 x i8] c"\01\01\01\01", align 1 133 // PATTERN-O1-NOT: @__const.test_bool4_uninit.uninit 134 // PATTERN-O1-NOT: @__const.test_bool4_custom.custom 135 // ZERO-O1-NOT: @__const.test_bool4_custom.custom 136 137 // PATTERN-O0: @__const.test_tailpad4_uninit.uninit = private unnamed_addr constant [4 x { i16, i8, [1 x i8] }] [{ i16, i8, [1 x i8] } { i16 [[I16]], i8 [[I8]], [1 x i8] c"\[[IC]]" }, { i16, i8, [1 x i8] } { i16 [[I16]], i8 [[I8]], [1 x i8] c"\[[IC]]" }, { i16, i8, [1 x i8] } { i16 [[I16]], i8 [[I8]], [1 x i8] c"\[[IC]]" }, { i16, i8, [1 x i8] } { i16 [[I16]], i8 [[I8]], [1 x i8] c"\[[IC]]" }], align 138 // PATTERN-O1-NOT: @__const.test_tailpad4_uninit.uninit 139 struct tailpad { short s; char c; }; 140 // PATTERN-O0: @__const.test_atomicnotlockfree_uninit.uninit = private unnamed_addr constant %struct.notlockfree { [4 x i64] {{\[}}i64 [[I64]], i64 [[I64]], i64 [[I64]], i64 [[I64]]] }, align 141 // PATTERN-O1-NOT: @__const.test_atomicnotlockfree_uninit.uninit 142 struct notlockfree { long long a[4]; }; 143 // PATTERN-O0: @__const.test_atomicpadded_uninit.uninit = private unnamed_addr constant { i8, [3 x i8], i32 } { i8 [[I8]], [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]", i32 [[I32]] }, align 8 144 // PATTERN-O1-NOT: @__const.test_atomicpadded_uninit.uninit 145 // PATTERN-O0: @__const.test_atomictailpad_uninit.uninit = private unnamed_addr constant { i16, i8, [1 x i8] } { i16 [[I16]], i8 [[I8]], [1 x i8] c"\[[IC]]" }, align 4 146 // PATTERN-O1-NOT: @__const.test_atomictailpad_uninit.uninit 147 // PATTERN-O0: @__const.test_complexfloat_uninit.uninit = private unnamed_addr constant { float, float } { float 0xFFFFFFFFE0000000, float 0xFFFFFFFFE0000000 }, align 4 148 // PATTERN-O1-NOT: @__const.test_complexfloat_uninit.uninit 149 // PATTERN-O0: @__const.test_complexdouble_uninit.uninit = private unnamed_addr constant { double, double } { double 0xFFFFFFFFFFFFFFFF, double 0xFFFFFFFFFFFFFFFF }, align 8 150 // PATTERN-O1-NOT: @__const.test_complexdouble_uninit.uninit 151 // PATTERN-O0: @__const.test_semivolatile_uninit.uninit = private unnamed_addr constant %struct.semivolatile { i32 [[I32]], i32 [[I32]] }, align 4 152 // PATTERN-O0: @__const.test_semivolatile_custom.custom = private unnamed_addr constant %struct.semivolatile { i32 1145324612, i32 1145324612 }, align 4 153 // PATTERN-O1-NOT: @__const.test_semivolatile_custom.custom 154 struct semivolatile { int i; volatile int vi; }; 155 // PATTERN-O0: @__const.test_semivolatileinit_uninit.uninit = private unnamed_addr constant %struct.semivolatileinit { i32 [[I32]], i32 [[I32]] }, align 4 156 // PATTERN-O1-NOT: @__const.test_semivolatileinit_uninit.uninit 157 // PATTERN-O0: @__const.test_semivolatileinit_braces.braces = private unnamed_addr constant %struct.semivolatileinit { i32 [[I32]], i32 [[I32]] }, align 4 158 // PATTERN-O1-NOT: @__const.test_semivolatileinit_braces.braces 159 // PATTERN-O0: @__const.test_semivolatileinit_custom.custom = private unnamed_addr constant %struct.semivolatileinit { i32 [[I32]], i32 [[I32]] }, align 4 160 // PATTERN-O1-NOT: @__const.test_semivolatileinit_custom.custom = private unnamed_addr constant %struct.semivolatileinit { i32 [[I32]], i32 [[I32]] }, align 4 161 // ZERO-O0: @__const.test_semivolatile_custom.custom = private unnamed_addr constant %struct.semivolatile { i32 1145324612, i32 1145324612 }, align 4 162 // ZERO-O1-NOT: @__const.test_semivolatile_custom.custom 163 struct semivolatileinit { int i = 0x11111111; volatile int vi = 0x11111111; }; 164 // PATTERN-O0: @__const.test_base_uninit.uninit = private unnamed_addr constant %struct.base { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) }, align 165 // PATTERN-O1-NOT: @__const.test_base_uninit.uninit 166 // PATTERN-O0: @__const.test_base_braces.braces = private unnamed_addr constant %struct.base { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) }, align 167 // PATTERN-O1-NOT: @__const.test_base_braces.braces 168 struct base { virtual ~base(); }; 169 // PATTERN-O0: @__const.test_derived_uninit.uninit = private unnamed_addr constant %struct.derived { %struct.base { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) } }, align 170 // PATTERN-O1-NOT: @__const.test_derived_uninit.uninit 171 // PATTERN-O0: @__const.test_derived_braces.braces = private unnamed_addr constant %struct.derived { %struct.base { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) } }, align 172 // PATTERN-O1-NOT: @__const.test_derived_braces.braces 173 struct derived : public base {}; 174 // PATTERN-O0: @__const.test_virtualderived_uninit.uninit = private unnamed_addr constant %struct.virtualderived { %struct.base { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) }, %struct.derived { %struct.base { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) } } }, align 175 // PATTERN-O1-NOT: @__const.test_virtualderived_uninit.uninit 176 // PATTERN-O0: @__const.test_virtualderived_braces.braces = private unnamed_addr constant %struct.virtualderived { %struct.base { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) }, %struct.derived { %struct.base { ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr) } } }, align 177 // PATTERN-O1-NOT: @__const.test_virtualderived_braces.braces 178 struct virtualderived : public virtual base, public virtual derived {}; 179 // PATTERN-O0: @__const.test_matching_uninit.uninit = private unnamed_addr constant %union.matching { i32 [[I32]] }, align 4 180 // PATTERN-O1-NOT: @__const.test_matching_uninit.uninit 181 // PATTERN-O0: @__const.test_matching_custom.custom = private unnamed_addr constant { float } { float 6.145500e+04 }, align 4 182 // PATTERN-O1-NOT: @__const.test_matching_custom.custom 183 // ZERO-O0: @__const.test_matching_custom.custom = private unnamed_addr constant { float } { float 6.145500e+04 }, align 4 184 // ZERO-O1-NOT: @__const.test_matching_custom.custom 185 union matching { int i; float f; }; 186 // PATTERN-O0: @__const.test_matchingreverse_uninit.uninit = private unnamed_addr constant %union.matchingreverse { float 0xFFFFFFFFE0000000 }, align 4 187 // PATTERN-O1-NOT: @__const.test_matchingreverse_uninit.uninit 188 // PATTERN-O0: @__const.test_matchingreverse_custom.custom = private unnamed_addr constant { i32 } { i32 61455 }, align 4 189 // PATTERN-O1-NOT: @__const.test_matchingreverse_custom.custom 190 // ZERO-O0: @__const.test_matchingreverse_custom.custom = private unnamed_addr constant { i32 } { i32 61455 }, align 4 191 // ZERO-O1-NOT: @__const.test_matchingreverse_custom.custom 192 union matchingreverse { float f; int i; }; 193 // PATTERN-O0: @__const.test_unmatched_uninit.uninit = private unnamed_addr constant %union.unmatched { i32 [[I32]] }, align 4 194 // PATTERN-O1-NOT: @__const.test_unmatched_uninit.uninit 195 // PATTERN-O0: @__const.test_unmatched_custom.custom = private unnamed_addr constant %union.unmatched { i32 1001242351 }, align 4 196 // PATTERN-O1-NOT: @__const.test_unmatched_custom.custom 197 // ZERO-O0: @__const.test_unmatched_custom.custom = private unnamed_addr constant %union.unmatched { i32 1001242351 }, align 4 198 // ZERO-O1-NOT: @__const.test_unmatched_custom.custom 199 union unmatched { char c; int i; }; 200 // PATTERN-O0: @__const.test_unmatchedreverse_uninit.uninit = private unnamed_addr constant %union.unmatchedreverse { i32 [[I32]] }, align 4 201 // PATTERN-O1-NOT: @__const.test_unmatchedreverse_uninit.uninit 202 // PATTERN-O0: @__const.test_unmatchedreverse_custom.custom = private unnamed_addr constant { i8, [3 x i8] } { i8 42, [3 x i8] c"\[[IC]]\[[IC]]\[[IC]]" }, align 4 203 // PATTERN-O1-NOT: @__const.test_unmatchedreverse_custom.custom 204 // ZERO-O0: @__const.test_unmatchedreverse_custom.custom = private unnamed_addr constant { i8, [3 x i8] } { i8 42, [3 x i8] zeroinitializer }, align 4 205 // ZERO-O1-NOT: @__const.test_unmatchedreverse_custom.custom 206 union unmatchedreverse { int i; char c; }; 207 // PATTERN-O0: @__const.test_unmatchedfp_uninit.uninit = private unnamed_addr constant %union.unmatchedfp { double 0xFFFFFFFFFFFFFFFF }, align 208 // PATTERN-O1-NOT: @__const.test_unmatchedfp_uninit.uninit 209 // PATTERN-O0: @__const.test_unmatchedfp_custom.custom = private unnamed_addr constant %union.unmatchedfp { double 0x400921FB54442D18 }, align 210 // PATTERN-O1-NOT: @__const.test_unmatchedfp_custom.custom 211 // ZERO-O0: @__const.test_unmatchedfp_custom.custom = private unnamed_addr constant %union.unmatchedfp { double 0x400921FB54442D18 }, align 8 212 // ZERO-O1-NOT: @__const.test_unmatchedfp_custom.custom 213 union unmatchedfp { float f; double d; }; 214 enum emptyenum {}; 215 enum smallenum { VALUE }; 216 217 extern "C" { 218 219 TEST_UNINIT(char, char); 220 // CHECK-LABEL: @test_char_uninit() 221 // CHECK: %uninit = alloca i8, align 222 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 223 // PATTERN-LABEL: @test_char_uninit() 224 // PATTERN: store i8 [[I8]], ptr %uninit, align 1, !annotation [[AUTO_INIT:!.+]] 225 // ZERO-LABEL: @test_char_uninit() 226 // ZERO: store i8 0, ptr %uninit, align 1, !annotation [[AUTO_INIT:!.+]] 227 228 TEST_BRACES(char, char); 229 // CHECK-LABEL: @test_char_braces() 230 // CHECK: %braces = alloca i8, align [[ALIGN:[0-9]*]] 231 // CHECK-NEXT: store i8 0, ptr %braces, align [[ALIGN]] 232 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 233 234 TEST_UNINIT(uchar, unsigned char); 235 // CHECK-LABEL: @test_uchar_uninit() 236 // CHECK: %uninit = alloca i8, align 237 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 238 // PATTERN-LABEL: @test_uchar_uninit() 239 // PATTERN: store i8 [[I8]], ptr %uninit, align 1, !annotation [[AUTO_INIT]] 240 // ZERO-LABEL: @test_uchar_uninit() 241 // ZERO: store i8 0, ptr %uninit, align 1, !annotation [[AUTO_INIT]] 242 243 TEST_BRACES(uchar, unsigned char); 244 // CHECK-LABEL: @test_uchar_braces() 245 // CHECK: %braces = alloca i8, align [[ALIGN:[0-9]*]] 246 // CHECK-NEXT: store i8 0, ptr %braces, align [[ALIGN]] 247 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 248 249 TEST_UNINIT(schar, signed char); 250 // CHECK-LABEL: @test_schar_uninit() 251 // CHECK: %uninit = alloca i8, align 252 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 253 // PATTERN-LABEL: @test_schar_uninit() 254 // PATTERN: store i8 [[I8]], ptr %uninit, align 1, !annotation [[AUTO_INIT]] 255 // ZERO-LABEL: @test_schar_uninit() 256 // ZERO: store i8 0, ptr %uninit, align 1, !annotation [[AUTO_INIT]] 257 258 TEST_BRACES(schar, signed char); 259 // CHECK-LABEL: @test_schar_braces() 260 // CHECK: %braces = alloca i8, align [[ALIGN:[0-9]*]] 261 // CHECK-NEXT: store i8 0, ptr %braces, align [[ALIGN]] 262 // CHECK-NOT: !annotation 263 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 264 265 TEST_UNINIT(wchar_t, wchar_t); 266 // CHECK-LABEL: @test_wchar_t_uninit() 267 // CHECK: %uninit = alloca i32, align 268 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 269 // PATTERN-LABEL: @test_wchar_t_uninit() 270 // PATTERN: store i32 [[I32]], ptr %uninit, align 4, !annotation [[AUTO_INIT]] 271 // ZERO-LABEL: @test_wchar_t_uninit() 272 // ZERO: store i32 0, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 273 274 TEST_BRACES(wchar_t, wchar_t); 275 // CHECK-LABEL: @test_wchar_t_braces() 276 // CHECK: %braces = alloca i32, align [[ALIGN:[0-9]*]] 277 // CHECK-NEXT: store i32 0, ptr %braces, align [[ALIGN]] 278 // CHECK-NOT: !annotation 279 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 280 281 TEST_UNINIT(short, short); 282 // CHECK-LABEL: @test_short_uninit() 283 // CHECK: %uninit = alloca i16, align 284 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 285 // PATTERN-LABEL: @test_short_uninit() 286 // PATTERN: store i16 [[I16]], ptr %uninit, align 2, !annotation [[AUTO_INIT]] 287 // ZERO-LABEL: @test_short_uninit() 288 // ZERO: store i16 0, ptr %uninit, align 2, !annotation [[AUTO_INIT]] 289 290 TEST_BRACES(short, short); 291 // CHECK-LABEL: @test_short_braces() 292 // CHECK: %braces = alloca i16, align [[ALIGN:[0-9]*]] 293 // CHECK-NEXT: store i16 0, ptr %braces, align [[ALIGN]] 294 // CHECK-NOT: !annotation 295 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 296 297 TEST_UNINIT(ushort, unsigned short); 298 // CHECK-LABEL: @test_ushort_uninit() 299 // CHECK: %uninit = alloca i16, align 300 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 301 // PATTERN-LABEL: @test_ushort_uninit() 302 // PATTERN: store i16 [[I16]], ptr %uninit, align 2, !annotation [[AUTO_INIT]] 303 // ZERO-LABEL: @test_ushort_uninit() 304 // ZERO: store i16 0, ptr %uninit, align 2, !annotation [[AUTO_INIT]] 305 306 TEST_BRACES(ushort, unsigned short); 307 // CHECK-LABEL: @test_ushort_braces() 308 // CHECK: %braces = alloca i16, align [[ALIGN:[0-9]*]] 309 // CHECK-NEXT: store i16 0, ptr %braces, align [[ALIGN]] 310 //CHECK-NOT: !annotation 311 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 312 313 TEST_UNINIT(int, int); 314 // CHECK-LABEL: @test_int_uninit() 315 // CHECK: %uninit = alloca i32, align 316 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 317 // PATTERN-LABEL: @test_int_uninit() 318 // PATTERN: store i32 [[I32]], ptr %uninit, align 4, !annotation [[AUTO_INIT]] 319 // ZERO-LABEL: @test_int_uninit() 320 // ZERO: store i32 0, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 321 322 TEST_BRACES(int, int); 323 // CHECK-LABEL: @test_int_braces() 324 // CHECK: %braces = alloca i32, align [[ALIGN:[0-9]*]] 325 // CHECK-NEXT: store i32 0, ptr %braces, align [[ALIGN]] 326 // CHECK-NOT: !annotation 327 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 328 329 TEST_UNINIT(unsigned, unsigned); 330 // CHECK-LABEL: @test_unsigned_uninit() 331 // CHECK: %uninit = alloca i32, align 332 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 333 // PATTERN-LABEL: @test_unsigned_uninit() 334 // PATTERN: store i32 [[I32]], ptr %uninit, align 4, !annotation [[AUTO_INIT]] 335 // ZERO-LABEL: @test_unsigned_uninit() 336 // ZERO: store i32 0, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 337 338 TEST_BRACES(unsigned, unsigned); 339 // CHECK-LABEL: @test_unsigned_braces() 340 // CHECK: %braces = alloca i32, align [[ALIGN:[0-9]*]] 341 // CHECK-NEXT: store i32 0, ptr %braces, align [[ALIGN]] 342 // CHECK-NOT: !annotation 343 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 344 345 TEST_UNINIT(long, long); 346 // CHECK-LABEL: @test_long_uninit() 347 // CHECK: %uninit = alloca i64, align 348 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 349 // PATTERN-LABEL: @test_long_uninit() 350 // PATTERN: store [[ILONGT]] [[ILONG]], ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 351 // ZERO-LABEL: @test_long_uninit() 352 // ZERO: store i64 0, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 353 354 TEST_BRACES(long, long); 355 // CHECK-LABEL: @test_long_braces() 356 // CHECK: %braces = alloca i64, align [[ALIGN:[0-9]*]] 357 // CHECK-NEXT: store i64 0, ptr %braces, align [[ALIGN]] 358 // CHECK-NOT: !annotation 359 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 360 361 TEST_UNINIT(ulong, unsigned long); 362 // CHECK-LABEL: @test_ulong_uninit() 363 // CHECK: %uninit = alloca i64, align 364 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 365 // PATTERN-LABEL: @test_ulong_uninit() 366 // PATTERN: store [[ILONGT]] [[ILONG]], ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 367 // ZERO-LABEL: @test_ulong_uninit() 368 // ZERO: store i64 0, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 369 370 TEST_BRACES(ulong, unsigned long); 371 // CHECK-LABEL: @test_ulong_braces() 372 // CHECK: %braces = alloca i64, align [[ALIGN:[0-9]*]] 373 // CHECK-NEXT: store i64 0, ptr %braces, align [[ALIGN]] 374 // CHECK-NOT: !annotation 375 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 376 377 TEST_UNINIT(longlong, long long); 378 // CHECK-LABEL: @test_longlong_uninit() 379 // CHECK: %uninit = alloca i64, align 380 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 381 // PATTERN-LABEL: @test_longlong_uninit() 382 // PATTERN: store i64 [[I64]], ptr %uninit, align 8, !annotation [[AUTO_INIT]] 383 // ZERO-LABEL: @test_longlong_uninit() 384 // ZERO: store i64 0, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 385 386 TEST_BRACES(longlong, long long); 387 // CHECK-LABEL: @test_longlong_braces() 388 // CHECK: %braces = alloca i64, align [[ALIGN:[0-9]*]] 389 // CHECK-NEXT: store i64 0, ptr %braces, align [[ALIGN]] 390 // CHECK-NOT: !annotation 391 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 392 393 TEST_UNINIT(ulonglong, unsigned long long); 394 // CHECK-LABEL: @test_ulonglong_uninit() 395 // CHECK: %uninit = alloca i64, align 396 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 397 // PATTERN-LABEL: @test_ulonglong_uninit() 398 // PATTERN: store i64 [[I64]], ptr %uninit, align 8, !annotation [[AUTO_INIT]] 399 // ZERO-LABEL: @test_ulonglong_uninit() 400 // ZERO: store i64 0, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 401 402 TEST_BRACES(ulonglong, unsigned long long); 403 // CHECK-LABEL: @test_ulonglong_braces() 404 // CHECK: %braces = alloca i64, align [[ALIGN:[0-9]*]] 405 // CHECK-NEXT: store i64 0, ptr %braces, align [[ALIGN]] 406 // CHECK-NOT: !annotation 407 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 408 409 TEST_UNINIT(int128, __int128); 410 // CHECK-LABEL: @test_int128_uninit() 411 // CHECK: %uninit = alloca i128, align 412 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 413 // PATTERN-LABEL: @test_int128_uninit() 414 // PATTERN: store [[I128T]] [[I128]], ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 415 // ZERO-LABEL: @test_int128_uninit() 416 // ZERO: store i128 0, ptr %uninit, align 16, !annotation [[AUTO_INIT]] 417 418 TEST_BRACES(int128, __int128); 419 // CHECK-LABEL: @test_int128_braces() 420 // CHECK: %braces = alloca i128, align [[ALIGN:[0-9]*]] 421 // CHECK-NEXT: store i128 0, ptr %braces, align [[ALIGN]] 422 // CHECK-NOT: !annotation 423 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 424 425 TEST_UNINIT(uint128, unsigned __int128); 426 // CHECK-LABEL: @test_uint128_uninit() 427 // CHECK: %uninit = alloca i128, align 428 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 429 // PATTERN-LABEL: @test_uint128_uninit() 430 // PATTERN: store [[I128T]] [[I128]], ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 431 // ZERO-LABEL: @test_uint128_uninit() 432 // ZERO: store i128 0, ptr %uninit, align 16, !annotation [[AUTO_INIT]] 433 434 TEST_BRACES(uint128, unsigned __int128); 435 // CHECK-LABEL: @test_uint128_braces() 436 // CHECK: %braces = alloca i128, align [[ALIGN:[0-9]*]] 437 // CHECK-NEXT: store i128 0, ptr %braces, align [[ALIGN]] 438 // CHECK-NOT: !annotation 439 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 440 441 TEST_UNINIT(fp16, __fp16); 442 // CHECK-LABEL: @test_fp16_uninit() 443 // CHECK: %uninit = alloca half, align 444 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 445 // PATTERN-LABEL: @test_fp16_uninit() 446 // PATTERN: store half 0xHFFFF, ptr %uninit, align 2, !annotation [[AUTO_INIT]] 447 // ZERO-LABEL: @test_fp16_uninit() 448 // ZERO: store half 0xH0000, ptr %uninit, align 2, !annotation [[AUTO_INIT]] 449 450 TEST_BRACES(fp16, __fp16); 451 // CHECK-LABEL: @test_fp16_braces() 452 // CHECK: %braces = alloca half, align [[ALIGN:[0-9]*]] 453 // CHECK-NEXT: store half 0xH0000, ptr %braces, align [[ALIGN]] 454 // CHECK-NOT: !annotation 455 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 456 457 TEST_UNINIT(float, float); 458 // CHECK-LABEL: @test_float_uninit() 459 // CHECK: %uninit = alloca float, align 460 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 461 // PATTERN-LABEL: @test_float_uninit() 462 // PATTERN: store float 0xFFFFFFFFE0000000, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 463 // ZERO-LABEL: @test_float_uninit() 464 // ZERO: store float 0.000000e+00, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 465 466 TEST_BRACES(float, float); 467 // CHECK-LABEL: @test_float_braces() 468 // CHECK: %braces = alloca float, align [[ALIGN:[0-9]*]] 469 // CHECK-NEXT: store float 0.000000e+00, ptr %braces, align [[ALIGN]] 470 // CHECK-NOT: !annotation 471 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 472 473 TEST_UNINIT(double, double); 474 // CHECK-LABEL: @test_double_uninit() 475 // CHECK: %uninit = alloca double, align 476 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 477 // PATTERN-LABEL: @test_double_uninit() 478 // PATTERN: store double 0xFFFFFFFFFFFFFFFF, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 479 // ZERO-LABEL: @test_double_uninit() 480 // ZERO: store double 0.000000e+00, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 481 482 TEST_BRACES(double, double); 483 // CHECK-LABEL: @test_double_braces() 484 // CHECK: %braces = alloca double, align [[ALIGN:[0-9]*]] 485 // CHECK-NEXT: store double 0.000000e+00, ptr %braces, align [[ALIGN]] 486 // CHECK-NOT: !annotation 487 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 488 489 TEST_UNINIT(longdouble, long double); 490 // CHECK-LABEL: @test_longdouble_uninit() 491 // CHECK: %uninit = alloca x86_fp80, align 492 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 493 // PATTERN-LABEL: @test_longdouble_uninit() 494 // PATTERN: store x86_fp80 0xKFFFFFFFFFFFFFFFFFFFF, ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 495 // ZERO-LABEL: @test_longdouble_uninit() 496 // ZERO: store x86_fp80 0xK00000000000000000000, ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 497 498 TEST_BRACES(longdouble, long double); 499 // CHECK-LABEL: @test_longdouble_braces() 500 // CHECK: %braces = alloca x86_fp80, align [[ALIGN:[0-9]*]] 501 // CHECK-NEXT: store x86_fp80 0xK00000000000000000000, ptr %braces, align [[ALIGN]] 502 // CHECK-NOT: !annotation 503 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 504 505 TEST_UNINIT(intptr, int*); 506 // CHECK-LABEL: @test_intptr_uninit() 507 // CHECK: %uninit = alloca ptr, align 508 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 509 // PATTERN-LABEL: @test_intptr_uninit() 510 // PATTERN: store ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr), ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 511 // ZERO-LABEL: @test_intptr_uninit() 512 // ZERO: store ptr null, ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 513 514 TEST_BRACES(intptr, int*); 515 // CHECK-LABEL: @test_intptr_braces() 516 // CHECK: %braces = alloca ptr, align [[ALIGN:[0-9]*]] 517 // CHECK-NEXT: store ptr null, ptr %braces, align [[ALIGN]] 518 // CHECK-NOT: !annotation 519 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 520 521 TEST_UNINIT(intptrptr, int**); 522 // CHECK-LABEL: @test_intptrptr_uninit() 523 // CHECK: %uninit = alloca ptr, align 524 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 525 // PATTERN-LABEL: @test_intptrptr_uninit() 526 // PATTERN: store ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr), ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 527 // ZERO-LABEL: @test_intptrptr_uninit() 528 // ZERO: store ptr null, ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 529 530 TEST_BRACES(intptrptr, int**); 531 // CHECK-LABEL: @test_intptrptr_braces() 532 // CHECK: %braces = alloca ptr, align [[ALIGN:[0-9]*]] 533 // CHECK-NEXT: store ptr null, ptr %braces, align [[ALIGN]] 534 // CHECK-NOT: !annotation 535 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 536 537 TEST_UNINIT(function, void(*)()); 538 // CHECK-LABEL: @test_function_uninit() 539 // CHECK: %uninit = alloca ptr, align 540 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 541 // PATTERN-LABEL: @test_function_uninit() 542 // PATTERN: store ptr inttoptr ([[IPTRT]] [[IPTR]] to ptr), ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 543 // ZERO-LABEL: @test_function_uninit() 544 // ZERO: store ptr null, ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 545 546 TEST_BRACES(function, void(*)()); 547 // CHECK-LABEL: @test_function_braces() 548 // CHECK: %braces = alloca ptr, align [[ALIGN:[0-9]*]] 549 // CHECK-NEXT: store ptr null, ptr %braces, align [[ALIGN]] 550 // CHECK-NOT: !annotation 551 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 552 553 TEST_UNINIT(bool, bool); 554 // CHECK-LABEL: @test_bool_uninit() 555 // CHECK: %uninit = alloca i8, align 556 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 557 // PATTERN-LABEL: @test_bool_uninit() 558 // PATTERN: store i8 [[I8]], ptr %uninit, align 1, !annotation [[AUTO_INIT]] 559 // ZERO-LABEL: @test_bool_uninit() 560 // ZERO: store i8 0, ptr %uninit, align 1, !annotation [[AUTO_INIT]] 561 562 TEST_BRACES(bool, bool); 563 // CHECK-LABEL: @test_bool_braces() 564 // CHECK: %braces = alloca i8, align [[ALIGN:[0-9]*]] 565 // CHECK-NEXT: store i8 0, ptr %braces, align [[ALIGN]] 566 // CHECK-NOT: !annotation 567 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 568 569 TEST_UNINIT(empty, empty); 570 // CHECK-LABEL: @test_empty_uninit() 571 // CHECK: %uninit = alloca %struct.empty, align 572 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 573 // PATTERN-LABEL: @test_empty_uninit() 574 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_empty_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 575 // PATTERN-O1: store i8 [[I8]], {{.*}} align 1, !annotation [[AUTO_INIT]] 576 // ZERO-LABEL: @test_empty_uninit() 577 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 578 // ZERO-O1: store i8 0, {{.*}} align 1, !annotation [[AUTO_INIT]] 579 580 TEST_BRACES(empty, empty); 581 // CHECK-LABEL: @test_empty_braces() 582 // CHECK: %braces = alloca %struct.empty, align 583 // CHECK-NEXT: call void @llvm.memcpy 584 // CHECK-NOT: !annotation 585 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 586 587 TEST_UNINIT(small, small); 588 // CHECK-LABEL: @test_small_uninit() 589 // CHECK: %uninit = alloca %struct.small, align 590 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 591 // PATTERN-LABEL: @test_small_uninit() 592 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_small_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 593 // PATTERN-O1: store i8 [[I8]], {{.*}} align 1, !annotation [[AUTO_INIT]] 594 // ZERO-LABEL: @test_small_uninit() 595 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 596 // ZERO-O1: store i8 0, {{.*}} align 1, !annotation [[AUTO_INIT]] 597 598 TEST_BRACES(small, small); 599 // CHECK-LABEL: @test_small_braces() 600 // CHECK: %braces = alloca %struct.small, align [[ALIGN:[0-9]*]] 601 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 1, i1 false) 602 // CHECK-NOT: !annotation 603 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 604 605 TEST_CUSTOM(small, small, { 42 }); 606 // CHECK-LABEL: @test_small_custom() 607 // CHECK: %custom = alloca %struct.small, align 608 // CHECK-NEXT: call void @llvm.memcpy 609 // CHECK-NOT: !annotation 610 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 611 612 TEST_UNINIT(smallinit, smallinit); 613 // CHECK-LABEL: @test_smallinit_uninit() 614 // CHECK: %uninit = alloca %struct.smallinit, align 615 // CHECK-NEXT: call void @{{.*}}smallinit{{.*}}%uninit) 616 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 617 618 TEST_BRACES(smallinit, smallinit); 619 // CHECK-LABEL: @test_smallinit_braces() 620 // CHECK: %braces = alloca %struct.smallinit, align [[ALIGN:[0-9]*]] 621 // CHECK-NEXT: %[[C:[^ ]*]] = getelementptr inbounds nuw %struct.smallinit, ptr %braces, i32 0, i32 0 622 // CHECK-NEXT: store i8 42, ptr %[[C]], align [[ALIGN]] 623 // CHECK-NOT: !annotation 624 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 625 626 TEST_CUSTOM(smallinit, smallinit, { 100 }); 627 // CHECK-LABEL: @test_smallinit_custom() 628 // CHECK: %custom = alloca %struct.smallinit, align [[ALIGN:[0-9]*]] 629 // CHECK-NEXT: %[[C:[^ ]*]] = getelementptr inbounds nuw %struct.smallinit, ptr %custom, i32 0, i32 0 630 // CHECK-NEXT: store i8 100, ptr %[[C]], align [[ALIGN]] 631 // CHECK-NOT: !annotation 632 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 633 634 TEST_UNINIT(smallpartinit, smallpartinit); 635 // CHECK-LABEL: @test_smallpartinit_uninit() 636 // CHECK: %uninit = alloca %struct.smallpartinit, align 637 // CHECK-NEXT: call void @{{.*}}smallpartinit{{.*}}%uninit) 638 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 639 // PATTERN-LABEL: @test_smallpartinit_uninit() 640 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_smallpartinit_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 641 // PATTERN-O1: store i8 [[I8]], {{.*}} align 1, !annotation [[AUTO_INIT]] 642 // PATTERN-O1: store i8 42, {{.*}} align 1 643 // ZERO-LABEL: @test_smallpartinit_uninit() 644 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 645 // ZERO-O1: store i16 0, ptr %uninit, align 2, !annotation [[AUTO_INIT]] 646 647 TEST_BRACES(smallpartinit, smallpartinit); 648 // CHECK-LABEL: @test_smallpartinit_braces() 649 // CHECK: %braces = alloca %struct.smallpartinit, align [[ALIGN:[0-9]*]] 650 // CHECK-NEXT: %[[C:[^ ]*]] = getelementptr inbounds nuw %struct.smallpartinit, ptr %braces, i32 0, i32 0 651 // CHECK-NEXT: store i8 42, ptr %[[C]], align [[ALIGN]] 652 // CHECK-NOT: !annotation 653 // CHECK-NEXT: %[[D:[^ ]*]] = getelementptr inbounds nuw %struct.smallpartinit, ptr %braces, i32 0, i32 1 654 // CHECK-NEXT: store i8 0, ptr %[[D]], align [[ALIGN]] 655 // CHECK-NOT: !annotation 656 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 657 658 TEST_CUSTOM(smallpartinit, smallpartinit, { 100, 42 }); 659 // CHECK-LABEL: @test_smallpartinit_custom() 660 // CHECK: %custom = alloca %struct.smallpartinit, align [[ALIGN:[0-9]*]] 661 // CHECK-NEXT: %[[C:[^ ]*]] = getelementptr inbounds nuw %struct.smallpartinit, ptr %custom, i32 0, i32 0 662 // CHECK-NEXT: store i8 100, ptr %[[C]], align [[ALIGN]] 663 // CHECK-NOT: !annotation 664 // CHECK-NEXT: %[[D:[^ ]*]] = getelementptr inbounds nuw %struct.smallpartinit, ptr %custom, i32 0, i32 1 665 // CHECK-NEXT: store i8 42, ptr %[[D]], align [[ALIGN]] 666 // CHECK-NOT: !annotation 667 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 668 669 TEST_UNINIT(nullinit, nullinit); 670 // CHECK-LABEL: @test_nullinit_uninit() 671 // CHECK: %uninit = alloca %struct.nullinit, align 672 // CHECK-NEXT: call void @{{.*}}nullinit{{.*}}%uninit) 673 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 674 675 TEST_BRACES(nullinit, nullinit); 676 // CHECK-LABEL: @test_nullinit_braces() 677 // CHECK: %braces = alloca %struct.nullinit, align [[ALIGN:[0-9]*]] 678 // CHECK-NEXT: %[[N:[^ ]*]] = getelementptr inbounds nuw %struct.nullinit, ptr %braces, i32 0, i32 0 679 // CHECK-NEXT: store ptr null, ptr %[[N]], align [[ALIGN]] 680 // CHECK-NOT: !annotation 681 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 682 683 TEST_CUSTOM(nullinit, nullinit, { (char*)"derp" }); 684 // CHECK-LABEL: @test_nullinit_custom() 685 // CHECK: %custom = alloca %struct.nullinit, align [[ALIGN:[0-9]*]] 686 // CHECK-NEXT: %[[N:[^ ]*]] = getelementptr inbounds nuw %struct.nullinit, ptr %custom, i32 0, i32 0 687 // CHECK-NEXT: store ptr {{.*}}, ptr %[[N]], align [[ALIGN]] 688 // CHECK-NOT: !annotation 689 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 690 691 TEST_UNINIT(padded, padded); 692 // CHECK-LABEL: @test_padded_uninit() 693 // CHECK: %uninit = alloca %struct.padded, align 694 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 695 // PATTERN-LABEL: @test_padded_uninit() 696 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_padded_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 697 // PATTERN-O1: store i64 [[I64]], ptr %uninit, align 8 698 // PATTERN-O1-NOT: !annotation 699 // ZERO-LABEL: @test_padded_uninit() 700 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 701 // ZERO-O1: store i64 0, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 702 703 TEST_BRACES(padded, padded); 704 // CHECK-LABEL: @test_padded_braces() 705 // CHECK: %braces = alloca %struct.padded, align [[ALIGN:[0-9]*]] 706 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 8, i1 false) 707 // CHECK-NOT: !annotation 708 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 709 710 TEST_CUSTOM(padded, padded, { 42, 13371337 }); 711 // CHECK-LABEL: @test_padded_custom() 712 // CHECK: %custom = alloca %struct.padded, align 713 // CHECK-NEXT: call void @llvm.memcpy 714 // CHECK-NOT: !annotation 715 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 716 717 TEST_UNINIT(paddednullinit, paddednullinit); 718 // CHECK-LABEL: @test_paddednullinit_uninit() 719 // CHECK: %uninit = alloca %struct.paddednullinit, align 720 // CHECK-NEXT: call void @{{.*}}paddednullinit{{.*}}%uninit) 721 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 722 // PATTERN-LABEL: @test_paddednullinit_uninit() 723 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_paddednullinit_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 724 // PATTERN-O1: store i64 [[I64]], ptr %uninit, align 8 725 // PATTERN-O1-NOT: !annotation 726 // ZERO-LABEL: @test_paddednullinit_uninit() 727 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0, {{.*}}, !annotation [[AUTO_INIT]] 728 // ZERO-O1: store i64 0, ptr %uninit, align 8 729 // FIXME: !annotation dropped by optimizations 730 // ZERO-O1-NOT: !annotation 731 // ZERO: ret 732 733 734 TEST_BRACES(paddednullinit, paddednullinit); 735 // CHECK-LABEL: @test_paddednullinit_braces() 736 // CHECK: %braces = alloca %struct.paddednullinit, align [[ALIGN:[0-9]*]] 737 // CHECK-NEXT: %[[C:[^ ]*]] = getelementptr inbounds nuw %struct.paddednullinit, ptr %braces, i32 0, i32 0 738 // CHECK-NEXT: store i8 0, ptr %[[C]], align [[ALIGN]] 739 // CHECK-NOT: !annotation 740 // CHECK-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw %struct.paddednullinit, ptr %braces, i32 0, i32 1 741 // CHECK-NEXT: store i32 0, ptr %[[I]], align [[ALIGN]] 742 // CHECK-NOT: !annotation 743 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 744 745 TEST_CUSTOM(paddednullinit, paddednullinit, { 42, 13371337 }); 746 // CHECK-LABEL: @test_paddednullinit_custom() 747 // CHECK: %custom = alloca %struct.paddednullinit, align [[ALIGN:[0-9]*]] 748 // CHECK-NEXT: %[[C:[^ ]*]] = getelementptr inbounds nuw %struct.paddednullinit, ptr %custom, i32 0, i32 0 749 // CHECK-NEXT: store i8 42, ptr %[[C]], align [[ALIGN]] 750 // CHECK-NOT: !annotation 751 // CHECK-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw %struct.paddednullinit, ptr %custom, i32 0, i32 1 752 // CHECK-NEXT: store i32 13371337, ptr %[[I]], align [[ALIGN]] 753 // CHECK-NOT: !annotation 754 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 755 756 TEST_UNINIT(paddedpacked, paddedpacked); 757 // CHECK-LABEL: @test_paddedpacked_uninit() 758 // CHECK: %uninit = alloca %struct.paddedpacked, align 759 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 760 // PATTERN-LABEL: @test_paddedpacked_uninit() 761 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_paddedpacked_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 762 // PATTERN-O1: store i8 [[I8]], ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 763 // PATTERN-O1: %[[I:[^ ]*]] = getelementptr inbounds {{.*}}%uninit, i64 1 764 // PATTERN-O1: store i32 [[I32]], ptr %[[I]], align {{.+}}, !annotation [[AUTO_INIT]] 765 // ZERO-LABEL: @test_paddedpacked_uninit() 766 // ZERO: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 767 768 TEST_BRACES(paddedpacked, paddedpacked); 769 // CHECK-LABEL: @test_paddedpacked_braces() 770 // CHECK: %braces = alloca %struct.paddedpacked, align [[ALIGN:[0-9]*]] 771 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 5, i1 false) 772 // CHECK-NOT: !annotation 773 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 774 775 TEST_CUSTOM(paddedpacked, paddedpacked, { 42, 13371337 }); 776 // CHECK-LABEL: @test_paddedpacked_custom() 777 // CHECK: %custom = alloca %struct.paddedpacked, align 778 // CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddedpacked_custom.custom 779 // CHECK-NOT: !annotation 780 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 781 782 TEST_UNINIT(paddedpackedarray, paddedpackedarray); 783 // CHECK-LABEL: @test_paddedpackedarray_uninit() 784 // CHECK: %uninit = alloca %struct.paddedpackedarray, align 785 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 786 // PATTERN-LABEL: @test_paddedpackedarray_uninit() 787 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_paddedpackedarray_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 788 // PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}i8 [[I8]], i64 10 789 // FIXME: !annotation dropped by optimizations 790 // PATTERN-O1-NOT: !annotation 791 // ZERO-LABEL: @test_paddedpackedarray_uninit() 792 // ZERO: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 793 794 TEST_BRACES(paddedpackedarray, paddedpackedarray); 795 // CHECK-LABEL: @test_paddedpackedarray_braces() 796 // CHECK: %braces = alloca %struct.paddedpackedarray, align [[ALIGN:[0-9]*]] 797 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 10, i1 false) 798 // CHECK-NOT: !annotation 799 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 800 801 TEST_CUSTOM(paddedpackedarray, paddedpackedarray, { {{ 42, 13371337 }, { 43, 13371338 }} }); 802 // CHECK-LABEL: @test_paddedpackedarray_custom() 803 // CHECK: %custom = alloca %struct.paddedpackedarray, align 804 // CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddedpackedarray_custom.custom 805 // CHECK-NOT: !annotation 806 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 807 808 TEST_UNINIT(unpackedinpacked, unpackedinpacked); 809 // PATTERN-LABEL: @test_unpackedinpacked_uninit() 810 // PATTERN-O0: call void @llvm.memcpy{{.*}} 9, i1 false), !annotation [[AUTO_INIT]] 811 812 TEST_UNINIT(paddednested, paddednested); 813 // CHECK-LABEL: @test_paddednested_uninit() 814 // CHECK: %uninit = alloca %struct.paddednested, align 815 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 816 // PATTERN-LABEL: @test_paddednested_uninit() 817 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_paddednested_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 818 // PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}, i8 [[I8]], i64 16{{.+}}) 819 // FIXME: !annotation dropped by optimizations 820 // PATTERN-O1-NOT: !annotation 821 // ZERO-LABEL: @test_paddednested_uninit() 822 // ZERO: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 823 824 TEST_BRACES(paddednested, paddednested); 825 // CHECK-LABEL: @test_paddednested_braces() 826 // CHECK: %braces = alloca %struct.paddednested, align [[ALIGN:[0-9]*]] 827 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 16, i1 false) 828 // CHECK-NOT: !annotation 829 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 830 831 TEST_CUSTOM(paddednested, paddednested, { { 42, 13371337 }, { 43, 13371338 } }); 832 // CHECK-LABEL: @test_paddednested_custom() 833 // CHECK: %custom = alloca %struct.paddednested, align 834 // CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddednested_custom.custom 835 // CHECK-NOT: !annotation 836 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 837 838 TEST_UNINIT(paddedpackednested, paddedpackednested); 839 // CHECK-LABEL: @test_paddedpackednested_uninit() 840 // CHECK: %uninit = alloca %struct.paddedpackednested, align 841 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 842 // PATTERN-LABEL: @test_paddedpackednested_uninit() 843 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_paddedpackednested_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 844 // PATTERN-O1: call void @llvm.memset.p0.i64(ptr noundef nonnull align 1 dereferenceable(10) %uninit, i8 [[I8]], i64 10, i1 false) 845 // FIXME: !annotation dropped by optimizations 846 // PATTERN-O1-NOT: !annotation 847 // ZERO-LABEL: @test_paddedpackednested_uninit() 848 // ZERO: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 849 850 TEST_BRACES(paddedpackednested, paddedpackednested); 851 // CHECK-LABEL: @test_paddedpackednested_braces() 852 // CHECK: %braces = alloca %struct.paddedpackednested, align [[ALIGN:[0-9]*]] 853 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 10, i1 false) 854 // CHECK-NOT: !annotation 855 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 856 857 TEST_CUSTOM(paddedpackednested, paddedpackednested, { { 42, 13371337 }, { 43, 13371338 } }); 858 // CHECK-LABEL: @test_paddedpackednested_custom() 859 // CHECK: %custom = alloca %struct.paddedpackednested, align 860 // CHECK-NEXT: call void @llvm.memcpy{{.*}}({{.*}}@__const.test_paddedpackednested_custom.custom 861 // CHECK-NOT: !annotation 862 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 863 864 TEST_UNINIT(bitfield, bitfield); 865 // CHECK-LABEL: @test_bitfield_uninit() 866 // CHECK: %uninit = alloca %struct.bitfield, align 867 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 868 // PATTERN-LABEL: @test_bitfield_uninit() 869 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_bitfield_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 870 // PATTERN-O1: store i32 [[I32]], ptr %uninit, align 4 871 // FIXME: !annotation dropped by optimizations 872 // PATTERN-O1-NOT: !annotation 873 // ZERO-LABEL: @test_bitfield_uninit() 874 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0{{.+}}), !annotation [[AUTO_INIT]] 875 // ZERO-O1: store i32 0, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 876 877 TEST_BRACES(bitfield, bitfield); 878 // CHECK-LABEL: @test_bitfield_braces() 879 // CHECK: %braces = alloca %struct.bitfield, align 880 // CHECK-NEXT: call void @llvm.memcpy 881 // CHECK-NOT: !annotation 882 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 883 884 TEST_CUSTOM(bitfield, bitfield, { 4, 1 }); 885 // CHECK-LABEL: @test_bitfield_custom() 886 // CHECK: %custom = alloca %struct.bitfield, align 887 // CHECK-NEXT: call void @llvm.memcpy 888 // CHECK-NOT: !annotation 889 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 890 891 TEST_UNINIT(bitfieldaligned, bitfieldaligned); 892 // CHECK-LABEL: @test_bitfieldaligned_uninit() 893 // CHECK: %uninit = alloca %struct.bitfieldaligned, align 894 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 895 // PATTERN-LABEL: @test_bitfieldaligned_uninit() 896 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_bitfieldaligned_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 897 // PATTERN-O1: store i64 [[IPTR]], ptr %uninit, align 8 898 // FIXME: !annotation dropped by optimizations 899 // PATTERN-O1-NOT: !annotation 900 // ZERO-LABEL: @test_bitfieldaligned_uninit() 901 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 902 // ZERO-O1: store i64 0, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 903 904 TEST_BRACES(bitfieldaligned, bitfieldaligned); 905 // CHECK-LABEL: @test_bitfieldaligned_braces() 906 // CHECK: %braces = alloca %struct.bitfieldaligned, align 907 // CHECK-NEXT: call void @llvm.memcpy 908 // CHECK-NOT: !annotation 909 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 910 911 TEST_CUSTOM(bitfieldaligned, bitfieldaligned, { 4, 1 }); 912 // CHECK-LABEL: @test_bitfieldaligned_custom() 913 // CHECK: %custom = alloca %struct.bitfieldaligned, align 914 // CHECK-NEXT: call void @llvm.memcpy 915 // CHECK-NOT: !annotation 916 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 917 918 TEST_UNINIT(big, big); 919 // CHECK-LABEL: @test_big_uninit() 920 // CHECK: %uninit = alloca %struct.big, align 921 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 922 // PATTERN-LABEL: @test_big_uninit() 923 // PATTERN: call void @llvm.memset{{.*}}, i8 [[I8]],{{.+}}), !annotation [[AUTO_INIT]] 924 // ZERO-LABEL: @test_big_uninit() 925 // ZERO: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 926 927 TEST_BRACES(big, big); 928 // CHECK-LABEL: @test_big_braces() 929 // CHECK: %braces = alloca %struct.big, align [[ALIGN:[0-9]*]] 930 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 104, i1 false) 931 // CHECK-NOT: !annotation 932 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 933 934 TEST_CUSTOM(big, big, { 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA, 0xAAAAAAAA }); 935 // CHECK-LABEL: @test_big_custom() 936 // CHECK: %custom = alloca %struct.big, align [[ALIGN:[0-9]*]] 937 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 -86, i64 104, i1 false) 938 // CHECK-NOT: !annotation 939 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 940 941 TEST_UNINIT(arraytail, arraytail); 942 // CHECK-LABEL: @test_arraytail_uninit() 943 // CHECK: %uninit = alloca %struct.arraytail, align 944 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 945 // PATTERN-LABEL: @test_arraytail_uninit() 946 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_arraytail_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 947 // PATTERN-O1: store i32 [[I32]], {{.*}} align 4, !annotation [[AUTO_INIT]] 948 // ZERO-LABEL: @test_arraytail_uninit() 949 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 950 // ZERO-O1: store i32 0, {{.*}} align 4, !annotation [[AUTO_INIT]] 951 952 TEST_BRACES(arraytail, arraytail); 953 // CHECK-LABEL: @test_arraytail_braces() 954 // CHECK: %braces = alloca %struct.arraytail, align [[ALIGN:[0-9]*]] 955 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false) 956 // CHECK-NOT: !annotation 957 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 958 959 TEST_CUSTOM(arraytail, arraytail, { 0xdead }); 960 // CHECK-LABEL: @test_arraytail_custom() 961 // CHECK: %custom = alloca %struct.arraytail, align 962 // CHECK-NEXT: call void @llvm.memcpy 963 // CHECK-NOT: !annotation 964 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 965 966 TEST_UNINIT(int0, int[0]); 967 // CHECK-LABEL: @test_int0_uninit() 968 // CHECK: %uninit = alloca [0 x i32], align 969 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 970 // PATTERN-LABEL: @test_int0_uninit() 971 // PATTERN: %uninit = alloca [0 x i32], align 972 // PATTERN-O0-NEXT: call void @{{.*}}used{{.*}}%uninit) 973 // ZERO-LABEL: @test_int0_uninit() 974 // ZERO: %uninit = alloca [0 x i32], align 975 // ZERO-O0-NEXT: call void @{{.*}}used{{.*}}%uninit) 976 977 TEST_BRACES(int0, int[0]); 978 // CHECK-LABEL: @test_int0_braces() 979 // CHECK: %braces = alloca [0 x i32], align [[ALIGN:[0-9]*]] 980 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 981 982 TEST_UNINIT(int1, int[1]); 983 // CHECK-LABEL: @test_int1_uninit() 984 // CHECK: %uninit = alloca [1 x i32], align [[ALIGN:[0-9]*]] 985 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 986 // PATTERN-LABEL: @test_int1_uninit() 987 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_int1_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 988 // PATTERN-O1: store i32 [[I32]], {{.*}} align 4, !annotation [[AUTO_INIT]] 989 // ZERO-LABEL: @test_int1_uninit() 990 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 991 // ZERO-O1: store i32 0, {{.*}} align 4, !annotation [[AUTO_INIT]] 992 993 TEST_BRACES(int1, int[1]); 994 // CHECK-LABEL: @test_int1_braces() 995 // CHECK: %braces = alloca [1 x i32], align [[ALIGN:[0-9]*]] 996 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false) 997 // CHECK-NOT: !annotation 998 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 999 1000 TEST_CUSTOM(int1, int[1], { 0x33333333 }); 1001 // CHECK-LABEL: @test_int1_custom() 1002 // CHECK: %custom = alloca [1 x i32], align 1003 // CHECK-NEXT: call void @llvm.memcpy 1004 // CHECK-NOT: !annotation 1005 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1006 1007 TEST_UNINIT(int64, int[64]); 1008 // CHECK-LABEL: @test_int64_uninit() 1009 // CHECK: %uninit = alloca [64 x i32], align 1010 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1011 // PATTERN-LABEL: @test_int64_uninit() 1012 // PATTERN: call void @llvm.memset{{.*}}, i8 [[I8]],{{.+}}), !annotation [[AUTO_INIT]] 1013 // ZERO-LABEL: @test_int64_uninit() 1014 // ZERO: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 1015 1016 TEST_BRACES(int64, int[64]); 1017 // CHECK-LABEL: @test_int64_braces() 1018 // CHECK: %braces = alloca [64 x i32], align [[ALIGN:[0-9]*]] 1019 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 256, i1 false) 1020 // CHECK-NOT: !annotation 1021 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1022 1023 TEST_CUSTOM(int64, int[64], = { 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111, 0x11111111 }); 1024 // CHECK-LABEL: @test_int64_custom() 1025 // CHECK: %custom = alloca [64 x i32], align [[ALIGN:[0-9]*]] 1026 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 17, i64 256, i1 false) 1027 // CHECK-NOT: !annotation 1028 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1029 1030 TEST_UNINIT(bool4, bool[4]); 1031 // CHECK-LABEL: @test_bool4_uninit() 1032 // CHECK: %uninit = alloca [4 x i8], align 1033 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1034 // PATTERN-LABEL: @test_bool4_uninit() 1035 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_bool4_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1036 // PATTERN-O1: store i32 [[I32]], ptr %uninit, align 4 1037 // FIXME: !annotation dropped by optimizations 1038 // PATTERN-O1-NOT: !annotation 1039 // ZERO-LABEL: @test_bool4_uninit() 1040 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 1041 // ZERO-O1: store i32 0, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 1042 1043 TEST_BRACES(bool4, bool[4]); 1044 // CHECK-LABEL: @test_bool4_braces() 1045 // CHECK: %braces = alloca [4 x i8], align [[ALIGN:[0-9]*]] 1046 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false) 1047 // CHECK-NOT: !annotation 1048 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1049 1050 TEST_CUSTOM(bool4, bool[4], { true, true, true, true }); 1051 // CHECK-LABEL: @test_bool4_custom() 1052 // CHECK: %custom = alloca [4 x i8], align 1053 // CHECK-NEXT: call void @llvm.memcpy 1054 // CHECK-NOT: !annotation 1055 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1056 1057 TEST_UNINIT(intptr4, int*[4]); 1058 // CHECK-LABEL: @test_intptr4_uninit() 1059 // CHECK: %uninit = alloca [4 x ptr], align 1060 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1061 // PATTERN-O1-LABEL: @test_intptr4_uninit() 1062 // PATTERN-O1: call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(32) %{{.*}}, i8 -86, i64 32, i1 false) 1063 // FIXME: !annotation dropped by optimizations 1064 // PATTERN-O1-NOT: !annotation 1065 // ZERO-LABEL: @test_intptr4_uninit() 1066 // ZERO: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 1067 1068 TEST_BRACES(intptr4, int*[4]); 1069 // CHECK-LABEL: @test_intptr4_braces() 1070 // CHECK: %braces = alloca [4 x ptr], align [[ALIGN:[0-9]*]] 1071 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 32, i1 false) 1072 // CHECK-NOT: !annotation 1073 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1074 1075 TEST_CUSTOM(intptr4, int *[4], = {(int *)0x22222222, (int *)0x22222222, (int *)0x22222222, (int *)0x22222222}); 1076 // CHECK-LABEL: @test_intptr4_custom() 1077 // CHECK: %custom = alloca [4 x ptr], align 1078 // CHECK-NEXT: call void @llvm.memcpy 1079 // CHECK-NOT: !annotation 1080 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1081 1082 TEST_UNINIT(tailpad4, tailpad[4]); 1083 // CHECK-LABEL: @test_tailpad4_uninit() 1084 // CHECK: %uninit = alloca [4 x %struct.tailpad], align 1085 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1086 // PATTERN-LABEL: @test_tailpad4_uninit() 1087 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_tailpad4_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1088 // PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}, i8 [[I8]], i64 16{{.+}}) 1089 // FIXME: !annotation dropped by optimizations 1090 // PATTERN-O1-NOT: !annotation 1091 // ZERO-LABEL: @test_tailpad4_uninit() 1092 // ZERO: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 1093 1094 TEST_BRACES(tailpad4, tailpad[4]); 1095 // CHECK-LABEL: @test_tailpad4_braces() 1096 // CHECK: %braces = alloca [4 x %struct.tailpad], align [[ALIGN:[0-9]*]] 1097 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 16, i1 false) 1098 // CHECK-NOT: !annotation 1099 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1100 1101 TEST_CUSTOM(tailpad4, tailpad[4], { {257, 1}, {257, 1}, {257, 1}, {257, 1} }); 1102 // CHECK-LABEL: @test_tailpad4_custom() 1103 // CHECK: %custom = alloca [4 x %struct.tailpad], align 1104 // CHECK-NEXT: call void @llvm.memcpy 1105 // CHECK-NOT: !annotation 1106 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1107 1108 TEST_UNINIT(tailpad9, tailpad[9]); 1109 // CHECK-LABEL: @test_tailpad9_uninit() 1110 // CHECK: %uninit = alloca [9 x %struct.tailpad], align 1111 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1112 // PATTERN-LABEL: @test_tailpad9_uninit() 1113 // PATTERN-O0: call void @llvm.memset{{.*}}, i8 [[I8]],{{.+}}), !annotation [[AUTO_INIT]] 1114 // ZERO-LABEL: @test_tailpad9_uninit() 1115 // ZERO: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 1116 1117 TEST_BRACES(tailpad9, tailpad[9]); 1118 // CHECK-LABEL: @test_tailpad9_braces() 1119 // CHECK: %braces = alloca [9 x %struct.tailpad], align [[ALIGN:[0-9]*]] 1120 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 36, i1 false) 1121 // CHECK-NOT: !annotation 1122 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1123 1124 TEST_CUSTOM(tailpad9, tailpad[9], { {257, 1}, {257, 1}, {257, 1}, {257, 1}, {257, 1}, {257, 1}, {257, 1}, {257, 1}, {257, 1} }); 1125 // CHECK-LABEL: @test_tailpad9_custom() 1126 // CHECK: %custom = alloca [9 x %struct.tailpad], align [[ALIGN:[0-9]*]] 1127 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 1, i64 36, i1 false) 1128 // CHECK-NOT: !annotation 1129 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1130 1131 TEST_UNINIT(atomicbool, _Atomic(bool)); 1132 // CHECK-LABEL: @test_atomicbool_uninit() 1133 // CHECK: %uninit = alloca i8, align 1134 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1135 // PATTERN-LABEL: @test_atomicbool_uninit() 1136 // PATTERN: store i8 [[I8]], ptr %uninit, align 1, !annotation [[AUTO_INIT]] 1137 // ZERO-LABEL: @test_atomicbool_uninit() 1138 // ZERO: store i8 0, ptr %uninit, align 1, !annotation [[AUTO_INIT]] 1139 1140 TEST_UNINIT(atomicint, _Atomic(int)); 1141 // CHECK-LABEL: @test_atomicint_uninit() 1142 // CHECK: %uninit = alloca i32, align 1143 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1144 // PATTERN-LABEL: @test_atomicint_uninit() 1145 // PATTERN: store i32 [[I32]], ptr %uninit, align 4, !annotation [[AUTO_INIT]] 1146 // ZERO-LABEL: @test_atomicint_uninit() 1147 // ZERO: store i32 0, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 1148 1149 TEST_UNINIT(atomicdouble, _Atomic(double)); 1150 // CHECK-LABEL: @test_atomicdouble_uninit() 1151 // CHECK: %uninit = alloca double, align 1152 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1153 // PATTERN-LABEL: @test_atomicdouble_uninit() 1154 // PATTERN: store double 0xFFFFFFFFFFFFFFFF, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 1155 // ZERO-LABEL: @test_atomicdouble_uninit() 1156 // ZERO: store double 0.000000e+00, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 1157 1158 TEST_UNINIT(atomicnotlockfree, _Atomic(notlockfree)); 1159 // CHECK-LABEL: @test_atomicnotlockfree_uninit() 1160 // CHECK: %uninit = alloca %struct.notlockfree, align 1161 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1162 // PATTERN-LABEL: @test_atomicnotlockfree_uninit() 1163 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_atomicnotlockfree_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1164 // PATTERN-O1: call void @llvm.memset{{.*}}({{.*}}, i8 [[I8]], i64 32{{.*}} 1165 // FIXME: !annotation dropped by optimizations 1166 // PATTERN-O1-NOT: !annotation 1167 // ZERO-LABEL: @test_atomicnotlockfree_uninit() 1168 // ZERO: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 1169 1170 TEST_UNINIT(atomicpadded, _Atomic(padded)); 1171 // CHECK-LABEL: @test_atomicpadded_uninit() 1172 // CHECK: %uninit = alloca %struct.padded, align 1173 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1174 // PATTERN-LABEL: @test_atomicpadded_uninit() 1175 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_atomicpadded_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1176 // PATTERN-O1: store i64 [[IPTR]], ptr %uninit, align 8 1177 // PATTERN-O1-NOT: !annotation 1178 // ZERO-LABEL: @test_atomicpadded_uninit() 1179 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 1180 // ZERO-O1: store i64 0, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 1181 1182 TEST_UNINIT(atomictailpad, _Atomic(tailpad)); 1183 // CHECK-LABEL: @test_atomictailpad_uninit() 1184 // CHECK: %uninit = alloca %struct.tailpad, align 1185 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1186 // PATTERN-LABEL: @test_atomictailpad_uninit() 1187 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_atomictailpad_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1188 // ZERO-LABEL: @test_atomictailpad_uninit() 1189 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 1190 // ZERO-O1: store i32 0, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 1191 1192 TEST_UNINIT(complexfloat, _Complex float); 1193 // CHECK-LABEL: @test_complexfloat_uninit() 1194 // CHECK: %uninit = alloca { float, float }, align 1195 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1196 // PATTERN-LABEL: @test_complexfloat_uninit() 1197 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_complexfloat_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1198 // PATTERN-O1: store float 0xFFFFFFFFE0000000, ptr %uninit, align {{.+}}, !annotation [[AUTO_INIT]] 1199 // PATTERN-O1: %[[F2:[^ ]*]] = getelementptr inbounds {{.*}}%uninit, i64 4 1200 // PATTERN-O1: store float 0xFFFFFFFFE0000000, ptr %[[F2]], align {{.+}}, !annotation [[AUTO_INIT]] 1201 1202 // ZERO-LABEL: @test_complexfloat_uninit() 1203 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 1204 // ZERO-O1: store i64 0, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 1205 1206 TEST_BRACES(complexfloat, _Complex float); 1207 // CHECK-LABEL: @test_complexfloat_braces() 1208 // CHECK: %braces = alloca { float, float }, align [[ALIGN:[0-9]*]] 1209 // CHECK-NEXT: %[[R:[^ ]*]] = getelementptr inbounds nuw { float, float }, ptr %braces, i32 0, i32 0 1210 // CHECK-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw { float, float }, ptr %braces, i32 0, i32 1 1211 // CHECK-NEXT: store float 0.000000e+00, ptr %[[R]], align [[ALIGN]] 1212 // CHECK-NOT: !annotation 1213 // CHECK-NEXT: store float 0.000000e+00, ptr %[[I]], align [[ALIGN]] 1214 // CHECK-NOT: !annotation 1215 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1216 1217 TEST_CUSTOM(complexfloat, _Complex float, { 3.1415926535897932384626433, 3.1415926535897932384626433 }); 1218 // CHECK-LABEL: @test_complexfloat_custom() 1219 // CHECK: %custom = alloca { float, float }, align [[ALIGN:[0-9]*]] 1220 // CHECK-NEXT: %[[R:[^ ]*]] = getelementptr inbounds nuw { float, float }, ptr %custom, i32 0, i32 0 1221 // CHECK-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw { float, float }, ptr %custom, i32 0, i32 1 1222 // CHECK-NEXT: store float 0x400921FB60000000, ptr %[[R]], align [[ALIGN]] 1223 // CHECK-NOT: !annotation 1224 // CHECK-NEXT: store float 0x400921FB60000000, ptr %[[I]], align [[ALIGN]] 1225 // CHECK-NOT: !annotation 1226 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1227 1228 TEST_UNINIT(complexdouble, _Complex double); 1229 // CHECK-LABEL: @test_complexdouble_uninit() 1230 // CHECK: %uninit = alloca { double, double }, align 1231 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1232 // PATTERN-LABEL: @test_complexdouble_uninit() 1233 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_complexdouble_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1234 // ZERO-LABEL: @test_complexdouble_uninit() 1235 // ZERO: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 1236 1237 TEST_BRACES(complexdouble, _Complex double); 1238 // CHECK-LABEL: @test_complexdouble_braces() 1239 // CHECK: %braces = alloca { double, double }, align [[ALIGN:[0-9]*]] 1240 // CHECK-NEXT: %[[R:[^ ]*]] = getelementptr inbounds nuw { double, double }, ptr %braces, i32 0, i32 0 1241 // CHECK-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw { double, double }, ptr %braces, i32 0, i32 1 1242 // CHECK-NEXT: store double 0.000000e+00, ptr %[[R]], align [[ALIGN]] 1243 // CHECK-NOT: !annotation 1244 // CHECK-NEXT: store double 0.000000e+00, ptr %[[I]], align [[ALIGN]] 1245 // CHECK-NOT: !annotation 1246 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1247 1248 TEST_CUSTOM(complexdouble, _Complex double, { 3.1415926535897932384626433, 3.1415926535897932384626433 }); 1249 // CHECK-LABEL: @test_complexdouble_custom() 1250 // CHECK: %custom = alloca { double, double }, align [[ALIGN:[0-9]*]] 1251 // CHECK-NEXT: %[[R:[^ ]*]] = getelementptr inbounds nuw { double, double }, ptr %custom, i32 0, i32 0 1252 // CHECK-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw { double, double }, ptr %custom, i32 0, i32 1 1253 // CHECK-NEXT: store double 0x400921FB54442D18, ptr %[[R]], align [[ALIGN]] 1254 // CHECK-NOT: !annotation 1255 // CHECK-NEXT: store double 0x400921FB54442D18, ptr %[[I]], align [[ALIGN]] 1256 // CHECK-NOT: !annotation 1257 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1258 1259 TEST_UNINIT(volatileint, volatile int); 1260 // CHECK-LABEL: @test_volatileint_uninit() 1261 // CHECK: %uninit = alloca i32, align 1262 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1263 // PATTERN-LABEL: @test_volatileint_uninit() 1264 // PATTERN: store volatile i32 [[I32]], ptr %uninit, align 4, !annotation [[AUTO_INIT]] 1265 // ZERO-LABEL: @test_volatileint_uninit() 1266 // ZERO: store volatile i32 0, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 1267 1268 TEST_BRACES(volatileint, volatile int); 1269 // CHECK-LABEL: @test_volatileint_braces() 1270 // CHECK: %braces = alloca i32, align [[ALIGN:[0-9]*]] 1271 // CHECK-NEXT: store volatile i32 0, ptr %braces, align [[ALIGN]] 1272 // CHECK-NOT: !annotation 1273 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1274 1275 TEST_UNINIT(semivolatile, semivolatile); 1276 // CHECK-LABEL: @test_semivolatile_uninit() 1277 // CHECK: %uninit = alloca %struct.semivolatile, align 1278 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1279 // PATTERN-LABEL: @test_semivolatile_uninit() 1280 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_semivolatile_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1281 // ZERO-LABEL: @test_semivolatile_uninit() 1282 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 1283 // ZERO-O1: store i64 0, ptr %uninit, align 8, !annotation [[AUTO_INIT]] 1284 1285 TEST_BRACES(semivolatile, semivolatile); 1286 // CHECK-LABEL: @test_semivolatile_braces() 1287 // CHECK: %braces = alloca %struct.semivolatile, align [[ALIGN:[0-9]*]] 1288 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 8, i1 false) 1289 // CHECK-NOT: !annotation 1290 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1291 1292 TEST_CUSTOM(semivolatile, semivolatile, { 0x44444444, 0x44444444 }); 1293 // CHECK-LABEL: @test_semivolatile_custom() 1294 // CHECK: %custom = alloca %struct.semivolatile, align 1295 // CHECK-O0: call void @llvm.memcpy 1296 // CHECK-NOT: !annotation 1297 // CHECK-O0: call void @{{.*}}used{{.*}}%custom) 1298 // PATTERN-O1: store i32 1145324612, ptr %custom, align 4 1299 // PATTERN-O1-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw i8, ptr %custom, i64 4 1300 // PATTERN-O1-NEXT: store i32 1145324612, ptr %[[I]], align 4 1301 // ZERO-O1: store i64 4919131752989213764, ptr %custom, align 8 1302 // CHECK-NOT: !annotation 1303 1304 TEST_UNINIT(semivolatileinit, semivolatileinit); 1305 // CHECK-LABEL: @test_semivolatileinit_uninit() 1306 // CHECK: %uninit = alloca %struct.semivolatileinit, align 1307 // CHECK-NEXT: call void @{{.*}}semivolatileinit{{.*}}%uninit) 1308 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1309 1310 TEST_BRACES(semivolatileinit, semivolatileinit); 1311 // CHECK-LABEL: @test_semivolatileinit_braces() 1312 // CHECK: %braces = alloca %struct.semivolatileinit, align [[ALIGN:[0-9]*]] 1313 // CHECK-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw %struct.semivolatileinit, ptr %braces, i32 0, i32 0 1314 // CHECK-NEXT: store i32 286331153, ptr %[[I]], align [[ALIGN]] 1315 // CHECK-NOT: !annotation 1316 // CHECK-NEXT: %[[VI:[^ ]*]] = getelementptr inbounds nuw %struct.semivolatileinit, ptr %braces, i32 0, i32 1 1317 // CHECK-NEXT: store volatile i32 286331153, ptr %[[VI]], align [[ALIGN]] 1318 // CHECK-NOT: !annotation 1319 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1320 1321 TEST_CUSTOM(semivolatileinit, semivolatileinit, { 0x44444444, 0x44444444 }); 1322 // CHECK-LABEL: @test_semivolatileinit_custom() 1323 // CHECK: %custom = alloca %struct.semivolatileinit, align [[ALIGN:[0-9]*]] 1324 // CHECK-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw %struct.semivolatileinit, ptr %custom, i32 0, i32 0 1325 // CHECK-NEXT: store i32 1145324612, ptr %[[I]], align [[ALIGN]] 1326 // CHECK-NOT: !annotation 1327 // CHECK-NEXT: %[[VI:[^ ]*]] = getelementptr inbounds nuw %struct.semivolatileinit, ptr %custom, i32 0, i32 1 1328 // CHECK-NEXT: store volatile i32 1145324612, ptr %[[VI]], align [[ALIGN]] 1329 // CHECK-NOT: !annotation 1330 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1331 1332 TEST_UNINIT(base, base); 1333 // CHECK-LABEL: @test_base_uninit() 1334 // CHECK: %uninit = alloca %struct.base, align 1335 // CHECK-NEXT: call void @{{.*}}base{{.*}}%uninit) 1336 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1337 // PATTERN-LABEL: @test_base_uninit() 1338 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_base_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1339 // ZERO-LABEL: @test_base_uninit() 1340 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 1341 // ZERO-O1: store ptr getelementptr inbounds nuw inrange(-16, 16) (i8, ptr @_ZTV4base, i64 16), {{.*}}, align 8 1342 // ZERO-O1-NOT: !annotation 1343 1344 TEST_BRACES(base, base); 1345 // CHECK-LABEL: @test_base_braces() 1346 // CHECK: %braces = alloca %struct.base, align [[ALIGN:[0-9]*]] 1347 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 8, i1 false) 1348 // CHECK-NOT: !annotation 1349 // CHECK-NEXT: call void @{{.*}}base{{.*}}%braces) 1350 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1351 1352 TEST_UNINIT(derived, derived); 1353 // CHECK-LABEL: @test_derived_uninit() 1354 // CHECK: %uninit = alloca %struct.derived, align 1355 // CHECK-NEXT: call void @{{.*}}derived{{.*}}%uninit) 1356 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1357 // PATTERN-LABEL: @test_derived_uninit() 1358 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_derived_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1359 // ZERO-LABEL: @test_derived_uninit() 1360 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 1361 // ZERO-O1: store i64 0, {{.*}} align 8, !annotation [[AUTO_INIT]] 1362 // ZERO-O1: store ptr getelementptr inbounds nuw inrange(-16, 16) (i8, ptr @_ZTV7derived, i64 16), {{.*}} align 8 1363 1364 TEST_BRACES(derived, derived); 1365 // CHECK-LABEL: @test_derived_braces() 1366 // CHECK: %braces = alloca %struct.derived, align [[ALIGN:[0-9]*]] 1367 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 8, i1 false) 1368 // CHECK-NOT: !annotation 1369 // CHECK-NEXT: call void @{{.*}}derived{{.*}}%braces) 1370 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1371 1372 TEST_UNINIT(virtualderived, virtualderived); 1373 // CHECK-LABEL: @test_virtualderived_uninit() 1374 // CHECK: %uninit = alloca %struct.virtualderived, align 1375 // CHECK-NEXT: call void @{{.*}}virtualderived{{.*}}%uninit) 1376 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1377 // PATTERN-LABEL: @test_virtualderived_uninit() 1378 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_virtualderived_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1379 // ZERO-LABEL: @test_virtualderived_uninit() 1380 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 1381 // ZERO-O1: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 1382 1383 TEST_BRACES(virtualderived, virtualderived); 1384 // CHECK-LABEL: @test_virtualderived_braces() 1385 // CHECK: %braces = alloca %struct.virtualderived, align [[ALIGN:[0-9]*]] 1386 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 16, i1 false) 1387 // CHECK-NOT: !annotation 1388 // CHECK-NEXT: call void @{{.*}}virtualderived{{.*}}%braces) 1389 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1390 1391 TEST_UNINIT(matching, matching); 1392 // CHECK-LABEL: @test_matching_uninit() 1393 // CHECK: %uninit = alloca %union.matching, align 1394 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1395 // PATTERN-LABEL: @test_matching_uninit() 1396 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_matching_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1397 // ZERO-LABEL: @test_matching_uninit() 1398 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 1399 // ZERO-O1: store i32 0, {{.*}} align 4, !annotation [[AUTO_INIT]] 1400 1401 TEST_BRACES(matching, matching); 1402 // CHECK-LABEL: @test_matching_braces() 1403 // CHECK: %braces = alloca %union.matching, align [[ALIGN:[0-9]*]] 1404 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false) 1405 // CHECK-NOT: !annotation 1406 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1407 1408 TEST_CUSTOM(matching, matching, { .f = 0xf00f }); 1409 // CHECK-LABEL: @test_matching_custom() 1410 // CHECK: %custom = alloca %union.matching, align 1411 // CHECK-O0: call void @llvm.memcpy 1412 // CHECK-NOT: !annotation 1413 // CHECK-O0: call void @{{.*}}used{{.*}}%custom) 1414 // PATTERN-O1: store float 6.145500e+04, ptr {{.*}}, align 4 1415 // ZERO-O1: store i32 1198526208, ptr %custom, align 4 1416 // CHECK-NOT: !annotation 1417 1418 TEST_UNINIT(matchingreverse, matchingreverse); 1419 // CHECK-LABEL: @test_matchingreverse_uninit() 1420 // CHECK: %uninit = alloca %union.matchingreverse, align 1421 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1422 // PATTERN-LABEL: @test_matchingreverse_uninit() 1423 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_matchingreverse_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1424 // PATTERN-O1: store float 0xFFFFFFFFE0000000, {{.+}}, !annotation [[AUTO_INIT]] 1425 // ZERO-LABEL: @test_matchingreverse_uninit() 1426 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0,{{.+}}), !annotation [[AUTO_INIT]] 1427 // ZERO-O1: store i32 0, {{.*}} align 4, !annotation [[AUTO_INIT]] 1428 1429 TEST_BRACES(matchingreverse, matchingreverse); 1430 // CHECK-LABEL: @test_matchingreverse_braces() 1431 // CHECK: %braces = alloca %union.matchingreverse, align [[ALIGN:[0-9]*]] 1432 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false) 1433 // CHECK-NOT: !annotation 1434 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1435 1436 TEST_CUSTOM(matchingreverse, matchingreverse, { .i = 0xf00f }); 1437 // CHECK-LABEL: @test_matchingreverse_custom() 1438 // CHECK: %custom = alloca %union.matchingreverse, align 1439 // CHECK-O0: call void @llvm.memcpy 1440 // CHECK-NOT: !annotation 1441 // CHECK-O0: call void @{{.*}}used{{.*}}%custom) 1442 // PATTERN-O1: store i32 61455, ptr %custom, align 4 1443 // ZERO-O1: store i32 61455, ptr %custom, align 4 1444 // CHECK-NOT: !annotation 1445 1446 TEST_UNINIT(unmatched, unmatched); 1447 // CHECK-LABEL: @test_unmatched_uninit() 1448 // CHECK: %uninit = alloca %union.unmatched, align 1449 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1450 // PATTERN-LABEL: @test_unmatched_uninit() 1451 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_unmatched_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1452 // ZERO-LABEL: @test_unmatched_uninit() 1453 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 1454 // ZERO-O1: store i32 0, {{.*}} align 4, !annotation [[AUTO_INIT]] 1455 1456 TEST_BRACES(unmatched, unmatched); 1457 // CHECK-LABEL: @test_unmatched_braces() 1458 // CHECK: %braces = alloca %union.unmatched, align 1459 // CHECK-NEXT: call void @llvm.memcpy 1460 // CHECK-NOT: !annotation 1461 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1462 1463 TEST_CUSTOM(unmatched, unmatched, { .i = 0x3badbeef }); 1464 // CHECK-LABEL: @test_unmatched_custom() 1465 // CHECK: %custom = alloca %union.unmatched, align 1466 // CHECK-O0: call void @llvm.memcpy 1467 // CHECK-NOT: !annotation 1468 // CHECK-O0: call void @{{.*}}used{{.*}}%custom) 1469 // PATTERN-O1: store i32 1001242351, ptr {{.*}}, align 4 1470 // ZERO-O1: store i32 1001242351, ptr {{.*}}, align 4 1471 // CHECK-NOT: !annotation 1472 1473 TEST_UNINIT(unmatchedreverse, unmatchedreverse); 1474 // CHECK-LABEL: @test_unmatchedreverse_uninit() 1475 // CHECK: %uninit = alloca %union.unmatchedreverse, align 1476 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1477 // PATTERN-LABEL: @test_unmatchedreverse_uninit() 1478 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_unmatchedreverse_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1479 // ZERO-LABEL: @test_unmatchedreverse_uninit() 1480 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 1481 // ZERO-O1: store i32 0, {{.*}} align 4, !annotation [[AUTO_INIT]] 1482 1483 TEST_BRACES(unmatchedreverse, unmatchedreverse); 1484 // CHECK-LABEL: @test_unmatchedreverse_braces() 1485 // CHECK: %braces = alloca %union.unmatchedreverse, align [[ALIGN:[0-9]*]] 1486 // CHECK-NEXT: call void @llvm.memset{{.*}}(ptr align [[ALIGN]] %{{.*}}, i8 0, i64 4, i1 false) 1487 // CHECK-NOT: !annotation 1488 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1489 1490 TEST_CUSTOM(unmatchedreverse, unmatchedreverse, { .c = 42 }); 1491 // CHECK-LABEL: @test_unmatchedreverse_custom() 1492 // CHECK: %custom = alloca %union.unmatchedreverse, align 1493 // CHECK-O0: call void @llvm.memcpy 1494 // CHECK-NOT: !annotation 1495 // CHECK-O0: call void @{{.*}}used{{.*}}%custom) 1496 // PATTERN-O1: store i8 42, ptr {{.*}}, align 4 1497 // PATTERN-O1-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw i8, ptr %custom, i64 1 1498 // PATTERN-O1-NEXT: store i8 -86, ptr %[[I]], align {{.*}} 1499 // PATTERN-O1-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw i8, ptr %custom, i64 2 1500 // PATTERN-O1-NEXT: store i8 -86, ptr %[[I]], align {{.*}} 1501 // PATTERN-O1-NEXT: %[[I:[^ ]*]] = getelementptr inbounds nuw i8, ptr %custom, i64 3 1502 // PATTERN-O1-NEXT: store i8 -86, ptr %[[I]], align {{.*}} 1503 // ZERO-O1: store i32 42, ptr {{.*}}, align 4 1504 1505 TEST_UNINIT(unmatchedfp, unmatchedfp); 1506 // CHECK-LABEL: @test_unmatchedfp_uninit() 1507 // CHECK: %uninit = alloca %union.unmatchedfp, align 1508 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1509 // PATTERN-LABEL: @test_unmatchedfp_uninit() 1510 // PATTERN-O0: call void @llvm.memcpy{{.*}} @__const.test_unmatchedfp_uninit.uninit{{.+}}), !annotation [[AUTO_INIT]] 1511 // ZERO-LABEL: @test_unmatchedfp_uninit() 1512 // ZERO-O0: call void @llvm.memset{{.*}}, i8 0, {{.+}}), !annotation [[AUTO_INIT]] 1513 // ZERO-O1: store i64 0, {{.*}} align 8, !annotation [[AUTO_INIT]] 1514 1515 TEST_BRACES(unmatchedfp, unmatchedfp); 1516 // CHECK-LABEL: @test_unmatchedfp_braces() 1517 // CHECK: %braces = alloca %union.unmatchedfp, align 1518 // CHECK-NEXT: call void @llvm.memcpy 1519 // CHECK-NOT: !annotation 1520 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1521 1522 TEST_CUSTOM(unmatchedfp, unmatchedfp, { .d = 3.1415926535897932384626433 }); 1523 // CHECK-LABEL: @test_unmatchedfp_custom() 1524 // CHECK: %custom = alloca %union.unmatchedfp, align 1525 // CHECK-O0: call void @llvm.memcpy 1526 // CHECK-NOT: !annotation 1527 // CHECK-O0: call void @{{.*}}used{{.*}}%custom) 1528 // PATTERN-O1: store double 0x400921FB54442D18, ptr %custom, align 8 1529 // ZERO-O1: store i64 4614256656552045848, ptr %custom, align 8 1530 // CHECK-NOT: !annotation 1531 1532 TEST_UNINIT(emptyenum, emptyenum); 1533 // CHECK-LABEL: @test_emptyenum_uninit() 1534 // CHECK: %uninit = alloca i32, align 1535 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1536 // PATTERN-LABEL: @test_emptyenum_uninit() 1537 // PATTERN: store i32 [[I32]], ptr %uninit, align 4, !annotation [[AUTO_INIT]] 1538 // ZERO-LABEL: @test_emptyenum_uninit() 1539 // ZERO: store i32 0, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 1540 1541 TEST_BRACES(emptyenum, emptyenum); 1542 // CHECK-LABEL: @test_emptyenum_braces() 1543 // CHECK: %braces = alloca i32, align [[ALIGN:[0-9]*]] 1544 // CHECK-NOT: !annotation 1545 // CHECK-NEXT: store i32 0, ptr %braces, align [[ALIGN]] 1546 // CHECK-NOT: !annotation 1547 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1548 1549 TEST_CUSTOM(emptyenum, emptyenum, { (emptyenum)42 }); 1550 // CHECK-LABEL: @test_emptyenum_custom() 1551 // CHECK: %custom = alloca i32, align [[ALIGN:[0-9]*]] 1552 // CHECK-NEXT: store i32 42, ptr %custom, align [[ALIGN]] 1553 // CHECK-NOT: !annotation 1554 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1555 1556 TEST_UNINIT(smallenum, smallenum); 1557 // CHECK-LABEL: @test_smallenum_uninit() 1558 // CHECK: %uninit = alloca i32, align 1559 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1560 // PATTERN-LABEL: @test_smallenum_uninit() 1561 // PATTERN: store i32 [[I32]], ptr %uninit, align 4, !annotation [[AUTO_INIT]] 1562 // ZERO-LABEL: @test_smallenum_uninit() 1563 // ZERO: store i32 0, ptr %uninit, align 4, !annotation [[AUTO_INIT]] 1564 1565 TEST_BRACES(smallenum, smallenum); 1566 // CHECK-LABEL: @test_smallenum_braces() 1567 // CHECK: %braces = alloca i32, align [[ALIGN:[0-9]*]] 1568 // CHECK-NEXT: store i32 0, ptr %braces, align [[ALIGN]] 1569 // CHECK-NOT: !annotation 1570 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1571 1572 TEST_CUSTOM(smallenum, smallenum, { (smallenum)42 }); 1573 // CHECK-LABEL: @test_smallenum_custom() 1574 // CHECK: %custom = alloca i32, align [[ALIGN:[0-9]*]] 1575 // CHECK-NEXT: store i32 42, ptr %custom, align [[ALIGN]] 1576 // CHECK-NOT: !annotation 1577 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1578 1579 TEST_UNINIT(intvec16, int __attribute__((vector_size(16)))); 1580 // CHECK-LABEL: @test_intvec16_uninit() 1581 // CHECK: %uninit = alloca <4 x i32>, align 1582 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1583 // PATTERN-LABEL: @test_intvec16_uninit() 1584 // PATTERN: store <4 x i32> splat (i32 [[I32]]), ptr %uninit, align 16, !annotation [[AUTO_INIT]] 1585 // ZERO-LABEL: @test_intvec16_uninit() 1586 // ZERO: store <4 x i32> zeroinitializer, ptr %uninit, align 16, !annotation [[AUTO_INIT]] 1587 1588 TEST_BRACES(intvec16, int __attribute__((vector_size(16)))); 1589 // CHECK-LABEL: @test_intvec16_braces() 1590 // CHECK: %braces = alloca <4 x i32>, align [[ALIGN:[0-9]*]] 1591 // CHECK-NEXT: store <4 x i32> zeroinitializer, ptr %braces, align [[ALIGN]] 1592 // CHECK-NOT: !annotation 1593 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1594 1595 TEST_CUSTOM(intvec16, int __attribute__((vector_size(16))), { 0x44444444, 0x44444444, 0x44444444, 0x44444444 }); 1596 // CHECK-LABEL: @test_intvec16_custom() 1597 // CHECK: %custom = alloca <4 x i32>, align [[ALIGN:[0-9]*]] 1598 // CHECK-NEXT: store <4 x i32> splat (i32 1145324612), ptr %custom, align [[ALIGN]] 1599 // CHECK-NOT: !annotation 1600 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1601 1602 TEST_UNINIT(longlongvec32, long long __attribute__((vector_size(32)))); 1603 // CHECK-LABEL: @test_longlongvec32_uninit() 1604 // CHECK: %uninit = alloca <4 x i64>, align 1605 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1606 // PATTERN-LABEL: @test_longlongvec32_uninit() 1607 // PATTERN: store <4 x i64> splat (i64 [[I64]]), ptr %uninit, align 32, !annotation [[AUTO_INIT]] 1608 // ZERO-LABEL: @test_longlongvec32_uninit() 1609 // ZERO: store <4 x i64> zeroinitializer, ptr %uninit, align 32, !annotation [[AUTO_INIT]] 1610 1611 TEST_BRACES(longlongvec32, long long __attribute__((vector_size(32)))); 1612 // CHECK-LABEL: @test_longlongvec32_braces() 1613 // CHECK: %braces = alloca <4 x i64>, align [[ALIGN:[0-9]*]] 1614 // CHECK-NEXT: store <4 x i64> zeroinitializer, ptr %braces, align [[ALIGN]] 1615 // CHECK-NOT: !annotation 1616 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1617 1618 TEST_CUSTOM(longlongvec32, long long __attribute__((vector_size(32))), { 0x3333333333333333, 0x3333333333333333, 0x3333333333333333, 0x3333333333333333 }); 1619 // CHECK-LABEL: @test_longlongvec32_custom() 1620 // CHECK: %custom = alloca <4 x i64>, align [[ALIGN:[0-9]*]] 1621 // CHECK-NEXT: store <4 x i64> splat (i64 3689348814741910323), ptr %custom, align [[ALIGN]] 1622 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1623 1624 TEST_UNINIT(floatvec16, float __attribute__((vector_size(16)))); 1625 // CHECK-LABEL: @test_floatvec16_uninit() 1626 // CHECK: %uninit = alloca <4 x float>, align 1627 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1628 // PATTERN-LABEL: @test_floatvec16_uninit() 1629 // PATTERN: store <4 x float> splat (float 0xFFFFFFFFE0000000), ptr %uninit, align 16, !annotation [[AUTO_INIT]] 1630 // ZERO-LABEL: @test_floatvec16_uninit() 1631 // ZERO: store <4 x float> zeroinitializer, ptr %uninit, align 16, !annotation [[AUTO_INIT]] 1632 1633 TEST_BRACES(floatvec16, float __attribute__((vector_size(16)))); 1634 // CHECK-LABEL: @test_floatvec16_braces() 1635 // CHECK: %braces = alloca <4 x float>, align [[ALIGN:[0-9]*]] 1636 // CHECK-NEXT: store <4 x float> zeroinitializer, ptr %braces, align [[ALIGN]] 1637 // CHECK-NOT: !annotation 1638 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1639 1640 TEST_CUSTOM(floatvec16, float __attribute__((vector_size(16))), { 3.1415926535897932384626433, 3.1415926535897932384626433, 3.1415926535897932384626433, 3.1415926535897932384626433 }); 1641 // CHECK-LABEL: @test_floatvec16_custom() 1642 // CHECK: %custom = alloca <4 x float>, align [[ALIGN:[0-9]*]] 1643 // CHECK-NEXT: store <4 x float> splat (float 0x400921FB60000000), ptr %custom, align [[ALIGN]] 1644 // CHECK-NOT: !annotation 1645 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1646 1647 TEST_UNINIT(doublevec32, double __attribute__((vector_size(32)))); 1648 // CHECK-LABEL: @test_doublevec32_uninit() 1649 // CHECK: %uninit = alloca <4 x double>, align 1650 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1651 // PATTERN-LABEL: @test_doublevec32_uninit() 1652 // PATTERN: store <4 x double> splat (double 0xFFFFFFFFFFFFFFFF), ptr %uninit, align 32, !annotation [[AUTO_INIT]] 1653 // ZERO-LABEL: @test_doublevec32_uninit() 1654 // ZERO: store <4 x double> zeroinitializer, ptr %uninit, align 32, !annotation [[AUTO_INIT]] 1655 1656 TEST_BRACES(doublevec32, double __attribute__((vector_size(32)))); 1657 // CHECK-LABEL: @test_doublevec32_braces() 1658 // CHECK: %braces = alloca <4 x double>, align [[ALIGN:[0-9]*]] 1659 // CHECK-NEXT: store <4 x double> zeroinitializer, ptr %braces, align [[ALIGN]] 1660 // CHECK-NOT: !annotation 1661 // CHECK-NEXT: call void @{{.*}}used{{.*}}%braces) 1662 1663 TEST_CUSTOM(doublevec32, double __attribute__((vector_size(32))), { 3.1415926535897932384626433, 3.1415926535897932384626433, 3.1415926535897932384626433, 3.1415926535897932384626433 }); 1664 // CHECK-LABEL: @test_doublevec32_custom() 1665 // CHECK: %custom = alloca <4 x double>, align [[ALIGN:[0-9]*]] 1666 // CHECK-NEXT: store <4 x double> splat (double 0x400921FB54442D18), ptr %custom, align [[ALIGN]] 1667 // CHECK-NOT: !annotation 1668 // CHECK-NEXT: call void @{{.*}}used{{.*}}%custom) 1669 1670 // TODO: This vector has tail padding 1671 TEST_UNINIT(doublevec24, double __attribute__((vector_size(24)))); 1672 // CHECK-LABEL: @test_doublevec24_uninit() 1673 // CHECK: %uninit = alloca <3 x double>, align 1674 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1675 // PATTERN-LABEL: @test_doublevec24_uninit() 1676 // PATTERN: store <3 x double> splat (double 0xFFFFFFFFFFFFFFFF), ptr %uninit, align 32, !annotation [[AUTO_INIT]] 1677 // ZERO-LABEL: @test_doublevec24_uninit() 1678 // ZERO: store <3 x double> zeroinitializer, ptr %uninit, align 32, !annotation [[AUTO_INIT]] 1679 1680 // TODO: This vector has tail padding 1681 TEST_UNINIT(longdoublevec32, long double __attribute__((vector_size(sizeof(long double)*2)))); 1682 // CHECK-LABEL: @test_longdoublevec32_uninit() 1683 // CHECK: %uninit = alloca <2 x x86_fp80>, align 1684 // CHECK-NEXT: call void @{{.*}}used{{.*}}%uninit) 1685 // PATTERN-LABEL: @test_longdoublevec32_uninit() 1686 // PATTERN: store <2 x x86_fp80> splat (x86_fp80 0xKFFFFFFFFFFFFFFFFFFFF), ptr %uninit, align 32, !annotation [[AUTO_INIT]] 1687 // ZERO-LABEL: @test_longdoublevec32_uninit() 1688 // ZERO: store <2 x x86_fp80> zeroinitializer, ptr %uninit, align 32, !annotation [[AUTO_INIT]] 1689 1690 } // extern "C" 1691 1692 // PATTERN: [[AUTO_INIT]] = !{!"auto-init"} 1693 // ZERO: [[AUTO_INIT]] = !{!"auto-init"} 1694