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