test/OpenMP/single_codegen.cpp

   1 // RUN: %clang_cc1 -verify -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
   2 // RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
   3 // RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
   4 // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -std=c++11 -fopenmp -fnoopenmp-use-tls -fexceptions -fcxx-exceptions -debug-info-kind=line-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
   5 // RUN: %clang_cc1 -verify -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -DARRAY -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck -check-prefix=ARRAY %s
   6
   7 // RUN: %clang_cc1 -verify -fopenmp-simd -fnoopenmp-use-tls -x c++ -std=c++11 -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck --check-prefix SIMD-ONLY0 %s
   8 // RUN: %clang_cc1 -fopenmp-simd -fnoopenmp-use-tls -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
   9 // RUN: %clang_cc1 -fopenmp-simd -fnoopenmp-use-tls -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s
  10 // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -std=c++11 -fopenmp-simd -fnoopenmp-use-tls -fexceptions -fcxx-exceptions -debug-info-kind=line-tables-only -x c++ -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s
  11 // RUN: %clang_cc1 -verify -fopenmp-simd -fnoopenmp-use-tls -x c++ -std=c++11 -DARRAY -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s
  12 // SIMD-ONLY0-NOT: {{__kmpc|__tgt}}
  13 // expected-no-diagnostics
  14 #ifndef ARRAY
  15 #ifndef HEADER
  16 #define HEADER
  17
  18 class TestClass {
  19 public:
  20   int a;
  21   TestClass() : a(0) {}
  22   TestClass(const TestClass &C) : a(C.a) {}
  23   TestClass &operator=(const TestClass &) { return *this;}
  24   ~TestClass(){};
  25 };
  26
  27 // CHECK-DAG:   [[TEST_CLASS_TY:%.+]] = type { i{{[0-9]+}} }
  28 // CHECK-DAG:   [[SST_TY:%.+]] = type { double }
  29 // CHECK-DAG:   [[SS_TY:%.+]] = type { i32, i8, i32* }
  30 // CHECK-DAG:   [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }
  31 // CHECK:       [[IMPLICIT_BARRIER_SINGLE_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 322, i32 0, i32 0, i8*
  32
  33 // CHECK:       define void [[FOO:@.+]]()
  34
  35 TestClass tc;
  36 TestClass tc2[2];
  37 #pragma omp threadprivate(tc, tc2)
  38
  39 void foo() {}
  40
  41 struct SS {
  42   int a;
  43   int b : 4;
  44   int &c;
  45   SS(int &d) : a(0), b(0), c(d) {
  46 #pragma omp parallel firstprivate(a, b, c)
  47 #pragma omp single copyprivate(a, this->b, (this)->c)
  48     [&]() {
  49       ++this->a, --b, (this)->c /= 1;
  50 #pragma omp parallel firstprivate(a, b, c)
  51 #pragma omp single copyprivate(a, this->b, (this)->c)
  52       ++(this)->a, --b, this->c /= 1;
  53     }();
  54   }
  55 };
  56
  57 template<typename T>
  58 struct SST {
  59   T a;
  60   SST() : a(T()) {
  61 #pragma omp parallel firstprivate(a)
  62 #pragma omp single copyprivate(this->a)
  63     [&]() {
  64       [&]() {
  65         ++this->a;
  66 #pragma omp parallel firstprivate(a)
  67 #pragma omp single copyprivate((this)->a)
  68         ++(this)->a;
  69       }();
  70     }();
  71   }
  72 };
  73
  74 // CHECK-LABEL: @main
  75 // TERM_DEBUG-LABEL: @main
  76 int main() {
  77   // CHECK-DAG: [[A_ADDR:%.+]] = alloca i8
  78   // CHECK-DAG: [[A2_ADDR:%.+]] = alloca [2 x i8]
  79   // CHECK-DAG: [[C_ADDR:%.+]] = alloca [[TEST_CLASS_TY]]
  80   char a;
  81   char a2[2];
  82   TestClass &c = tc;
  83   SST<double> sst;
  84   SS ss(c.a);
  85
  86 // CHECK:       [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT_T_TY]]* [[DEFAULT_LOC:@.+]])
  87 // CHECK-DAG:   [[DID_IT:%.+]] = alloca i32,
  88 // CHECK-DAG:   [[COPY_LIST:%.+]] = alloca [5 x i8*],
  89
  90 // CHECK:       [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
  91 // CHECK-NEXT:  [[IS_SINGLE:%.+]] = icmp ne i32 [[RES]], 0
  92 // CHECK-NEXT:  br i1 [[IS_SINGLE]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]]
  93 // CHECK:       [[THEN]]
  94 // CHECK-NEXT:  store i8 2, i8* [[A_ADDR]]
  95 // CHECK-NEXT:  call void @__kmpc_end_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
  96 // CHECK-NEXT:  br label {{%?}}[[EXIT]]
  97 // CHECK:       [[EXIT]]
  98 // CHECK-NOT:   call {{.+}} @__kmpc_cancel_barrier
  99 #pragma omp single nowait
 100   a = 2;
 101 // CHECK:       [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
 102 // CHECK-NEXT:  [[IS_SINGLE:%.+]] = icmp ne i32 [[RES]], 0
 103 // CHECK-NEXT:  br i1 [[IS_SINGLE]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]]
 104 // CHECK:       [[THEN]]
 105 // CHECK-NEXT:  store i8 2, i8* [[A_ADDR]]
 106 // CHECK-NEXT:  call void @__kmpc_end_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
 107 // CHECK-NEXT:  br label {{%?}}[[EXIT]]
 108 // CHECK:       [[EXIT]]
 109 // CHECK:       call{{.*}} @__kmpc_barrier([[IDENT_T_TY]]* [[IMPLICIT_BARRIER_SINGLE_LOC]], i32 [[GTID]])
 110 #pragma omp single
 111   a = 2;
 112 // CHECK:       store i32 0, i32* [[DID_IT]]
 113 // CHECK:       [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
 114 // CHECK-NEXT:  [[IS_SINGLE:%.+]] = icmp ne i32 [[RES]], 0
 115 // CHECK-NEXT:  br i1 [[IS_SINGLE]], label {{%?}}[[THEN:.+]], label {{%?}}[[EXIT:.+]]
 116 // CHECK:       [[THEN]]
 117 // CHECK-NEXT:  invoke void [[FOO]]()
 118 // CHECK:       to label {{%?}}[[CONT:.+]] unwind
 119 // CHECK:       [[CONT]]
 120 // CHECK:       call void @__kmpc_end_single([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]])
 121 // CHECK:       store i32 1, i32* [[DID_IT]]
 122 // CHECK-NEXT:  br label {{%?}}[[EXIT]]
 123 // CHECK:       [[EXIT]]
 124 // CHECK:       [[A_PTR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[COPY_LIST]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
 125 // CHECK:       store i8* [[A_ADDR]], i8** [[A_PTR_REF]],
 126 // CHECK:       [[C_PTR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[COPY_LIST]], i{{[0-9]+}} 0, i{{[0-9]+}} 1
 127 // CHECK:       store i8* {{.+}}, i8** [[C_PTR_REF]],
 128 // CHECK:       [[TC_PTR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[COPY_LIST]], i{{[0-9]+}} 0, i{{[0-9]+}} 2
 129 // CHECK:       [[TC_THREADPRIVATE_ADDR_VOID_PTR:%.+]] = call{{.*}} i8* @__kmpc_threadprivate_cached
 130 // CHECK:       [[TC_THREADPRIVATE_ADDR:%.+]] = bitcast i8* [[TC_THREADPRIVATE_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
 131 // CHECK:       [[TC_PTR_REF_VOID_PTR:%.+]] = bitcast [[TEST_CLASS_TY]]* [[TC_THREADPRIVATE_ADDR]] to i8*
 132 // CHECK:       store i8* [[TC_PTR_REF_VOID_PTR]], i8** [[TC_PTR_REF]],
 133 // CHECK:       [[A2_PTR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[COPY_LIST]], i{{[0-9]+}} 0, i{{[0-9]+}} 3
 134 // CHECK:       [[BITCAST:%.+]] = bitcast [2 x i8]* [[A2_ADDR]] to i8*
 135 // CHECK:       store i8* [[BITCAST]], i8** [[A2_PTR_REF]],
 136 // CHECK:       [[TC2_PTR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[COPY_LIST]], i{{[0-9]+}} 0, i{{[0-9]+}} 4
 137 // CHECK:       [[TC2_THREADPRIVATE_ADDR_VOID_PTR:%.+]] = call{{.*}} i8* @__kmpc_threadprivate_cached
 138 // CHECK:       [[TC2_THREADPRIVATE_ADDR:%.+]] = bitcast i8* [[TC2_THREADPRIVATE_ADDR_VOID_PTR]] to [2 x [[TEST_CLASS_TY]]]*
 139 // CHECK:       [[TC2_PTR_REF_VOID_PTR:%.+]] = bitcast [2 x [[TEST_CLASS_TY]]]* [[TC2_THREADPRIVATE_ADDR]] to i8*
 140 // CHECK:       store i8* [[TC2_PTR_REF_VOID_PTR]], i8** [[TC2_PTR_REF]],
 141 // CHECK:       [[COPY_LIST_VOID_PTR:%.+]] = bitcast [5 x i8*]* [[COPY_LIST]] to i8*
 142 // CHECK:       [[DID_IT_VAL:%.+]] = load i32, i32* [[DID_IT]],
 143 // CHECK:       call void @__kmpc_copyprivate([[IDENT_T_TY]]* [[DEFAULT_LOC]], i32 [[GTID]], i64 40, i8* [[COPY_LIST_VOID_PTR]], void (i8*, i8*)* [[COPY_FUNC:@.+]], i32 [[DID_IT_VAL]])
 144 // CHECK-NOT:   call {{.+}} @__kmpc_cancel_barrier
 145 #pragma omp single copyprivate(a, c, tc, a2, tc2)
 146   foo();
 147 // CHECK-NOT:   call i32 @__kmpc_single
 148 // CHECK-NOT:   call void @__kmpc_end_single
 149   return a;
 150 }
 151
 152 // CHECK: void [[COPY_FUNC]](i8*, i8*)
 153 // CHECK: store i8* %0, i8** [[DST_ADDR_REF:%.+]],
 154 // CHECK: store i8* %1, i8** [[SRC_ADDR_REF:%.+]],
 155 // CHECK: [[DST_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[DST_ADDR_REF]],
 156 // CHECK: [[DST_ADDR:%.+]] = bitcast i8* [[DST_ADDR_VOID_PTR]] to [5 x i8*]*
 157 // CHECK: [[SRC_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[SRC_ADDR_REF]],
 158 // CHECK: [[SRC_ADDR:%.+]] = bitcast i8* [[SRC_ADDR_VOID_PTR]] to [5 x i8*]*
 159 // CHECK: [[DST_A_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[DST_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
 160 // CHECK: [[DST_A_ADDR:%.+]] = load i8*, i8** [[DST_A_ADDR_REF]],
 161 // CHECK: [[SRC_A_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[SRC_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
 162 // CHECK: [[SRC_A_ADDR:%.+]] = load i8*, i8** [[SRC_A_ADDR_REF]],
 163 // CHECK: [[SRC_A_VAL:%.+]] = load i8, i8* [[SRC_A_ADDR]],
 164 // CHECK: store i8 [[SRC_A_VAL]], i8* [[DST_A_ADDR]],
 165 // CHECK: [[DST_C_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[DST_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 1
 166 // CHECK: [[DST_C_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[DST_C_ADDR_REF]],
 167 // CHECK: [[DST_C_ADDR:%.+]] = bitcast i8* [[DST_C_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
 168 // CHECK: [[SRC_C_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[SRC_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 1
 169 // CHECK: [[SRC_C_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[SRC_C_ADDR_REF]],
 170 // CHECK: [[SRC_C_ADDR:%.+]] = bitcast i8* [[SRC_C_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
 171 // CHECK: call{{.*}} [[TEST_CLASS_TY_ASSIGN:@.+]]([[TEST_CLASS_TY]]* [[DST_C_ADDR]], [[TEST_CLASS_TY]]* {{.*}}[[SRC_C_ADDR]])
 172 // CHECK: [[DST_TC_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[DST_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 2
 173 // CHECK: [[DST_TC_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[DST_TC_ADDR_REF]],
 174 // CHECK: [[DST_TC_ADDR:%.+]] = bitcast i8* [[DST_TC_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
 175 // CHECK: [[SRC_TC_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[SRC_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 2
 176 // CHECK: [[SRC_TC_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[SRC_TC_ADDR_REF]],
 177 // CHECK: [[SRC_TC_ADDR:%.+]] = bitcast i8* [[SRC_TC_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
 178 // CHECK: call{{.*}} [[TEST_CLASS_TY_ASSIGN]]([[TEST_CLASS_TY]]* [[DST_TC_ADDR]], [[TEST_CLASS_TY]]* {{.*}}[[SRC_TC_ADDR]])
 179 // CHECK: [[DST_A2_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[DST_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 3
 180 // CHECK: [[DST_A2_ADDR:%.+]] = load i8*, i8** [[DST_A2_ADDR_REF]],
 181 // CHECK: [[SRC_A2_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[SRC_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 3
 182 // CHECK: [[SRC_A2_ADDR:%.+]] = load i8*, i8** [[SRC_A2_ADDR_REF]],
 183 // CHECK: call void @llvm.memcpy.{{.+}}(i8* align 1 [[DST_A2_ADDR]], i8* align 1 [[SRC_A2_ADDR]], i{{[0-9]+}} 2, i1 false)
 184 // CHECK: [[DST_TC2_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[DST_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 4
 185 // CHECK: [[DST_TC2_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[DST_TC2_ADDR_REF]],
 186 // CHECK: [[DST_TC2_ADDR:%.+]] = bitcast i8* [[DST_TC2_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
 187 // CHECK: [[SRC_TC2_ADDR_REF:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[SRC_ADDR]], i{{[0-9]+}} 0, i{{[0-9]+}} 4
 188 // CHECK: [[SRC_TC2_ADDR_VOID_PTR:%.+]] = load i8*, i8** [[SRC_TC2_ADDR_REF]],
 189 // CHECK: [[SRC_TC2_ADDR:%.+]] = bitcast i8* [[SRC_TC2_ADDR_VOID_PTR]] to [[TEST_CLASS_TY]]*
 190 // CHECK: br i1
 191 // CHECK: call{{.*}} [[TEST_CLASS_TY_ASSIGN]]([[TEST_CLASS_TY]]* %{{.+}}, [[TEST_CLASS_TY]]* {{.*}})
 192 // CHECK: br i1
 193 // CHECK: ret void
 194
 195 // CHECK-LABEL:      parallel_single
 196 // TERM_DEBUG-LABEL: parallel_single
 197 void parallel_single() {
 198 #pragma omp parallel
 199 #pragma omp single
 200   // TERM_DEBUG-NOT: __kmpc_global_thread_num
 201   // TERM_DEBUG:     call i32 @__kmpc_single({{.+}}), !dbg [[DBG_LOC_START:![0-9]+]]
 202   // TERM_DEBUG:     invoke void {{.*}}foo{{.*}}()
 203   // TERM_DEBUG:     unwind label %[[TERM_LPAD:.+]],
 204   // TERM_DEBUG-NOT: __kmpc_global_thread_num
 205   // TERM_DEBUG:     call void @__kmpc_end_single({{.+}}), !dbg [[DBG_LOC_END:![0-9]+]]
 206   // TERM_DEBUG:     [[TERM_LPAD]]
 207   // TERM_DEBUG:     call void @__clang_call_terminate
 208   // TERM_DEBUG:     unreachable
 209   foo();
 210 }
 211 // TERM_DEBUG-DAG: [[DBG_LOC_START]] = !DILocation(line: [[@LINE-12]],
 212 // TERM_DEBUG-DAG: [[DBG_LOC_END]] = !DILocation(line: [[@LINE-3]],
 213 #endif
 214 #else
 215 // ARRAY-LABEL: array_func
 216 struct St {
 217   int a, b;
 218   St() : a(0), b(0) {}
 219   St &operator=(const St &) { return *this; };
 220   ~St() {}
 221 };
 222
 223 void array_func(int n, int a[n], St s[2]) {
 224 // ARRAY: call void @__kmpc_copyprivate(%struct.ident_t* @{{.+}}, i32 %{{.+}}, i64 16, i8* %{{.+}}, void (i8*, i8*)* [[CPY:@.+]], i32 %{{.+}})
 225 #pragma omp single copyprivate(a, s)
 226   ;
 227 }
 228 // ARRAY: define internal void [[CPY]]
 229 // ARRAY: store i32* %{{.+}}, i32** %{{.+}},
 230 // ARRAY: store %struct.St* %{{.+}}, %struct.St** %{{.+}},
 231 #endif
 232
 233 // CHECK-LABEL:@_ZN2SSC2ERi(
 234 // CHECK: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* @{{.+}}, i32 4, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, [[SS_TY]]*, i64, i64, i64)* [[SS_MICROTASK:@.+]] to void
 235 // CHECK-NEXT: ret void
 236
 237 // CHECK: define internal void [[SS_MICROTASK]](i32* {{[^,]+}}, i32* {{[^,]+}}, [[SS_TY]]* {{.+}}, i64 {{.+}}, i64 {{.+}}, i64 {{.+}})
 238 // Private a
 239 // CHECK: alloca i64,
 240 // Private b
 241 // CHECK: alloca i64,
 242 // Private c
 243 // CHECK: alloca i64,
 244 // CHECK: alloca i32*,
 245 // CHECK: alloca i32*,
 246 // CHECK: alloca i32*,
 247 // CHECK: alloca i32*,
 248 // CHECK: [[DID_IT:%.+]] = alloca i32,
 249 // CHECK: bitcast i64* %{{.+}} to i32*
 250 // CHECK: bitcast i64* %{{.+}} to i32*
 251 // CHECK: bitcast i64* %{{.+}} to i32*
 252 // CHECK: store i32 0, i32* [[DID_IT]],
 253 // CHECK: [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
 254 // CHECK-NEXT: icmp ne i32 [[RES]], 0
 255 // CHECK-NEXT: br i1
 256
 257 // CHECK: getelementptr inbounds [[CAP_TY:%.+]], [[CAP_TY]]* [[CAP:%.+]], i32 0, i32 0
 258 // CHECK: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 1
 259 // CHECK-NEXT: load i32*, i32** %
 260 // CHECK-NEXT: store i32* %
 261 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 2
 262 // CHECK-NEXT: store i32* %
 263 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 3
 264 // CHECK-NEXT: load i32*, i32** %
 265 // CHECK-NEXT: store i32* %
 266 // CHECK-LABEL: invoke void @_ZZN2SSC1ERiENKUlvE_clEv(
 267 // CHECK-SAME: [[CAP_TY]]* [[CAP]])
 268
 269 // CHECK: call void @__kmpc_end_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
 270 // CHECK: store i32 1, i32* [[DID_IT]],
 271 // CHECK: br label
 272
 273 // CHECK: call void @__kmpc_end_single(%{{.+}}* @{{.+}}, i32 %{{.+}})
 274 // CHECK: br label
 275
 276 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST:%.+]], i64 0, i64 0
 277 // CHECK: load i32*, i32** %
 278 // CHECK-NEXT: bitcast i32* %
 279 // CHECK-NEXT: store i8* %
 280 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST]], i64 0, i64 1
 281 // CHECK-NEXT: bitcast i32* %
 282 // CHECK-NEXT: store i8* %
 283 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST]], i64 0, i64 2
 284 // CHECK: load i32*, i32** %
 285 // CHECK-NEXT: bitcast i32* %
 286 // CHECK-NEXT: store i8* %
 287 // CHECK-NEXT: bitcast [3 x i8*]* [[LIST]] to i8*
 288 // CHECK-NEXT: load i32, i32* [[DID_IT]],
 289 // CHECK-NEXT: call void @__kmpc_copyprivate([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}}, i64 24, i8* %{{.+}}, void (i8*, i8*)* [[COPY_FUNC:@[^,]+]], i32 %{{.+}})
 290 // CHECK-NEXT: ret void
 291
 292 // CHECK-LABEL: @_ZZN2SSC1ERiENKUlvE_clEv(
 293 // CHECK: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP:%.+]], i32 0, i32 1
 294 // CHECK-NEXT: load i32*, i32** %
 295 // CHECK-NEXT: load i32, i32* %
 296 // CHECK-NEXT: add nsw i32 %{{.+}}, 1
 297 // CHECK-NEXT: store i32 %
 298 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 2
 299 // CHECK-NEXT: load i32*, i32** %
 300 // CHECK-NEXT: load i32, i32* %
 301 // CHECK-NEXT: add nsw i32 %{{.+}}, -1
 302 // CHECK-NEXT: store i32 %
 303 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 3
 304 // CHECK-NEXT: load i32*, i32** %
 305 // CHECK-NEXT: load i32, i32* %
 306 // CHECK-NEXT: sdiv i32 %{{.+}}, 1
 307 // CHECK-NEXT: store i32 %
 308 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 1
 309 // CHECK-NEXT: load i32*, i32** %
 310 // CHECK-NEXT: load i32, i32* %
 311 // CHECK-NEXT: bitcast i64* %
 312 // CHECK-NEXT: store i32 %{{.+}}, i32* %
 313 // CHECK-NEXT: load i64, i64* %
 314 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 2
 315 // CHECK-NEXT: load i32*, i32** %
 316 // CHECK-NEXT: load i32, i32* %
 317 // CHECK-NEXT: bitcast i64* %
 318 // CHECK-NEXT: store i32 %{{.+}}, i32* %
 319 // CHECK-NEXT: load i64, i64* %
 320 // CHECK-NEXT: getelementptr inbounds [[CAP_TY]], [[CAP_TY]]* [[CAP]], i32 0, i32 3
 321 // CHECK-NEXT: load i32*, i32** %
 322 // CHECK-NEXT: load i32, i32* %
 323 // CHECK-NEXT: bitcast i64* %
 324 // CHECK-NEXT: store i32 %{{.+}}, i32* %
 325 // CHECK-NEXT: load i64, i64* %
 326 // CHECK-NEXT: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* @{{.+}}, i32 4, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, [[SS_TY]]*, i64, i64, i64)* [[SS_MICROTASK1:@.+]] to void
 327 // CHECK-NEXT: ret void
 328
 329 // CHECK: define internal void [[COPY_FUNC]](i8*, i8*)
 330 // CHECK: ret void
 331
 332 // CHECK: define internal void [[SS_MICROTASK1]](i32* {{[^,]+}}, i32* {{[^,]+}}, [[SS_TY]]* {{.+}}, i64 {{.+}}, i64 {{.+}}, i64 {{.+}})
 333 // Private a
 334 // CHECK: alloca i64,
 335 // Private b
 336 // CHECK: alloca i64,
 337 // Private c
 338 // CHECK: alloca i64,
 339 // CHECK: alloca i32*,
 340 // CHECK: alloca i32*,
 341 // CHECK: alloca i32*,
 342 // CHECK: alloca i32*,
 343 // CHECK: [[DID_IT:%.+]] = alloca i32,
 344 // CHECK: bitcast i64* %{{.+}} to i32*
 345 // CHECK: bitcast i64* %{{.+}} to i32*
 346 // CHECK: bitcast i64* %{{.+}} to i32*
 347 // CHECK: [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
 348 // CHECK-NEXT: icmp ne i32 [[RES]], 0
 349 // CHECK-NEXT: br i1
 350
 351 // CHECK-NOT: getelementptr inbounds
 352 // CHECK: load i32*, i32** %
 353 // CHECK-NEXT: load i32, i32* %
 354 // CHECK-NEXT: add nsw i32 %{{.+}}, 1
 355 // CHECK-NEXT: store i32 %
 356 // CHECK-NOT: getelementptr inbounds
 357 // CHECK: load i32, i32* %
 358 // CHECK-NEXT: add nsw i32 %{{.+}}, -1
 359 // CHECK-NEXT: store i32 %
 360 // CHECK-NOT: getelementptr inbounds
 361 // CHECK: load i32*, i32** %
 362 // CHECK-NEXT: load i32, i32* %
 363 // CHECK-NEXT: sdiv i32 %{{.+}}, 1
 364 // CHECK-NEXT: store i32 %
 365 // CHECK-NEXT: call void @__kmpc_end_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
 366 // CHECK-NEXT: store i32 1, i32* [[DID_IT]],
 367 // CHECK-NEXT: br label
 368
 369 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST:%.+]], i64 0, i64 0
 370 // CHECK: load i32*, i32** %
 371 // CHECK-NEXT: bitcast i32* %
 372 // CHECK-NEXT: store i8* %
 373 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST]], i64 0, i64 1
 374 // CHECK-NEXT: bitcast i32* %
 375 // CHECK-NEXT: store i8* %
 376 // CHECK: getelementptr inbounds [3 x i8*], [3 x i8*]* [[LIST]], i64 0, i64 2
 377 // CHECK: load i32*, i32** %
 378 // CHECK-NEXT: bitcast i32* %
 379 // CHECK-NEXT: store i8* %
 380 // CHECK-NEXT: bitcast [3 x i8*]* [[LIST]] to i8*
 381 // CHECK-NEXT: load i32, i32* [[DID_IT]],
 382 // CHECK-NEXT: call void @__kmpc_copyprivate([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}}, i64 24, i8* %{{.+}}, void (i8*, i8*)* [[COPY_FUNC:@[^,]+]], i32 %{{.+}})
 383 // CHECK-NEXT:  ret void
 384
 385 // CHECK: define internal void [[COPY_FUNC]](i8*, i8*)
 386 // CHECK: ret void
 387
 388 // CHECK-LABEL: @_ZN3SSTIdEC2Ev
 389 // CHECK: getelementptr inbounds [[SST_TY]], [[SST_TY]]* %{{.+}}, i32 0, i32 0
 390 // CHECK-NEXT: store double 0.000000e+00, double* %
 391 // CHECK-NEXT: getelementptr inbounds [[SST_TY]], [[SST_TY]]* %{{.+}}, i32 0, i32 0
 392 // CHECK-NEXT: store double* %{{.+}}, double** %
 393 // CHECK-NEXT: load double*, double** %
 394 // CHECK-NEXT: load double, double* %
 395 // CHECK-NEXT: bitcast i64* %{{.+}} to double*
 396 // CHECK-NEXT: store double %{{.+}}, double* %
 397 // CHECK-NEXT: load i64, i64* %
 398 // CHECK-NEXT: call void ([[IDENT_T_TY]]*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call([[IDENT_T_TY]]* @{{.+}}, i32 2, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, [[SST_TY]]*, i64)* [[SST_MICROTASK:@.+]] to void
 399 // CHECK-NEXT: ret void
 400
 401 // CHECK: define internal void [[SST_MICROTASK]](i32* {{[^,]+}}, i32* {{[^,]+}}, [[SST_TY]]* {{.+}}, i64 {{.+}})
 402 // CHECK: [[RES:%.+]] = call i32 @__kmpc_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
 403 // CHECK-NEXT: icmp ne i32 [[RES]], 0
 404 // CHECK-NEXT: br i1
 405
 406 // CHECK: getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i32 0, i32 1
 407 // CHECK-NEXT: load double*, double** %
 408 // CHECK-NEXT: store double* %
 409 // CHECK-LABEL: invoke void @_ZZN3SSTIdEC1EvENKUlvE_clEv(
 410
 411 // CHECK: call void @__kmpc_end_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
 412 // CHECK-NEXT: store i32 1, i32* [[DID_IT]],
 413 // CHECK-NEXT: br label
 414
 415 // CHECK: call void @__kmpc_end_single([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}})
 416 // CHECK-NEXT: br label
 417
 418 // CHECK: getelementptr inbounds [1 x i8*], [1 x i8*]* [[LIST:%.+]], i64 0, i64 0
 419 // CHECK: load double*, double** %
 420 // CHECK-NEXT: bitcast double* %
 421 // CHECK-NEXT: store i8* %
 422 // CHECK-NEXT: bitcast [1 x i8*]* [[LIST]] to i8*
 423 // CHECK-NEXT: load i32, i32* [[DID_IT]],
 424 // CHECK-NEXT: call void @__kmpc_copyprivate([[IDENT_T_TY]]* @{{.+}}, i32 %{{.+}}, i64 8, i8* %{{.+}}, void (i8*, i8*)* [[COPY_FUNC:@[^,]+]], i32 %{{.+}})
 425 // CHECK-NEXT:  ret void
 426
 427 // CHECK-LABEL: @_ZZN3SSTIdEC1EvENKUlvE_clEv(
 428 // CHECK: getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i32 0, i32 1
 429 // CHECK-NEXT: getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i32 0, i32 1
 430 // CHECK-NEXT: load double*, double** %
 431 // CHECK-NEXT: store double* %
 432 // CHECK-LABEL: call void @_ZZZN3SSTIdEC1EvENKUlvE_clEvENKUlvE_clEv(
 433 // CHECK-NEXT: ret void
 434
 435 // CHECK: define internal void [[COPY_FUNC]](i8*, i8*)
 436 // CHECK: ret void
 437
 438 // CHECK-LABEL: @_ZZZN3SSTIdEC1EvENKUlvE_clEvENKUlvE_clEv(