1 // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -omptargets=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 -omptargets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s
3 // RUN: %clang_cc1 -fopenmp -x c++ -triple powerpc64le-unknown-unknown -omptargets=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 -omptargets=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 -omptargets=i386-pc-linux-gnu -emit-pch -o %t %s
6 // RUN: %clang_cc1 -fopenmp -x c++ -triple i386-unknown-unknown -omptargets=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 // expected-no-diagnostics
8 #ifndef HEADER
9 #define HEADER
10 
11 
12 // CHECK-DAG: [[GA:@.+]] = global double 1.000000e+00
13 // CHECK-DAG: [[GB:@.+]] = global double 2.000000e+00
14 // CHECK-DAG: [[GC:@.+]] = global double 3.000000e+00
15 // CHECK-DAG: [[GD:@.+]] = global double 4.000000e+00
16 // CHECK-DAG: [[FA:@.+]] = internal global float 5.000000e+00
17 // CHECK-DAG: [[FB:@.+]] = internal global float 6.000000e+00
18 // CHECK-DAG: [[FC:@.+]] = internal global float 7.000000e+00
19 // CHECK-DAG: [[FD:@.+]] = internal global float 8.000000e+00
20 // CHECK-DAG: [[BA:@.+]] = internal global float 9.000000e+00
21 // CHECK-DAG: [[BB:@.+]] = internal global float 1.000000e+01
22 // CHECK-DAG: [[BC:@.+]] = internal global float 1.100000e+01
23 // CHECK-DAG: [[BD:@.+]] = internal global float 1.200000e+01
24 double Ga = 1.0;
25 double Gb = 2.0;
26 double Gc = 3.0;
27 double Gd = 4.0;
28 
29 // CHECK: define {{.*}} @{{.*}}foo{{.*}}(
30 // CHECK-SAME: i16 {{[^,]*}}[[A:%[^,]+]],
31 // CHECK-SAME: i16 {{[^,]*}}[[B:%[^,]+]],
32 // CHECK-SAME: i16 {{[^,]*}}[[C:%[^,]+]],
33 // CHECK-SAME: i16 {{[^,]*}}[[D:%[^,]+]])
34 // CHECK: [[LA:%.+]] = alloca i16
35 // CHECK: [[LB:%.+]] = alloca i16
36 // CHECK: [[LC:%.+]] = alloca i16
37 // CHECK: [[LD:%.+]] = alloca i16
38 int foo(short a, short b, short c, short d){
39   static float Sa = 5.0;
40   static float Sb = 6.0;
41   static float Sc = 7.0;
42   static float Sd = 8.0;
43 
44   // CHECK-DAG:    [[VALLB:%.+]] = load i16, i16* [[LB]],
45   // CHECK-64-DAG: [[VALGB:%.+]] = load double, double* @Gb,
46   // CHECK-DAG:    [[VALFB:%.+]] = load float, float* @_ZZ3foossssE2Sb,
47   // CHECK-64-DAG: [[VALGC:%.+]] = load double, double* @Gc,
48   // CHECK-DAG:    [[VALLC:%.+]] = load i16, i16* [[LC]],
49   // CHECK-DAG:    [[VALFC:%.+]] = load float, float* @_ZZ3foossssE2Sc,
50   // CHECK-DAG:    [[VALLD:%.+]] = load i16, i16* [[LD]],
51   // CHECK-64-DAG: [[VALGD:%.+]] = load double, double* @Gd,
52   // CHECK-DAG:    [[VALFD:%.+]] = load float, float* @_ZZ3foossssE2Sd,
53 
54   // 3 local vars being captured.
55 
56   // CHECK-DAG: store i16 [[VALLB]], i16* [[CONVLB:%.+]],
57   // CHECK-DAG: [[CONVLB]] = bitcast i[[sz:64|32]]* [[CADDRLB:%.+]] to i16*
58   // CHECK-DAG: [[CVALLB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLB]],
59   // CHECK-DAG: [[CPTRLB:%.+]] = inttoptr i[[sz]] [[CVALLB]] to i8*
60   // CHECK-DAG: store i8* [[CPTRLB]], i8** [[GEPLB:%.+]],
61   // CHECK-DAG: [[GEPLB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
62 
63   // CHECK-DAG: store i16 [[VALLC]], i16* [[CONVLC:%.+]],
64   // CHECK-DAG: [[CONVLC]] = bitcast i[[sz]]* [[CADDRLC:%.+]] to i16*
65   // CHECK-DAG: [[CVALLC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLC]],
66   // CHECK-DAG: [[CPTRLC:%.+]] = inttoptr i[[sz]] [[CVALLC]] to i8*
67   // CHECK-DAG: store i8* [[CPTRLC]], i8** [[GEPLC:%.+]],
68   // CHECK-DAG: [[GEPLC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
69 
70   // CHECK-DAG: store i16 [[VALLD]], i16* [[CONVLD:%.+]],
71   // CHECK-DAG: [[CONVLD]] = bitcast i[[sz]]* [[CADDRLD:%.+]] to i16*
72   // CHECK-DAG: [[CVALLD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLD]],
73   // CHECK-DAG: [[CPTRLD:%.+]] = inttoptr i[[sz]] [[CVALLD]] to i8*
74   // CHECK-DAG: store i8* [[CPTRLD]], i8** [[GEPLD:%.+]],
75   // CHECK-DAG: [[GEPLD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
76 
77   // 3 static vars being captured.
78 
79   // CHECK-DAG: store float [[VALFB]], float* [[CONVFB:%.+]],
80   // CHECK-DAG: [[CONVFB]] = bitcast i[[sz]]* [[CADDRFB:%.+]] to float*
81   // CHECK-DAG: [[CVALFB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFB]],
82   // CHECK-DAG: [[CPTRFB:%.+]] = inttoptr i[[sz]] [[CVALFB]] to i8*
83   // CHECK-DAG: store i8* [[CPTRFB]], i8** [[GEPFB:%.+]],
84   // CHECK-DAG: [[GEPFB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
85 
86   // CHECK-DAG: store float [[VALFC]], float* [[CONVFC:%.+]],
87   // CHECK-DAG: [[CONVFC]] = bitcast i[[sz]]* [[CADDRFC:%.+]] to float*
88   // CHECK-DAG: [[CVALFC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFC]],
89   // CHECK-DAG: [[CPTRFC:%.+]] = inttoptr i[[sz]] [[CVALFC]] to i8*
90   // CHECK-DAG: store i8* [[CPTRFC]], i8** [[GEPFC:%.+]],
91   // CHECK-DAG: [[GEPFC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
92 
93   // CHECK-DAG: store float [[VALFD]], float* [[CONVFD:%.+]],
94   // CHECK-DAG: [[CONVFD]] = bitcast i[[sz]]* [[CADDRFD:%.+]] to float*
95   // CHECK-DAG: [[CVALFD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFD]],
96   // CHECK-DAG: [[CPTRFD:%.+]] = inttoptr i[[sz]] [[CVALFD]] to i8*
97   // CHECK-DAG: store i8* [[CPTRFD]], i8** [[GEPFD:%.+]],
98   // CHECK-DAG: [[GEPFD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
99 
100   // 3 static global vars being captured.
101 
102   // CHECK-64-DAG: store double [[VALGB]], double* [[CONVGB:%.+]],
103   // CHECK-64-DAG: [[CONVGB]] = bitcast i[[sz]]* [[CADDRGB:%.+]] to double*
104   // CHECK-64-DAG: [[CVALGB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGB]],
105   // CHECK-64-DAG: [[CPTRGB:%.+]] = inttoptr i[[sz]] [[CVALGB]] to i8*
106   // CHECK-64-DAG: store i8* [[CPTRGB]], i8** [[GEPGB:%.+]],
107   // CHECK-32-DAG: store i8* bitcast (double* @Gb to i8*), i8** [[GEPGB:%.+]],
108   // CHECK-DAG: [[GEPGB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
109 
110   // CHECK-64-DAG: store double [[VALGC]], double* [[CONVGC:%.+]],
111   // CHECK-64-DAG: [[CONVGC]] = bitcast i[[sz]]* [[CADDRGC:%.+]] to double*
112   // CHECK-64-DAG: [[CVALGC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGC]],
113   // CHECK-64-DAG: [[CPTRGC:%.+]] = inttoptr i[[sz]] [[CVALGC]] to i8*
114   // CHECK-64-DAG: store i8* [[CPTRGC]], i8** [[GEPGC:%.+]],
115   // CHECK-32-DAG: store i8* bitcast (double* @Gc to i8*), i8** [[GEPGC:%.+]],
116   // CHECK-DAG: [[GEPGC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
117 
118   // CHECK-64-DAG: store double [[VALGD]], double* [[CONVGD:%.+]],
119   // CHECK-64-DAG: [[CONVGD]] = bitcast i[[sz]]* [[CADDRGD:%.+]] to double*
120   // CHECK-64-DAG: [[CVALGD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGD]],
121   // CHECK-64-DAG: [[CPTRGD:%.+]] = inttoptr i[[sz]] [[CVALGD]] to i8*
122   // CHECK-64-DAG: store i8* [[CPTRGD]], i8** [[GEPGD:%.+]],
123   // CHECK-32-DAG: store i8* bitcast (double* @Gd to i8*), i8** [[GEPGD:%.+]],
124   // CHECK-DAG: [[GEPGD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
125 
126   // CHECK: call i32 @__tgt_target
127   // CHECK: call void [[OFFLOADF:@.+]](
128   // Capture b, Gb, Sb, Gc, c, Sc, d, Gd, Sd
129   #pragma omp target if(Ga>0.0 && a>0 && Sa>0.0)
130   {
131     b += 1;
132     Gb += 1.0;
133     Sb += 1.0;
134 
135     // CHECK: define internal void [[OFFLOADF]]({{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}})
136     // The parallel region only uses 3 captures.
137     // CHECK:     call {{.*}}@__kmpc_fork_call(%ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}}), {{.+}}* %{{.+}}, {{.+}}* %{{.+}}, {{.+}}* %{{.+}})
138     // CHECK:     call void @.omp_outlined.(i32* %{{.+}}, i32* %{{.+}}, {{.+}}* %{{.+}}, {{.+}}* %{{.+}}, {{.+}}* %{{.+}})
139     // Capture d, Gd, Sd,
140 
141     // CHECK: define internal void [[PARF]](i32* noalias %{{.*}}, i32* noalias %{{.*}},
142     #pragma omp parallel if(Gc>0.0 && c>0 && Sc>0.0)
143     {
144       d += 1;
145       Gd += 1.0;
146       Sd += 1.0;
147     }
148   }
149   return a + b + c + d + (int)Sa + (int)Sb + (int)Sc + (int)Sd;
150 }
151 
152 // CHECK: define {{.*}} @{{.*}}bar{{.*}}(
153 // CHECK-SAME: i16 {{[^,]*}}[[A:%[^,]+]],
154 // CHECK-SAME: i16 {{[^,]*}}[[B:%[^,]+]],
155 // CHECK-SAME: i16 {{[^,]*}}[[C:%[^,]+]],
156 // CHECK-SAME: i16 {{[^,]*}}[[D:%[^,]+]])
157 // CHECK: [[LA:%.+]] = alloca i16
158 // CHECK: [[LB:%.+]] = alloca i16
159 // CHECK: [[LC:%.+]] = alloca i16
160 // CHECK: [[LD:%.+]] = alloca i16
161 int bar(short a, short b, short c, short d){
162   static float Sa = 9.0;
163   static float Sb = 10.0;
164   static float Sc = 11.0;
165   static float Sd = 12.0;
166 
167   // CHECK: call void {{.*}}@__kmpc_fork_call(%ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}}), i16* %{{.+}}, i16* %{{.+}}, i16* %{{.+}}, i16* %{{.+}})
168   // 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:%.+]])
169   // Capture a, b, c, d
170   // CHECK: [[ALLOCLA:%.+]] = alloca i16
171   // CHECK: [[ALLOCLB:%.+]] = alloca i16
172   // CHECK: [[ALLOCLC:%.+]] = alloca i16
173   // CHECK: [[ALLOCLD:%.+]] = alloca i16
174   // CHECK: [[LLA:%.+]] = load i16*, i16** [[ALLOCLA]],
175   // CHECK: [[LLB:%.+]] = load i16*, i16** [[ALLOCLB]],
176   // CHECK: [[LLC:%.+]] = load i16*, i16** [[ALLOCLC]],
177   // CHECK: [[LLD:%.+]] = load i16*, i16** [[ALLOCLD]],
178   #pragma omp parallel
179   {
180     // CHECK-DAG:    [[VALLB:%.+]] = load i16, i16* [[LLB]],
181     // CHECK-64-DAG: [[VALGB:%.+]] = load double, double* @Gb,
182     // CHECK-DAG:    [[VALFB:%.+]] = load float, float* @_ZZ3barssssE2Sb,
183     // CHECK-64-DAG: [[VALGC:%.+]] = load double, double* @Gc,
184     // CHECK-DAG:    [[VALLC:%.+]] = load i16, i16* [[LLC]],
185     // CHECK-DAG:    [[VALFC:%.+]] = load float, float* @_ZZ3barssssE2Sc,
186     // CHECK-DAG:    [[VALLD:%.+]] = load i16, i16* [[LLD]],
187     // CHECK-64-DAG: [[VALGD:%.+]] = load double, double* @Gd,
188     // CHECK-DAG:    [[VALFD:%.+]] = load float, float* @_ZZ3barssssE2Sd,
189 
190     // 3 local vars being captured.
191 
192     // CHECK-DAG: store i16 [[VALLB]], i16* [[CONVLB:%.+]],
193     // CHECK-DAG: [[CONVLB]] = bitcast i[[sz:64|32]]* [[CADDRLB:%.+]] to i16*
194     // CHECK-DAG: [[CVALLB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLB]],
195     // CHECK-DAG: [[CPTRLB:%.+]] = inttoptr i[[sz]] [[CVALLB]] to i8*
196     // CHECK-DAG: store i8* [[CPTRLB]], i8** [[GEPLB:%.+]],
197     // CHECK-DAG: [[GEPLB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
198 
199     // CHECK-DAG: store i16 [[VALLC]], i16* [[CONVLC:%.+]],
200     // CHECK-DAG: [[CONVLC]] = bitcast i[[sz]]* [[CADDRLC:%.+]] to i16*
201     // CHECK-DAG: [[CVALLC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLC]],
202     // CHECK-DAG: [[CPTRLC:%.+]] = inttoptr i[[sz]] [[CVALLC]] to i8*
203     // CHECK-DAG: store i8* [[CPTRLC]], i8** [[GEPLC:%.+]],
204     // CHECK-DAG: [[GEPLC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
205 
206     // CHECK-DAG: store i16 [[VALLD]], i16* [[CONVLD:%.+]],
207     // CHECK-DAG: [[CONVLD]] = bitcast i[[sz]]* [[CADDRLD:%.+]] to i16*
208     // CHECK-DAG: [[CVALLD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRLD]],
209     // CHECK-DAG: [[CPTRLD:%.+]] = inttoptr i[[sz]] [[CVALLD]] to i8*
210     // CHECK-DAG: store i8* [[CPTRLD]], i8** [[GEPLD:%.+]],
211     // CHECK-DAG: [[GEPLD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
212 
213     // 3 static vars being captured.
214 
215     // CHECK-DAG: store float [[VALFB]], float* [[CONVFB:%.+]],
216     // CHECK-DAG: [[CONVFB]] = bitcast i[[sz]]* [[CADDRFB:%.+]] to float*
217     // CHECK-DAG: [[CVALFB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFB]],
218     // CHECK-DAG: [[CPTRFB:%.+]] = inttoptr i[[sz]] [[CVALFB]] to i8*
219     // CHECK-DAG: store i8* [[CPTRFB]], i8** [[GEPFB:%.+]],
220     // CHECK-DAG: [[GEPFB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
221 
222     // CHECK-DAG: store float [[VALFC]], float* [[CONVFC:%.+]],
223     // CHECK-DAG: [[CONVFC]] = bitcast i[[sz]]* [[CADDRFC:%.+]] to float*
224     // CHECK-DAG: [[CVALFC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFC]],
225     // CHECK-DAG: [[CPTRFC:%.+]] = inttoptr i[[sz]] [[CVALFC]] to i8*
226     // CHECK-DAG: store i8* [[CPTRFC]], i8** [[GEPFC:%.+]],
227     // CHECK-DAG: [[GEPFC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
228 
229     // CHECK-DAG: store float [[VALFD]], float* [[CONVFD:%.+]],
230     // CHECK-DAG: [[CONVFD]] = bitcast i[[sz]]* [[CADDRFD:%.+]] to float*
231     // CHECK-DAG: [[CVALFD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRFD]],
232     // CHECK-DAG: [[CPTRFD:%.+]] = inttoptr i[[sz]] [[CVALFD]] to i8*
233     // CHECK-DAG: store i8* [[CPTRFD]], i8** [[GEPFD:%.+]],
234     // CHECK-DAG: [[GEPFD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
235 
236     // 3 static global vars being captured.
237 
238     // CHECK-64-DAG: store double [[VALGB]], double* [[CONVGB:%.+]],
239     // CHECK-64-DAG: [[CONVGB]] = bitcast i[[sz]]* [[CADDRGB:%.+]] to double*
240     // CHECK-64-DAG: [[CVALGB:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGB]],
241     // CHECK-64-DAG: [[CPTRGB:%.+]] = inttoptr i[[sz]] [[CVALGB]] to i8*
242     // CHECK-64-DAG: store i8* [[CPTRGB]], i8** [[GEPGB:%.+]],
243     // CHECK-32-DAG: store i8* bitcast (double* @Gb to i8*), i8** [[GEPGB:%.+]],
244     // CHECK-DAG: [[GEPGB]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
245 
246     // CHECK-64-DAG: store double [[VALGC]], double* [[CONVGC:%.+]],
247     // CHECK-64-DAG: [[CONVGC]] = bitcast i[[sz]]* [[CADDRGC:%.+]] to double*
248     // CHECK-64-DAG: [[CVALGC:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGC]],
249     // CHECK-64-DAG: [[CPTRGC:%.+]] = inttoptr i[[sz]] [[CVALGC]] to i8*
250     // CHECK-64-DAG: store i8* [[CPTRGC]], i8** [[GEPGC:%.+]],
251     // CHECK-32-DAG: store i8* bitcast (double* @Gc to i8*), i8** [[GEPGC:%.+]],
252     // CHECK-DAG: [[GEPGC]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
253 
254     // CHECK-64-DAG: store double [[VALGD]], double* [[CONVGD:%.+]],
255     // CHECK-64-DAG: [[CONVGD]] = bitcast i[[sz]]* [[CADDRGD:%.+]] to double*
256     // CHECK-64-DAG: [[CVALGD:%.+]] = load i[[sz]], i[[sz]]* [[CADDRGD]],
257     // CHECK-64-DAG: [[CPTRGD:%.+]] = inttoptr i[[sz]] [[CVALGD]] to i8*
258     // CHECK-64-DAG: store i8* [[CPTRGD]], i8** [[GEPGD:%.+]],
259     // CHECK-32-DAG: store i8* bitcast (double* @Gd to i8*), i8** [[GEPGD:%.+]],
260     // CHECK-DAG: [[GEPGD]] = getelementptr inbounds [9 x i8*], [9 x i8*]* %{{.+}}, i32 0, i32 {{[0-8]}}
261 
262     // CHECK: call i32 @__tgt_target
263     // CHECK: call void [[OFFLOADF:@.+]](
264     // Capture b, Gb, Sb, Gc, c, Sc, d, Gd, Sd
265     #pragma omp target if(Ga>0.0 && a>0 && Sa>0.0)
266     {
267       b += 1;
268       Gb += 1.0;
269       Sb += 1.0;
270 
271       // CHECK: define internal void [[OFFLOADF]]({{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}}, {{.+}} {{.*}}%{{.+}})
272       // CHECK: call void {{.*}}@__kmpc_fork_call(%ident_t* {{.+}}, i32 {{.+}}, void (i32*, i32*, ...)* bitcast ({{.*}}[[PARF:@.+]] to {{.*}})
273 
274       // CHECK: define internal void [[PARF]](i32* noalias %{{.*}}, i32* noalias %{{.*}}, {{.+}}* dereferenceable({{.+}}) %{{.+}}, {{.+}}* dereferenceable({{.+}}) %{{.+}}, {{.+}}* dereferenceable({{.+}}) %{{.+}})
275       // Capture d, Gd, Sd
276       #pragma omp parallel if(Gc>0.0 && c>0 && Sc>0.0)
277       {
278         d += 1;
279         Gd += 1.0;
280         Sd += 1.0;
281       }
282     }
283   }
284   return a + b + c + d + (int)Sa + (int)Sb + (int)Sc + (int)Sd;
285 }
286 
287 #endif
288