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* nonnull align 2 dereferenceable(2) [[A:%.+]], i16* nonnull align 2 dereferenceable(2) [[B:%.+]], i16* nonnull align 2 dereferenceable(2) [[C:%.+]], i16* nonnull align 2 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 %{{.*}}, {{.+}}* nonnull align {{[0-9]+}} dereferenceable({{.+}}) %{{.+}}, {{.+}}* nonnull align {{[0-9]+}} dereferenceable({{.+}}) %{{.+}}, {{.+}}* nonnull align {{[0-9]+}} 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* nonnull align 2 dereferenceable(2) [[A:%.+]], i16* nonnull align 2 dereferenceable(2) [[B:%.+]], i16* nonnull align 2 dereferenceable(2) [[C:%.+]], i16* nonnull align 2 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 %{{.*}}, {{.+}}* nonnull align {{[0-9]+}} dereferenceable({{.+}}) %{{.+}}, {{.+}}* nonnull align {{[0-9]+}} dereferenceable({{.+}}) %{{.+}}, {{.+}}* nonnull align {{[0-9]+}} 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 456