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