test/OpenMP/target_codegen_global_capture.cpp

   1 // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-64
   2 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s
   3 // RUN: %clang_cc1 -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-64
   4 // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-32
   5 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -o %t %s
   6 // RUN: %clang_cc1 -fopenmp -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-32
   7
   8 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s
   9 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s
  10 // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s
  11 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s
  12 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -o %t %s
  13 // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s
  14 // SIMD-ONLY0-NOT: {{__kmpc|__tgt}}
  15 // expected-no-diagnostics
  16 #ifndef HEADER
  17 #define HEADER
  18
  19
  20 // CHECK-DAG: [[GA:@.+]] = global double 1.000000e+00
  21 // CHECK-DAG: [[GB:@.+]] = global double 2.000000e+00
  22 // CHECK-DAG: [[GC:@.+]] = global double 3.000000e+00
  23 // CHECK-DAG: [[GD:@.+]] = global double 4.000000e+00
  24 // CHECK-DAG: [[FA:@.+]] = internal global float 5.000000e+00
  25 // CHECK-DAG: [[FB:@.+]] = internal global float 6.000000e+00
  26 // CHECK-DAG: [[FC:@.+]] = internal global float 7.000000e+00
  27 // CHECK-DAG: [[FD:@.+]] = internal global float 8.000000e+00
  28 // CHECK-DAG: [[BA:@.+]] = internal global float 9.000000e+00
  29 // CHECK-DAG: [[BB:@.+]] = internal global float 1.000000e+01
  30 // CHECK-DAG: [[BC:@.+]] = internal global float 1.100000e+01
  31 // CHECK-DAG: [[BD:@.+]] = internal global float 1.200000e+01
  32 // CHECK-DAG: [[TBA:@.+]] = {{.*}}global float 1.700000e+01
  33 // CHECK-DAG: [[TBB:@.+]] = {{.*}}global float 1.800000e+01
  34 // CHECK-DAG: [[TBC:@.+]] = {{.*}}global float 1.900000e+01
  35 // CHECK-DAG: [[TBD:@.+]] = {{.*}}global float 2.000000e+01
  36
  37 double Ga = 1.0;
  38 double Gb = 2.0;
  39 double Gc = 3.0;
  40 double Gd = 4.0;
  41
  42 // CHECK: define {{.*}} @{{.*}}foo{{.*}}(
  43 // CHECK-SAME: i16 {{[^,]*}}[[A:%[^,]+]],
  44 // CHECK-SAME: i16 {{[^,]*}}[[B:%[^,]+]],
  45 // CHECK-SAME: i16 {{[^,]*}}[[C:%[^,]+]],
  46 // CHECK-SAME: i16 {{[^,]*}}[[D:%[^,]+]])
  47 // CHECK: [[LA:%.+]] = alloca i16,
  48 // CHECK: [[LB:%.+]] = alloca i16,
  49 // CHECK: [[LC:%.+]] = alloca i16,
  50 // CHECK: [[LD:%.+]] = alloca i16,
  51 int foo(short a, short b, short c, short d){
  52   static float Sa = 5.0;
  53   static float Sb = 6.0;
  54   static float Sc = 7.0;
  55   static float Sd = 8.0;
  56
  57   // CHECK-DAG:    [[VALLB:%.+]] = load i16, i16* [[LB]],
  58   // CHECK-64-DAG: [[VALGB:%.+]] = load double, double* [[GB]],
  59   // CHECK-DAG:    [[VALFB:%.+]] = load float, float* [[FB]],
  60   // CHECK-64-DAG: [[VALGC:%.+]] = load double, double* [[GC]],
  61   // CHECK-DAG:    [[VALLC:%.+]] = load i16, i16* [[LC]],
  62   // CHECK-DAG:    [[VALFC:%.+]] = load float, float* [[FC]],
  63   // CHECK-DAG:    [[VALLD:%.+]] = load i16, i16* [[LD]],
  64   // CHECK-64-DAG: [[VALGD:%.+]] = load double, double* [[GD]],
  65   // CHECK-DAG:    [[VALFD:%.+]] = load float, float* [[FD]],
  66
  67   // 3 local vars being captured.
  68
  69   // CHECK-DAG: store i16 [[VALLB]], i16* [[CONVLB:%.+]],
  70   // CHECK-DAG: [[CONVLB]] = bitcast i[[sz:64|32]]* [[CADDRLB:%.+]] to i16*
  71   // CHECK-DAG: [[CVALLB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLB]],
  72   // CHECK-DAG: store i[[sz]] [[CVALLB]], i[[sz]]* [[CBP:%.+]],
  73   // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPLB:%.+]] to i[[sz]]*
  74   // CHECK-DAG: [[GEPLB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
  75
  76   // CHECK-DAG: store i16 [[VALLC]], i16* [[CONVLC:%.+]],
  77   // CHECK-DAG: [[CONVLC]] = bitcast i[[sz]]* [[CADDRLC:%.+]] to i16*
  78   // CHECK-DAG: [[CVALLC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLC]],
  79   // CHECK-DAG: store i[[sz]] [[CVALLC]], i[[sz]]* [[CBP:%.+]],
  80   // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPLC:%.+]] to i[[sz]]*
  81   // CHECK-DAG: [[GEPLC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
  82
  83   // CHECK-DAG: store i16 [[VALLD]], i16* [[CONVLD:%.+]],
  84   // CHECK-DAG: [[CONVLD]] = bitcast i[[sz]]* [[CADDRLD:%.+]] to i16*
  85   // CHECK-DAG: [[CVALLD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLD]],
  86   // CHECK-DAG: store i[[sz]] [[CVALLD]], i[[sz]]* [[CBP:%.+]],
  87   // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPLD:%.+]] to i[[sz]]*
  88   // CHECK-DAG: [[GEPLD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
  89
  90   // 3 static vars being captured.
  91
  92   // CHECK-DAG: store float [[VALFB]], float* [[CONVFB:%.+]],
  93   // CHECK-DAG: [[CONVFB]] = bitcast i[[sz]]* [[CADDRFB:%.+]] to float*
  94   // CHECK-DAG: [[CVALFB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFB]],
  95   // CHECK-DAG: store i[[sz]] [[CVALFB]], i[[sz]]* [[CBP:%.+]],
  96   // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPFB:%.+]] to i[[sz]]*
  97   // CHECK-DAG: [[GEPFB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
  98
  99   // CHECK-DAG: store float [[VALFC]], float* [[CONVFC:%.+]],
 100   // CHECK-DAG: [[CONVFC]] = bitcast i[[sz]]* [[CADDRFC:%.+]] to float*
 101   // CHECK-DAG: [[CVALFC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFC]],
 102   // CHECK-DAG: store i[[sz]] [[CVALFC]], i[[sz]]* [[CBP:%.+]],
 103   // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPFC:%.+]] to i[[sz]]*
 104   // CHECK-DAG: [[GEPFC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 105
 106   // CHECK-DAG: store float [[VALFD]], float* [[CONVFD:%.+]],
 107   // CHECK-DAG: [[CONVFD]] = bitcast i[[sz]]* [[CADDRFD:%.+]] to float*
 108   // CHECK-DAG: [[CVALFD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFD]],
 109   // CHECK-DAG: store i[[sz]] [[CVALFD]], i[[sz]]* [[CBP:%.+]],
 110   // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPFD:%.+]] to i[[sz]]*
 111   // CHECK-DAG: [[GEPFD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 112
 113   // 3 static global vars being captured.
 114
 115   // CHECK-64-DAG: store double [[VALGB]], double* [[CONVGB:%.+]],
 116   // CHECK-64-DAG: [[CONVGB]] = bitcast i[[sz]]* [[CADDRGB:%.+]] to double*
 117   // CHECK-64-DAG: [[CVALGB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGB]],
 118   // CHECK-64-DAG: store i[[sz]] [[CVALGB]], i[[sz]]* [[CBP:%.+]],
 119   // CHECK-64-DAG: [[CBP]] = bitcast i8** [[GEPGB:%.+]] to i[[sz]]*
 120   // CHECK-32-DAG: store double* @Gb, double** [[CBP:%.+]],
 121   // CHECK-32-DAG: [[CBP]] = bitcast i8** [[GEPGB:%.+]] to double**
 122   // CHECK-DAG: [[GEPGB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 123
 124   // CHECK-64-DAG: store double [[VALGC]], double* [[CONVGC:%.+]],
 125   // CHECK-64-DAG: [[CONVGC]] = bitcast i[[sz]]* [[CADDRGC:%.+]] to double*
 126   // CHECK-64-DAG: [[CVALGC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGC]],
 127   // CHECK-64-DAG: store i[[sz]] [[CVALGC]], i[[sz]]* [[CBP:%.+]],
 128   // CHECK-64-DAG: [[CBP]] = bitcast i8** [[GEPGC:%.+]] to i[[sz]]*
 129   // CHECK-32-DAG: store double* @Gc, double** [[CBP:%.+]],
 130   // CHECK-32-DAG: [[CBP]] = bitcast i8** [[GEPGC:%.+]] to double**
 131   // CHECK-DAG: [[GEPGC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 132
 133   // CHECK-64-DAG: store double [[VALGD]], double* [[CONVGD:%.+]],
 134   // CHECK-64-DAG: [[CONVGD]] = bitcast i[[sz]]* [[CADDRGD:%.+]] to double*
 135   // CHECK-64-DAG: [[CVALGD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGD]],
 136   // CHECK-64-DAG: store i[[sz]] [[CVALGD]], i[[sz]]* [[CBP:%.+]],
 137   // CHECK-64-DAG: [[CBP]] = bitcast i8** [[GEPGD:%.+]] to i[[sz]]*
 138   // CHECK-32-DAG: store double* @Gd, double** [[CBP:%.+]],
 139   // CHECK-32-DAG: [[CBP]] = bitcast i8** [[GEPGD:%.+]] to double**
 140   // CHECK-DAG: [[GEPGD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 141
 142   // CHECK: call i32 @__tgt_target
 143   // CHECK: call void [[OFFLOADF:@.+]](
 144   // Capture b, Gb, Sb, Gc, c, Sc, d, Gd, Sd
 145   #pragma omp target if(Ga>0.0 && a>0 && Sa>0.0)
 146   {
 147     b += 1;
 148     Gb += 1.0;
 149     Sb += 1.0;
 150
 151     // CHECK: define internal void [[OFFLOADF]]({{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}})
 152     // The parallel region only uses 3 captures.
 153     // CHECK:     call {{.*}}@__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}}), {{.+}}* %{{.+}}, {{.+}}* %{{.+}}, {{.+}}* %{{.+}})
 154     // CHECK:     call void @.omp_outlined.(i32* %{{.+}}, i32* %{{.+}}, {{.+}}* %{{.+}}, {{.+}}* %{{.+}}, {{.+}}* %{{.+}})
 155     // Capture d, Gd, Sd,
 156
 157     // CHECK: define internal void [[PARF]](i32* noalias %{{.*}}, i32* noalias %{{.*}},
 158     #pragma omp parallel if(Gc>0.0 && c>0 && Sc>0.0)
 159     {
 160       d += 1;
 161       Gd += 1.0;
 162       Sd += 1.0;
 163     }
 164   }
 165   return a + b + c + d + (int)Sa + (int)Sb + (int)Sc + (int)Sd;
 166 }
 167
 168 // CHECK: define {{.*}} @{{.*}}bar{{.*}}(
 169 // CHECK-SAME: i16 {{[^,]*}}[[A:%[^,]+]],
 170 // CHECK-SAME: i16 {{[^,]*}}[[B:%[^,]+]],
 171 // CHECK-SAME: i16 {{[^,]*}}[[C:%[^,]+]],
 172 // CHECK-SAME: i16 {{[^,]*}}[[D:%[^,]+]])
 173 // CHECK: [[LA:%.+]] = alloca i16
 174 // CHECK: [[LB:%.+]] = alloca i16
 175 // CHECK: [[LC:%.+]] = alloca i16
 176 // CHECK: [[LD:%.+]] = alloca i16
 177 int bar(short a, short b, short c, short d){
 178   static float Sa = 9.0;
 179   static float Sb = 10.0;
 180   static float Sc = 11.0;
 181   static float Sd = 12.0;
 182
 183   // CHECK: call void {{.*}}@__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}}), i16* %{{.+}}, i16* %{{.+}}, i16* %{{.+}}, i16* %{{.+}})
 184   // CHECK: define internal void [[PARF]](i32* noalias %{{.*}}, i32* noalias %{{.*}}, i16* dereferenceable(2) [[A:%.+]], i16* dereferenceable(2) [[B:%.+]], i16* dereferenceable(2) [[C:%.+]], i16* dereferenceable(2) [[D:%.+]])
 185   // Capture a, b, c, d
 186   // CHECK: [[ALLOCLA:%.+]] = alloca i16
 187   // CHECK: [[ALLOCLB:%.+]] = alloca i16
 188   // CHECK: [[ALLOCLC:%.+]] = alloca i16
 189   // CHECK: [[ALLOCLD:%.+]] = alloca i16
 190   // CHECK: [[LLA:%.+]] = load i16*, i16** [[ALLOCLA]],
 191   // CHECK: [[LLB:%.+]] = load i16*, i16** [[ALLOCLB]],
 192   // CHECK: [[LLC:%.+]] = load i16*, i16** [[ALLOCLC]],
 193   // CHECK: [[LLD:%.+]] = load i16*, i16** [[ALLOCLD]],
 194   #pragma omp parallel
 195   {
 196     // CHECK-DAG:    [[VALLB:%.+]] = load i16, i16* [[LLB]],
 197     // CHECK-64-DAG: [[VALGB:%.+]] = load double, double* [[GB]],
 198     // CHECK-DAG:    [[VALFB:%.+]] = load float, float* [[BB]],
 199     // CHECK-64-DAG: [[VALGC:%.+]] = load double, double* [[GC]],
 200     // CHECK-DAG:    [[VALLC:%.+]] = load i16, i16* [[LLC]],
 201     // CHECK-DAG:    [[VALFC:%.+]] = load float, float* [[BC]],
 202     // CHECK-DAG:    [[VALLD:%.+]] = load i16, i16* [[LLD]],
 203     // CHECK-64-DAG: [[VALGD:%.+]] = load double, double* [[GD]],
 204     // CHECK-DAG:    [[VALFD:%.+]] = load float, float* [[BD]],
 205
 206     // 3 local vars being captured.
 207
 208     // CHECK-DAG: store i16 [[VALLB]], i16* [[CONVLB:%.+]],
 209     // CHECK-DAG: [[CONVLB]] = bitcast i[[sz:64|32]]* [[CADDRLB:%.+]] to i16*
 210     // CHECK-DAG: [[CVALLB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLB]],
 211     // CHECK-DAG: store i[[sz]] [[CVALLB]], i[[sz]]* [[CBP:%.+]],
 212     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPLB:%.+]] to i[[sz]]*
 213     // CHECK-DAG: [[GEPLB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 214
 215     // CHECK-DAG: store i16 [[VALLC]], i16* [[CONVLC:%.+]],
 216     // CHECK-DAG: [[CONVLC]] = bitcast i[[sz]]* [[CADDRLC:%.+]] to i16*
 217     // CHECK-DAG: [[CVALLC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLC]],
 218     // CHECK-DAG: store i[[sz]] [[CVALLC]], i[[sz]]* [[CBP:%.+]],
 219     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPLC:%.+]] to i[[sz]]*
 220     // CHECK-DAG: [[GEPLC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 221
 222     // CHECK-DAG: store i16 [[VALLD]], i16* [[CONVLD:%.+]],
 223     // CHECK-DAG: [[CONVLD]] = bitcast i[[sz]]* [[CADDRLD:%.+]] to i16*
 224     // CHECK-DAG: [[CVALLD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLD]],
 225     // CHECK-DAG: store i[[sz]] [[CVALLD]], i[[sz]]* [[CBP:%.+]],
 226     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPLD:%.+]] to i[[sz]]*
 227     // CHECK-DAG: [[GEPLD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 228
 229     // 3 static vars being captured.
 230
 231     // CHECK-DAG: store float [[VALFB]], float* [[CONVFB:%.+]],
 232     // CHECK-DAG: [[CONVFB]] = bitcast i[[sz]]* [[CADDRFB:%.+]] to float*
 233     // CHECK-DAG: [[CVALFB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFB]],
 234     // CHECK-DAG: store i[[sz]] [[CVALFB]], i[[sz]]* [[CBP:%.+]],
 235     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPFB:%.+]] to i[[sz]]*
 236     // CHECK-DAG: [[GEPFB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 237
 238     // CHECK-DAG: store float [[VALFC]], float* [[CONVFC:%.+]],
 239     // CHECK-DAG: [[CONVFC]] = bitcast i[[sz]]* [[CADDRFC:%.+]] to float*
 240     // CHECK-DAG: [[CVALFC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFC]],
 241     // CHECK-DAG: store i[[sz]] [[CVALFC]], i[[sz]]* [[CBP:%.+]],
 242     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPFC:%.+]] to i[[sz]]*
 243     // CHECK-DAG: [[GEPFC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 244
 245     // CHECK-DAG: store float [[VALFD]], float* [[CONVFD:%.+]],
 246     // CHECK-DAG: [[CONVFD]] = bitcast i[[sz]]* [[CADDRFD:%.+]] to float*
 247     // CHECK-DAG: [[CVALFD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFD]],
 248     // CHECK-DAG: store i[[sz]] [[CVALFD]], i[[sz]]* [[CBP:%.+]],
 249     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPFD:%.+]] to i[[sz]]*
 250     // CHECK-DAG: [[GEPFD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 251
 252     // 3 static global vars being captured.
 253
 254     // CHECK-64-DAG: store double [[VALGB]], double* [[CONVGB:%.+]],
 255     // CHECK-64-DAG: [[CONVGB]] = bitcast i[[sz]]* [[CADDRGB:%.+]] to double*
 256     // CHECK-64-DAG: [[CVALGB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGB]],
 257     // CHECK-64-DAG: store i[[sz]] [[CVALGB]], i[[sz]]* [[CBP:%.+]],
 258     // CHECK-64-DAG: [[CBP]] = bitcast i8** [[GEPGB:%.+]] to i[[sz]]*
 259     // CHECK-32-DAG: store double* @Gb, double** [[CBP:%.+]],
 260     // CHECK-32-DAG: [[CBP]] = bitcast i8** [[GEPGB:%.+]] to double**
 261     // CHECK-DAG: [[GEPGB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 262
 263     // CHECK-64-DAG: store double [[VALGC]], double* [[CONVGC:%.+]],
 264     // CHECK-64-DAG: [[CONVGC]] = bitcast i[[sz]]* [[CADDRGC:%.+]] to double*
 265     // CHECK-64-DAG: [[CVALGC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGC]],
 266     // CHECK-64-DAG: store i[[sz]] [[CVALGC]], i[[sz]]* [[CBP:%.+]],
 267     // CHECK-64-DAG: [[CBP]] = bitcast i8** [[GEPGC:%.+]] to i[[sz]]*
 268     // CHECK-32-DAG: store double* @Gc, double** [[CBP:%.+]],
 269     // CHECK-32-DAG: [[CBP]] = bitcast i8** [[GEPGC:%.+]] to double**
 270     // CHECK-DAG: [[GEPGC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 271
 272     // CHECK-64-DAG: store double [[VALGD]], double* [[CONVGD:%.+]],
 273     // CHECK-64-DAG: [[CONVGD]] = bitcast i[[sz]]* [[CADDRGD:%.+]] to double*
 274     // CHECK-64-DAG: [[CVALGD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGD]],
 275     // CHECK-64-DAG: store i[[sz]] [[CVALGD]], i[[sz]]* [[CBP:%.+]],
 276     // CHECK-64-DAG: [[CBP]] = bitcast i8** [[GEPGD:%.+]] to i[[sz]]*
 277     // CHECK-32-DAG: store double* @Gd, double** [[CBP:%.+]],
 278     // CHECK-32-DAG: [[CBP]] = bitcast i8** [[GEPGD:%.+]] to double**
 279     // CHECK-DAG: [[GEPGD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 280
 281     // CHECK: call i32 @__tgt_target
 282     // CHECK: call void [[OFFLOADF:@.+]](
 283     // Capture b, Gb, Sb, Gc, c, Sc, d, Gd, Sd
 284     #pragma omp target if(Ga>0.0 && a>0 && Sa>0.0)
 285     {
 286       b += 1;
 287       Gb += 1.0;
 288       Sb += 1.0;
 289
 290       // CHECK: define internal void [[OFFLOADF]]({{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}})
 291       // CHECK: call void {{.*}}@__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}})
 292
 293       // CHECK: define internal void [[PARF]](i32* noalias %{{.*}}, i32* noalias %{{.*}}, {{.+}}* dereferenceable({{.+}}) %{{.+}}, {{.+}}* dereferenceable({{.+}}) %{{.+}}, {{.+}}* dereferenceable({{.+}}) %{{.+}})
 294       // Capture d, Gd, Sd
 295       #pragma omp parallel if(Gc>0.0 && c>0 && Sc>0.0)
 296       {
 297         d += 1;
 298         Gd += 1.0;
 299         Sd += 1.0;
 300       }
 301     }
 302   }
 303   return a + b + c + d + (int)Sa + (int)Sb + (int)Sc + (int)Sd;
 304 }
 305
 306 ///
 307 /// Tests with template functions.
 308 ///
 309
 310 // CHECK: define {{.*}} @{{.*}}tbar2{{.*}}(
 311
 312 // CHECK: define {{.*}} @{{.*}}tbar{{.*}}(
 313 // CHECK-SAME: i16 {{[^,]*}}[[A:%[^,]+]],
 314 // CHECK-SAME: i16 {{[^,]*}}[[B:%[^,]+]],
 315 // CHECK-SAME: i16 {{[^,]*}}[[C:%[^,]+]],
 316 // CHECK-SAME: i16 {{[^,]*}}[[D:%[^,]+]])
 317 // CHECK: [[LA:%.+]] = alloca i16
 318 // CHECK: [[LB:%.+]] = alloca i16
 319 // CHECK: [[LC:%.+]] = alloca i16
 320 // CHECK: [[LD:%.+]] = alloca i16
 321 template<typename T>
 322 int tbar(T a, T b, T c, T d){
 323   static float Sa = 17.0;
 324   static float Sb = 18.0;
 325   static float Sc = 19.0;
 326   static float Sd = 20.0;
 327
 328   // CHECK: call void {{.*}}@__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}}), i16* %{{.+}}, i16* %{{.+}}, i16* %{{.+}}, i16* %{{.+}})
 329   // CHECK: define internal void [[PARF]](i32* noalias %{{.*}}, i32* noalias %{{.*}}, i16* dereferenceable(2) [[A:%.+]], i16* dereferenceable(2) [[B:%.+]], i16* dereferenceable(2) [[C:%.+]], i16* dereferenceable(2) [[D:%.+]])
 330   // Capture a, b, c, d
 331   // CHECK: [[ALLOCLA:%.+]] = alloca i16
 332   // CHECK: [[ALLOCLB:%.+]] = alloca i16
 333   // CHECK: [[ALLOCLC:%.+]] = alloca i16
 334   // CHECK: [[ALLOCLD:%.+]] = alloca i16
 335   // CHECK: [[LLA:%.+]] = load i16*, i16** [[ALLOCLA]],
 336   // CHECK: [[LLB:%.+]] = load i16*, i16** [[ALLOCLB]],
 337   // CHECK: [[LLC:%.+]] = load i16*, i16** [[ALLOCLC]],
 338   // CHECK: [[LLD:%.+]] = load i16*, i16** [[ALLOCLD]],
 339   #pragma omp parallel
 340   {
 341     // CHECK-DAG:    [[VALLB:%.+]] = load i16, i16* [[LLB]],
 342     // CHECK-64-DAG: [[VALGB:%.+]] = load double, double* [[GB]],
 343     // CHECK-DAG:    [[VALFB:%.+]] = load float, float* [[TBB]],
 344     // CHECK-64-DAG: [[VALGC:%.+]] = load double, double* [[GC]],
 345     // CHECK-DAG:    [[VALLC:%.+]] = load i16, i16* [[LLC]],
 346     // CHECK-DAG:    [[VALFC:%.+]] = load float, float* [[TBC]],
 347     // CHECK-DAG:    [[VALLD:%.+]] = load i16, i16* [[LLD]],
 348     // CHECK-64-DAG: [[VALGD:%.+]] = load double, double* [[GD]],
 349     // CHECK-DAG:    [[VALFD:%.+]] = load float, float* [[TBD]],
 350
 351     // 3 local vars being captured.
 352
 353     // CHECK-DAG: store i16 [[VALLB]], i16* [[CONVLB:%.+]],
 354     // CHECK-DAG: [[CONVLB]] = bitcast i[[sz:64|32]]* [[CADDRLB:%.+]] to i16*
 355     // CHECK-DAG: [[CVALLB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLB]],
 356     // CHECK-DAG: store i[[sz]] [[CVALLB]], i[[sz]]* [[CBP:%.+]],
 357     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPLB:%.+]] to i[[sz]]*
 358     // CHECK-DAG: [[GEPLB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 359
 360     // CHECK-DAG: store i16 [[VALLC]], i16* [[CONVLC:%.+]],
 361     // CHECK-DAG: [[CONVLC]] = bitcast i[[sz]]* [[CADDRLC:%.+]] to i16*
 362     // CHECK-DAG: [[CVALLC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLC]],
 363     // CHECK-DAG: store i[[sz]] [[CVALLC]], i[[sz]]* [[CBP:%.+]],
 364     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPLC:%.+]] to i[[sz]]*
 365     // CHECK-DAG: [[GEPLC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 366
 367     // CHECK-DAG: store i16 [[VALLD]], i16* [[CONVLD:%.+]],
 368     // CHECK-DAG: [[CONVLD]] = bitcast i[[sz]]* [[CADDRLD:%.+]] to i16*
 369     // CHECK-DAG: [[CVALLD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLD]],
 370     // CHECK-DAG: store i[[sz]] [[CVALLD]], i[[sz]]* [[CBP:%.+]],
 371     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPLD:%.+]] to i[[sz]]*
 372     // CHECK-DAG: [[GEPLD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 373
 374     // 3 static vars being captured.
 375
 376     // CHECK-DAG: store float [[VALFB]], float* [[CONVFB:%.+]],
 377     // CHECK-DAG: [[CONVFB]] = bitcast i[[sz]]* [[CADDRFB:%.+]] to float*
 378     // CHECK-DAG: [[CVALFB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFB]],
 379     // CHECK-DAG: store i[[sz]] [[CVALFB]], i[[sz]]* [[CBP:%.+]],
 380     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPFB:%.+]] to i[[sz]]*
 381     // CHECK-DAG: [[GEPFB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 382
 383     // CHECK-DAG: store float [[VALFC]], float* [[CONVFC:%.+]],
 384     // CHECK-DAG: [[CONVFC]] = bitcast i[[sz]]* [[CADDRFC:%.+]] to float*
 385     // CHECK-DAG: [[CVALFC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFC]],
 386     // CHECK-DAG: store i[[sz]] [[CVALFC]], i[[sz]]* [[CBP:%.+]],
 387     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPFC:%.+]] to i[[sz]]*
 388     // CHECK-DAG: [[GEPFC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 389
 390     // CHECK-DAG: store float [[VALFD]], float* [[CONVFD:%.+]],
 391     // CHECK-DAG: [[CONVFD]] = bitcast i[[sz]]* [[CADDRFD:%.+]] to float*
 392     // CHECK-DAG: [[CVALFD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFD]],
 393     // CHECK-DAG: store i[[sz]] [[CVALFD]], i[[sz]]* [[CBP:%.+]],
 394     // CHECK-DAG: [[CBP]] = bitcast i8** [[GEPFD:%.+]] to i[[sz]]*
 395     // CHECK-DAG: [[GEPFD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 396
 397     // 3 static global vars being captured.
 398
 399     // CHECK-64-DAG: store double [[VALGB]], double* [[CONVGB:%.+]],
 400     // CHECK-64-DAG: [[CONVGB]] = bitcast i[[sz]]* [[CADDRGB:%.+]] to double*
 401     // CHECK-64-DAG: [[CVALGB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGB]],
 402     // CHECK-64-DAG: store i[[sz]] [[CVALGB]], i[[sz]]* [[CBP:%.+]],
 403     // CHECK-64-DAG: [[CBP]] = bitcast i8** [[GEPGB:%.+]] to i[[sz]]*
 404     // CHECK-32-DAG: store double* @Gb, double** [[CBP:%.+]],
 405     // CHECK-32-DAG: [[CBP]] = bitcast i8** [[GEPGB:%.+]] to double**
 406     // CHECK-DAG: [[GEPGB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 407
 408     // CHECK-64-DAG: store double [[VALGC]], double* [[CONVGC:%.+]],
 409     // CHECK-64-DAG: [[CONVGC]] = bitcast i[[sz]]* [[CADDRGC:%.+]] to double*
 410     // CHECK-64-DAG: [[CVALGC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGC]],
 411     // CHECK-64-DAG: store i[[sz]] [[CVALGC]], i[[sz]]* [[CBP:%.+]],
 412     // CHECK-64-DAG: [[CBP]] = bitcast i8** [[GEPGC:%.+]] to i[[sz]]*
 413     // CHECK-32-DAG: store double* @Gc, double** [[CBP:%.+]],
 414     // CHECK-32-DAG: [[CBP]] = bitcast i8** [[GEPGC:%.+]] to double**
 415     // CHECK-DAG: [[GEPGC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 416
 417     // CHECK-64-DAG: store double [[VALGD]], double* [[CONVGD:%.+]],
 418     // CHECK-64-DAG: [[CONVGD]] = bitcast i[[sz]]* [[CADDRGD:%.+]] to double*
 419     // CHECK-64-DAG: [[CVALGD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGD]],
 420     // CHECK-64-DAG: store i[[sz]] [[CVALGD]], i[[sz]]* [[CBP:%.+]],
 421     // CHECK-64-DAG: [[CBP]] = bitcast i8** [[GEPGD:%.+]] to i[[sz]]*
 422     // CHECK-32-DAG: store double* @Gd, double** [[CBP:%.+]],
 423     // CHECK-32-DAG: [[CBP]] = bitcast i8** [[GEPGD:%.+]] to double**
 424     // CHECK-DAG: [[GEPGD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
 425
 426     // CHECK: call i32 @__tgt_target
 427     // CHECK: call void [[OFFLOADF:@.+]](
 428     // Capture b, Gb, Sb, Gc, c, Sc, d, Gd, Sd
 429     #pragma omp target if(Ga>0.0 && a>0 && Sa>0.0)
 430     {
 431       b += 1;
 432       Gb += 1.0;
 433       Sb += 1.0;
 434
 435       // CHECK: define internal void [[OFFLOADF]]({{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}})
 436       // CHECK: call void {{.*}}@__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}})
 437
 438       // CHECK: define internal void [[PARF]](i32* noalias %{{.*}}, i32* noalias %{{.*}}, {{.+}}* dereferenceable({{.+}}) %{{.+}}, {{.+}}* dereferenceable({{.+}}) %{{.+}}, {{.+}}* dereferenceable({{.+}}) %{{.+}})
 439       // Capture d, Gd, Sd
 440       #pragma omp parallel if(Gc>0.0 && c>0 && Sc>0.0)
 441       {
 442         d += 1;
 443         Gd += 1.0;
 444         Sd += 1.0;
 445       }
 446     }
 447   }
 448   return a + b + c + d + (int)Sa + (int)Sb + (int)Sc + (int)Sd;
 449 }
 450
 451 int tbar2(short a, short b, short c, short d){
 452   return tbar(a, b, c, d);
 453 }
 454
 455 #endif