1 // expected-no-diagnostics
2 #ifndef HEADER
3 #define HEADER
4 
5 ///
6 /// Implicit maps.
7 ///
8 
9 ///==========================================================================///
10 // RUN: %clang_cc1 -DCK1 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK1 --check-prefix CK1-64
11 // RUN: %clang_cc1 -DCK1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
12 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK1 --check-prefix CK1-64
13 // RUN: %clang_cc1 -DCK1 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK1 --check-prefix CK1-32
14 // RUN: %clang_cc1 -DCK1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
15 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK1 --check-prefix CK1-32
16 #ifdef CK1
17 
18 // CK1-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 4]
19 // Map types: OMP_MAP_PRIVATE_VAL | OMP_MAP_IS_FIRST = 288
20 // CK1-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
21 
22 // CK1-LABEL: implicit_maps_integer
implicit_maps_integer(int a)23 void implicit_maps_integer (int a){
24   int i = a;
25 
26   // CK1-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
27   // CK1-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
28   // CK1-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
29   // CK1-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
30   // CK1-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
31   // CK1-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
32   // CK1-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
33   // CK1-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
34   // CK1-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
35   // CK1-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
36   // CK1-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
37   // CK1-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
38 
39   // CK1: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
40   #pragma omp target
41   {
42    ++i;
43   }
44 }
45 
46 // CK1: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
47 // CK1: [[ADDR:%.+]] = alloca i[[sz]],
48 // CK1: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
49 // CK1-64: [[CADDR:%.+]] = bitcast i64* [[ADDR]] to i32*
50 // CK1-64: {{.+}} = load i32, i32* [[CADDR]],
51 // CK1-32: {{.+}} = load i32, i32* [[ADDR]],
52 
53 #endif
54 ///==========================================================================///
55 // RUN: %clang_cc1 -DCK2 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK2 --check-prefix CK2-64
56 // RUN: %clang_cc1 -DCK2 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
57 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK2 --check-prefix CK2-64
58 // RUN: %clang_cc1 -DCK2 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK2 --check-prefix CK2-32
59 // RUN: %clang_cc1 -DCK2 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
60 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK2 --check-prefix CK2-32
61 #ifdef CK2
62 
63 // CK2-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 4]
64 // Map types: OMP_MAP_PRIVATE_VAL | OMP_MAP_IS_FIRST = 288
65 // CK2-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
66 
67 // CK2-LABEL: implicit_maps_integer_reference
implicit_maps_integer_reference(int a)68 void implicit_maps_integer_reference (int a){
69   int &i = a;
70   // CK2-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
71   // CK2-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
72   // CK2-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
73   // CK2-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
74   // CK2-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
75   // CK2-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
76   // CK2-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
77   // CK2-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
78   // CK2-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
79   // CK2-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
80   // CK2-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
81   // CK2-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
82 
83   // CK2: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
84   #pragma omp target
85   {
86    ++i;
87   }
88 }
89 
90 // CK2: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
91 // CK2: [[ADDR:%.+]] = alloca i[[sz]],
92 // CK2: [[REF:%.+]] = alloca i32*,
93 // CK2: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
94 // CK2-64: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
95 // CK2-64: store i32* [[CADDR]], i32** [[REF]],
96 // CK2-64: [[RVAL:%.+]] = load i32*, i32** [[REF]],
97 // CK2-64: {{.+}} = load i32, i32* [[RVAL]],
98 // CK2-32: store i32* [[ADDR]], i32** [[REF]],
99 // CK2-32: [[RVAL:%.+]] = load i32*, i32** [[REF]],
100 // CK2-32: {{.+}} = load i32, i32* [[RVAL]],
101 
102 #endif
103 ///==========================================================================///
104 // RUN: %clang_cc1 -DCK3 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK3 --check-prefix CK3-64
105 // RUN: %clang_cc1 -DCK3 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
106 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK3 --check-prefix CK3-64
107 // RUN: %clang_cc1 -DCK3 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK3 --check-prefix CK3-32
108 // RUN: %clang_cc1 -DCK3 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
109 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK3 --check-prefix CK3-32
110 #ifdef CK3
111 
112 // CK3-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 4]
113 // Map types: OMP_MAP_PRIVATE_VAL | OMP_MAP_IS_FIRST = 288
114 // CK3-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
115 
116 // CK3-LABEL: implicit_maps_parameter
implicit_maps_parameter(int a)117 void implicit_maps_parameter (int a){
118 
119   // CK3-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
120   // CK3-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
121   // CK3-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
122   // CK3-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
123   // CK3-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
124   // CK3-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
125   // CK3-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
126   // CK3-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
127   // CK3-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
128   // CK3-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
129   // CK3-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
130   // CK3-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
131 
132   // CK3: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
133   #pragma omp target
134   {
135    ++a;
136   }
137 }
138 
139 // CK3: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
140 // CK3: [[ADDR:%.+]] = alloca i[[sz]],
141 // CK3: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
142 // CK3-64: [[CADDR:%.+]] = bitcast i64* [[ADDR]] to i32*
143 // CK3-64: {{.+}} = load i32, i32* [[CADDR]],
144 // CK3-32: {{.+}} = load i32, i32* [[ADDR]],
145 
146 #endif
147 ///==========================================================================///
148 // RUN: %clang_cc1 -DCK4 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK4 --check-prefix CK4-64
149 // RUN: %clang_cc1 -DCK4 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
150 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK4 --check-prefix CK4-64
151 // RUN: %clang_cc1 -DCK4 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK4 --check-prefix CK4-32
152 // RUN: %clang_cc1 -DCK4 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
153 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK4 --check-prefix CK4-32
154 #ifdef CK4
155 
156 // CK4-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 4]
157 // Map types: OMP_MAP_PRIVATE_VAL | OMP_MAP_IS_FIRST = 288
158 // CK4-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
159 
160 // CK4-LABEL: implicit_maps_nested_integer
implicit_maps_nested_integer(int a)161 void implicit_maps_nested_integer (int a){
162   int i = a;
163 
164   // The captures in parallel are by reference. Only the capture in target is by
165   // copy.
166 
167   // CK4: call void {{.+}}@__kmpc_fork_call({{.+}} [[KERNELP1:@.+]] to void (i32*, i32*, ...)*), i32* {{.+}})
168   // CK4: define internal void [[KERNELP1]](i32* {{[^,]+}}, i32* {{[^,]+}}, i32* {{[^,]+}})
169   #pragma omp parallel
170   {
171     // CK4-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
172     // CK4-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
173     // CK4-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
174     // CK4-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
175     // CK4-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
176     // CK4-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
177     // CK4-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
178     // CK4-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
179     // CK4-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
180     // CK4-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
181     // CK4-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
182     // CK4-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
183 
184     // CK4: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
185     #pragma omp target
186     {
187       #pragma omp parallel
188       {
189         ++i;
190       }
191     }
192   }
193 }
194 
195 // CK4: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
196 // CK4: [[ADDR:%.+]] = alloca i[[sz]],
197 // CK4: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
198 // CK4-64: [[CADDR:%.+]] = bitcast i64* [[ADDR]] to i32*
199 // CK4-64: call void {{.+}}@__kmpc_fork_call({{.+}} [[KERNELP2:@.+]] to void (i32*, i32*, ...)*), i32* [[CADDR]])
200 // CK4-32: call void {{.+}}@__kmpc_fork_call({{.+}} [[KERNELP2:@.+]] to void (i32*, i32*, ...)*), i32* [[ADDR]])
201 // CK4: define internal void [[KERNELP2]](i32* {{[^,]+}}, i32* {{[^,]+}}, i32* {{[^,]+}})
202 #endif
203 ///==========================================================================///
204 // RUN: %clang_cc1 -DCK5 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK5 --check-prefix CK5-64
205 // RUN: %clang_cc1 -DCK5 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
206 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK5 --check-prefix CK5-64
207 // RUN: %clang_cc1 -DCK5 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK5 --check-prefix CK5-32
208 // RUN: %clang_cc1 -DCK5 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
209 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK5 --check-prefix CK5-32
210 #ifdef CK5
211 
212 // CK5-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 4]
213 // Map types: OMP_MAP_PRIVATE_VAL | OMP_MAP_IS_FIRST = 288
214 // CK5-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
215 
216 // CK5-LABEL: implicit_maps_nested_integer_and_enum
implicit_maps_nested_integer_and_enum(int a)217 void implicit_maps_nested_integer_and_enum (int a){
218   enum Bla {
219     SomeEnum = 0x09
220   };
221 
222   // Using an enum should not change the mapping information.
223   int  i = a;
224 
225   // CK5-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
226   // CK5-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
227   // CK5-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
228   // CK5-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
229   // CK5-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
230   // CK5-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
231   // CK5-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
232   // CK5-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
233   // CK5-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
234   // CK5-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
235   // CK5-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
236   // CK5-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
237 
238   // CK5: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
239   #pragma omp target
240   {
241     ++i;
242     i += SomeEnum;
243   }
244 }
245 
246 // CK5: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
247 // CK5: [[ADDR:%.+]] = alloca i[[sz]],
248 // CK5: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
249 // CK5-64: [[CADDR:%.+]] = bitcast i64* [[ADDR]] to i32*
250 // CK5-64: {{.+}} = load i32, i32* [[CADDR]],
251 // CK5-32: {{.+}} = load i32, i32* [[ADDR]],
252 
253 #endif
254 ///==========================================================================///
255 // RUN: %clang_cc1 -DCK6 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK6 --check-prefix CK6-64
256 // RUN: %clang_cc1 -DCK6 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
257 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK6 --check-prefix CK6-64
258 // RUN: %clang_cc1 -DCK6 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK6 --check-prefix CK6-32
259 // RUN: %clang_cc1 -DCK6 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
260 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK6 --check-prefix CK6-32
261 #ifdef CK6
262 // CK6-DAG: [[GBL:@Gi]] = global i32 0
263 // CK6-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 4]
264 // Map types: OMP_MAP_PRIVATE_VAL | OMP_MAP_IS_FIRST = 288
265 // CK6-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
266 
267 // CK6-LABEL: implicit_maps_host_global
268 int Gi;
implicit_maps_host_global(int a)269 void implicit_maps_host_global (int a){
270   // CK6-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
271   // CK6-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
272   // CK6-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
273   // CK6-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
274   // CK6-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
275   // CK6-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
276   // CK6-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
277   // CK6-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
278   // CK6-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
279   // CK6-64-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
280   // CK6-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
281   // CK6-64-DAG: store i32 [[GBLVAL:%.+]], i32* [[CADDR]],
282   // CK6-64-DAG: [[GBLVAL]] = load i32, i32* [[GBL]],
283   // CK6-32-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[GBLVAL:%.+]],
284 
285   // CK6: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
286   #pragma omp target
287   {
288     ++Gi;
289   }
290 }
291 
292 // CK6: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
293 // CK6: [[ADDR:%.+]] = alloca i[[sz]],
294 // CK6: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
295 // CK6-64: [[CADDR:%.+]] = bitcast i64* [[ADDR]] to i32*
296 // CK6-64: {{.+}} = load i32, i32* [[CADDR]],
297 // CK6-32: {{.+}} = load i32, i32* [[ADDR]],
298 
299 #endif
300 ///==========================================================================///
301 // RUN: %clang_cc1 -DCK7 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK7 --check-prefix CK7-64
302 // RUN: %clang_cc1 -DCK7 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
303 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK7  --check-prefix CK7-64
304 // RUN: %clang_cc1 -DCK7 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK7  --check-prefix CK7-32
305 // RUN: %clang_cc1 -DCK7 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
306 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK7  --check-prefix CK7-32
307 #ifdef CK7
308 
309 // For a 32-bit targets, the value doesn't fit the size of the pointer,
310 // therefore it is passed by reference with a map 'to' specification.
311 
312 // CK7-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 8]
313 // Map types: OMP_MAP_PRIVATE_VAL | OMP_MAP_IS_FIRST = 288
314 // CK7-64-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
315 // Map types: OMP_MAP_TO  | OMP_MAP_IS_FIRST = 33
316 // CK7-32-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 33]
317 
318 // CK7-LABEL: implicit_maps_double
implicit_maps_double(int a)319 void implicit_maps_double (int a){
320   double d = (double)a;
321 
322   // CK7-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
323   // CK7-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
324   // CK7-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
325   // CK7-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
326   // CK7-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
327 
328   // CK7-64-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
329   // CK7-64-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
330   // CK7-64-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
331   // CK7-64-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
332   // CK7-64-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
333   // CK7-64-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to double*
334   // CK7-64-64-DAG: store double {{.+}}, double* [[CADDR]],
335 
336   // CK7-32-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
337   // CK7-32-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
338   // CK7-32-DAG: [[VALBP]] = bitcast double* [[DECL:%.+]] to i8*
339   // CK7-32-DAG: [[VALP]] = bitcast double* [[DECL]] to i8*
340 
341   // CK7-64: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
342   // CK7-32: call void [[KERNEL:@.+]](double* [[DECL]])
343   #pragma omp target
344   {
345     d += 1.0;
346   }
347 }
348 
349 // CK7-64: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
350 // CK7-64: [[ADDR:%.+]] = alloca i[[sz]],
351 // CK7-64: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
352 // CK7-64: [[CADDR:%.+]] = bitcast i64* [[ADDR]] to double*
353 // CK7-64: {{.+}} = load double, double* [[CADDR]],
354 
355 // CK7-32: define internal void [[KERNEL]](double* {{.+}}[[ARG:%.+]])
356 // CK7-32: [[ADDR:%.+]] = alloca double*,
357 // CK7-32: store double* [[ARG]], double** [[ADDR]],
358 // CK7-32: [[REF:%.+]] = load double*, double** [[ADDR]],
359 // CK7-32: {{.+}} = load double, double* [[REF]],
360 
361 #endif
362 ///==========================================================================///
363 // RUN: %clang_cc1 -DCK8 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK8
364 // RUN: %clang_cc1 -DCK8 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
365 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK8
366 // RUN: %clang_cc1 -DCK8 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK8
367 // RUN: %clang_cc1 -DCK8 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
368 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK8
369 #ifdef CK8
370 
371 // CK8-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 4]
372 // Map types: OMP_MAP_PRIVATE_VAL | OMP_MAP_IS_FIRST = 288
373 // CK8-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
374 
375 // CK8-LABEL: implicit_maps_float
implicit_maps_float(int a)376 void implicit_maps_float (int a){
377   float f = (float)a;
378 
379   // CK8-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
380   // CK8-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
381   // CK8-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
382   // CK8-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
383   // CK8-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
384   // CK8-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
385   // CK8-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
386   // CK8-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
387   // CK8-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
388   // CK8-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
389   // CK8-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to float*
390   // CK8-DAG: store float {{.+}}, float* [[CADDR]],
391 
392   // CK8: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
393   #pragma omp target
394   {
395     f += 1.0;
396   }
397 }
398 
399 // CK8: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
400 // CK8: [[ADDR:%.+]] = alloca i[[sz]],
401 // CK8: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
402 // CK8: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to float*
403 // CK8: {{.+}} = load float, float* [[CADDR]],
404 
405 #endif
406 ///==========================================================================///
407 // RUN: %clang_cc1 -DCK9 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK9
408 // RUN: %clang_cc1 -DCK9 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
409 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK9
410 // RUN: %clang_cc1 -DCK9 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK9
411 // RUN: %clang_cc1 -DCK9 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
412 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK9
413 #ifdef CK9
414 
415 // CK9-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 16]
416 // Map types: OMP_MAP_TO + OMP_MAP_FROM + OMP_MAP_IS_FIRST = 35
417 // CK9-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 35]
418 
419 // CK9-LABEL: implicit_maps_array
implicit_maps_array(int a)420 void implicit_maps_array (int a){
421   double darr[2] = {(double)a, (double)a};
422 
423   // CK9-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
424   // CK9-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
425   // CK9-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
426   // CK9-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
427   // CK9-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
428   // CK9-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
429   // CK9-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
430   // CK9-DAG: [[VALBP]] = bitcast [2 x double]* [[DECL:%.+]] to i8*
431   // CK9-DAG: [[VALP]] = bitcast [2 x double]* [[DECL]] to i8*
432 
433   // CK9: call void [[KERNEL:@.+]]([2 x double]* [[DECL]])
434   #pragma omp target
435   {
436     darr[0] += 1.0;
437     darr[1] += 1.0;
438   }
439 }
440 
441 // CK9: define internal void [[KERNEL]]([2 x double]* {{.+}}[[ARG:%.+]])
442 // CK9: [[ADDR:%.+]] = alloca [2 x double]*,
443 // CK9: store [2 x double]* [[ARG]], [2 x double]** [[ADDR]],
444 // CK9: [[REF:%.+]] = load [2 x double]*, [2 x double]** [[ADDR]],
445 // CK9: {{.+}} = getelementptr inbounds [2 x double], [2 x double]* [[REF]], i[[sz]] 0, i[[sz]] 0
446 #endif
447 ///==========================================================================///
448 // RUN: %clang_cc1 -DCK10 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK10
449 // RUN: %clang_cc1 -DCK10 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
450 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK10
451 // RUN: %clang_cc1 -DCK10 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK10
452 // RUN: %clang_cc1 -DCK10 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
453 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK10
454 #ifdef CK10
455 
456 // CK10-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] zeroinitializer
457 // Map types: OMP_MAP_IS_FIRST = 32
458 // CK10-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 32]
459 
460 // CK10-LABEL: implicit_maps_pointer
implicit_maps_pointer()461 void implicit_maps_pointer (){
462   double *ddyn;
463 
464   // CK10-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
465   // CK10-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
466   // CK10-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
467   // CK10-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
468   // CK10-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
469   // CK10-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
470   // CK10-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
471   // CK10-DAG: [[VALBP]] = bitcast double* [[PTR:%.+]] to i8*
472   // CK10-DAG: [[VALP]] = bitcast double* [[PTR]] to i8*
473 
474   // CK10: call void [[KERNEL:@.+]](double* [[PTR]])
475   #pragma omp target
476   {
477     ddyn[0] += 1.0;
478     ddyn[1] += 1.0;
479   }
480 }
481 
482 // CK10: define internal void [[KERNEL]](double* {{.*}}[[ARG:%.+]])
483 // CK10: [[ADDR:%.+]] = alloca double*,
484 // CK10: store double* [[ARG]], double** [[ADDR]],
485 // CK10: [[REF:%.+]] = load double*, double** [[ADDR]],
486 // CK10: {{.+}} = getelementptr inbounds double, double* [[REF]], i[[sz]] 0
487 
488 #endif
489 ///==========================================================================///
490 // RUN: %clang_cc1 -DCK11 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK11
491 // RUN: %clang_cc1 -DCK11 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
492 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK11
493 // RUN: %clang_cc1 -DCK11 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK11
494 // RUN: %clang_cc1 -DCK11 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
495 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK11
496 #ifdef CK11
497 
498 // CK11-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 16]
499 // Map types: OMP_MAP_TO + OMP_MAP_IS_FIRST = 33
500 // CK11-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 33]
501 
502 // CK11-LABEL: implicit_maps_double_complex
implicit_maps_double_complex(int a)503 void implicit_maps_double_complex (int a){
504   double _Complex dc = (double)a;
505 
506   // CK11-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
507   // CK11-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
508   // CK11-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
509   // CK11-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
510   // CK11-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
511   // CK11-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
512   // CK11-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
513   // CK11-DAG: [[VALBP]] = bitcast { double, double }* [[PTR:%.+]] to i8*
514   // CK11-DAG: [[VALP]] = bitcast { double, double }* [[PTR]] to i8*
515 
516   // CK11: call void [[KERNEL:@.+]]({ double, double }* [[PTR]])
517   #pragma omp target
518   {
519    dc *= dc;
520   }
521 }
522 
523 // CK11: define internal void [[KERNEL]]({ double, double }* {{.*}}[[ARG:%.+]])
524 // CK11: [[ADDR:%.+]] = alloca { double, double }*,
525 // CK11: store { double, double }* [[ARG]], { double, double }** [[ADDR]],
526 // CK11: [[REF:%.+]] = load { double, double }*, { double, double }** [[ADDR]],
527 // CK11: {{.+}} = getelementptr inbounds { double, double }, { double, double }* [[REF]], i32 0, i32 0
528 #endif
529 ///==========================================================================///
530 // RUN: %clang_cc1 -DCK12 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK12 --check-prefix CK12-64
531 // RUN: %clang_cc1 -DCK12 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
532 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK12 --check-prefix CK12-64
533 // RUN: %clang_cc1 -DCK12 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK12 --check-prefix CK12-32
534 // RUN: %clang_cc1 -DCK12 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
535 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK12 --check-prefix CK12-32
536 #ifdef CK12
537 
538 // For a 32-bit targets, the value doesn't fit the size of the pointer,
539 // therefore it is passed by reference with a map 'to' specification.
540 
541 // CK12-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 8]
542 // Map types: OMP_MAP_PRIVATE_VAL + OMP_MAP_IS_FIRST = 288
543 // CK12-64-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
544 // Map types: OMP_MAP_TO + OMP_MAP_IS_FIRST = 33
545 // CK12-32-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 33]
546 
547 // CK12-LABEL: implicit_maps_float_complex
implicit_maps_float_complex(int a)548 void implicit_maps_float_complex (int a){
549   float _Complex fc = (float)a;
550 
551   // CK12-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
552   // CK12-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
553   // CK12-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
554   // CK12-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
555   // CK12-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
556 
557   // CK12-64-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
558   // CK12-64-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
559   // CK12-64-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
560   // CK12-64-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
561   // CK12-64-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
562   // CK12-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to { float, float }*
563   // CK12-64-DAG: store { float, float } {{.+}}, { float, float }* [[CADDR]],
564 
565   // CK12-32-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
566   // CK12-32-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
567   // CK12-32-DAG: [[VALBP]] = bitcast { float, float }* [[DECL:%.+]] to i8*
568   // CK12-32-DAG: [[VALP]] = bitcast { float, float }* [[DECL]] to i8*
569 
570   // CK12-64: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
571   // CK12-32: call void [[KERNEL:@.+]]({ float, float }* [[DECL]])
572   #pragma omp target
573   {
574     fc *= fc;
575   }
576 }
577 
578 // CK12-64: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
579 // CK12-64: [[ADDR:%.+]] = alloca i[[sz]],
580 // CK12-64: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
581 // CK12-64: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to { float, float }*
582 // CK12-64: {{.+}} = getelementptr inbounds { float, float }, { float, float }* [[CADDR]], i32 0, i32 0
583 
584 // CK12-32: define internal void [[KERNEL]]({ float, float }* {{.+}}[[ARG:%.+]])
585 // CK12-32: [[ADDR:%.+]] = alloca { float, float }*,
586 // CK12-32: store { float, float }* [[ARG]], { float, float }** [[ADDR]],
587 // CK12-32: [[REF:%.+]] = load { float, float }*, { float, float }** [[ADDR]],
588 // CK12-32: {{.+}} = getelementptr inbounds { float, float }, { float, float }* [[REF]], i32 0, i32 0
589 #endif
590 ///==========================================================================///
591 // RUN: %clang_cc1 -DCK13 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK13
592 // RUN: %clang_cc1 -DCK13 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
593 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK13
594 // RUN: %clang_cc1 -DCK13 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK13
595 // RUN: %clang_cc1 -DCK13 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
596 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK13
597 #ifdef CK13
598 
599 // We don't have a constant map size for VLAs.
600 // Map types:
601 //  - OMP_MAP_PRIVATE_VAL + OMP_MAP_IS_FIRST = 288 (vla size)
602 //  - OMP_MAP_PRIVATE_VAL + OMP_MAP_IS_FIRST = 288 (vla size)
603 //  - OMP_MAP_TO + OMP_MAP_FROM + OMP_MAP_IS_FIRST = 35
604 // CK13-DAG: [[TYPES:@.+]] = {{.+}}constant [3 x i32] [i32 288, i32 288, i32 35]
605 
606 // CK13-LABEL: implicit_maps_variable_length_array
implicit_maps_variable_length_array(int a)607 void implicit_maps_variable_length_array (int a){
608   double vla[2][a];
609 
610   // CK13-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 3, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], i[[sz:64|32]]* [[SGEP:%[^,]+]], {{.+}}[[TYPES]]{{.+}})
611   // CK13-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
612   // CK13-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
613   // CK13-DAG: [[SGEP]] = getelementptr inbounds {{.+}}[[SS:%[^,]+]], i32 0, i32 0
614 
615   // CK13-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
616   // CK13-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
617   // CK13-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[SS]], i32 0, i32 0
618   // CK13-DAG: store i8* inttoptr (i[[sz]] 2 to i8*), i8** [[BP0]],
619   // CK13-DAG: store i8* inttoptr (i[[sz]] 2 to i8*), i8** [[P0]],
620   // CK13-DAG: store i[[sz]] {{8|4}}, i[[sz]]* [[S0]],
621 
622   // CK13-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 1
623   // CK13-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 1
624   // CK13-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[SS]], i32 0, i32 1
625   // CK13-DAG: store i8* [[VALBP1:%.+]], i8** [[BP1]],
626   // CK13-DAG: store i8* [[VALP1:%.+]], i8** [[P1]],
627   // CK13-DAG: [[VALBP1]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
628   // CK13-DAG: [[VALP1]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
629   // CK13-DAG: store i[[sz]] {{8|4}}, i[[sz]]* [[S1]],
630 
631   // CK13-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 2
632   // CK13-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 2
633   // CK13-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[SS]], i32 0, i32 2
634   // CK13-DAG: store i8* [[VALBP2:%.+]], i8** [[BP2]],
635   // CK13-DAG: store i8* [[VALP2:%.+]], i8** [[P2]],
636   // CK13-DAG: store i[[sz]] [[VALS2:%.+]], i[[sz]]* [[S2]],
637   // CK13-DAG: [[VALBP2]] = bitcast double* [[DECL:%.+]] to i8*
638   // CK13-DAG: [[VALP2]] = bitcast double* [[DECL]] to i8*
639   // CK13-DAG: [[VALS2]] = mul nuw i[[sz]] %{{.+}}, 8
640 
641   // CK13: call void [[KERNEL:@.+]](i[[sz]] {{.+}}, i[[sz]] {{.+}}, double* [[DECL]])
642   #pragma omp target
643   {
644     vla[1][3] += 1.0;
645   }
646 }
647 
648 // CK13: define internal void [[KERNEL]](i[[sz]] [[VLA0:%.+]], i[[sz]] [[VLA1:%.+]], double* {{.+}}[[ARG:%.+]])
649 // CK13: [[ADDR0:%.+]] = alloca i[[sz]],
650 // CK13: [[ADDR1:%.+]] = alloca i[[sz]],
651 // CK13: [[ADDR2:%.+]] = alloca double*,
652 // CK13: store i[[sz]] [[VLA0]], i[[sz]]* [[ADDR0]],
653 // CK13: store i[[sz]] [[VLA1]], i[[sz]]* [[ADDR1]],
654 // CK13: store double* [[ARG]], double** [[ADDR2]],
655 // CK13: {{.+}} = load i[[sz]],  i[[sz]]* [[ADDR0]],
656 // CK13: {{.+}} = load i[[sz]],  i[[sz]]* [[ADDR1]],
657 // CK13: [[REF:%.+]] = load double*, double** [[ADDR2]],
658 // CK13: {{.+}} = getelementptr inbounds double, double* [[REF]], i[[sz]] %{{.+}}
659 #endif
660 ///==========================================================================///
661 // RUN: %clang_cc1 -DCK14 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK14 --check-prefix CK14-64
662 // RUN: %clang_cc1 -DCK14 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
663 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK14 --check-prefix CK14-64
664 // RUN: %clang_cc1 -DCK14 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK14 --check-prefix CK14-32
665 // RUN: %clang_cc1 -DCK14 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
666 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK14 --check-prefix CK14-32
667 #ifdef CK14
668 
669 // CK14-DAG: [[ST:%.+]] = type { i32, double }
670 // CK14-DAG: [[SIZES:@.+]] = {{.+}}constant [2 x i[[sz:64|32]]] [i{{64|32}} {{16|12}}, i{{64|32}} 4]
671 // Map types:
672 // - OMP_MAP_TO + OMP_MAP_FROM + OMP_MAP_IS_FIRST = 35
673 // - OMP_MAP_PRIVATE_VAL + OMP_MAP_IS_FIRST = 288
674 // CK14-DAG: [[TYPES:@.+]] = {{.+}}constant [2 x i32] [i32 35, i32 288]
675 
676 class SSS {
677 public:
678   int a;
679   double b;
680 
foo(int c)681   void foo(int c) {
682     #pragma omp target
683     {
684       a += c;
685       b += (double)c;
686     }
687   }
688 
SSS(int a,double b)689   SSS(int a, double b) : a(a), b(b) {}
690 };
691 
692 // CK14-LABEL: implicit_maps_class
implicit_maps_class(int a)693 void implicit_maps_class (int a){
694   SSS sss(a, (double)a);
695 
696   // CK14: define {{.*}}void @{{.+}}foo{{.+}}([[ST]]* {{[^,]+}}, i32 {{[^,]+}})
697   // CK14-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 2, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
698   // CK14-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
699   // CK14-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
700 
701   // CK14-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
702   // CK14-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
703   // CK14-DAG: store i8* [[VALBP0:%.+]], i8** [[BP0]],
704   // CK14-DAG: store i8* [[VALP0:%.+]], i8** [[P0]],
705   // CK14-DAG: [[VALBP0]] = bitcast [[ST]]* [[DECL:%.+]] to i8*
706   // CK14-DAG: [[VALP0]] = bitcast [[ST]]* [[DECL]] to i8*
707 
708   // CK14-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 1
709   // CK14-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 1
710   // CK14-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
711   // CK14-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
712   // CK14-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
713   // CK14-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
714   // CK14-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
715   // CK14-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
716   // CK14-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
717 
718   // CK14: call void [[KERNEL:@.+]]([[ST]]* [[DECL]], i[[sz]] {{.+}})
719   sss.foo(123);
720 }
721 
722 // CK14: define internal void [[KERNEL]]([[ST]]* [[THIS:%.+]], i[[sz]] [[ARG:%.+]])
723 // CK14: [[ADDR0:%.+]] = alloca [[ST]]*,
724 // CK14: [[ADDR1:%.+]] = alloca i[[sz]],
725 // CK14: store [[ST]]* [[THIS]], [[ST]]** [[ADDR0]],
726 // CK14: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR1]],
727 // CK14: [[REF0:%.+]] = load [[ST]]*, [[ST]]** [[ADDR0]],
728 // CK14-64: [[CADDR1:%.+]] = bitcast i[[sz]]* [[ADDR1]] to i32*
729 // CK14-64: {{.+}} = load i32,  i32* [[CADDR1]],
730 // CK14-32: {{.+}} = load i32, i32* [[ADDR1]],
731 // CK14: {{.+}} = getelementptr inbounds [[ST]], [[ST]]* [[REF0]], i32 0, i32 0
732 
733 #endif
734 ///==========================================================================///
735 // RUN: %clang_cc1 -DCK15 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK15 --check-prefix CK15-64
736 // RUN: %clang_cc1 -DCK15 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
737 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK15 --check-prefix CK15-64
738 // RUN: %clang_cc1 -DCK15 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK15 --check-prefix CK15-32
739 // RUN: %clang_cc1 -DCK15 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
740 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK15 --check-prefix CK15-32
741 #ifdef CK15
742 
743 // CK15: [[ST:%.+]] = type { i32, double, i32* }
744 // CK15: [[SIZES:@.+]] = {{.+}}constant [2 x i[[sz:64|32]]] [i{{64|32}} {{24|16}}, i{{64|32}} 4]
745 // Map types:
746 // - OMP_MAP_TO + OMP_MAP_FROM + OMP_MAP_IS_FIRST = 35
747 // - OMP_MAP_PRIVATE_VAL + OMP_MAP_IS_FIRST = 288
748 // CK15: [[TYPES:@.+]] = {{.+}}constant [2 x i32] [i32 35, i32 288]
749 
750 // CK15: [[SIZES2:@.+]] = {{.+}}constant [2 x i[[sz]]] [i{{64|32}} {{24|16}}, i{{64|32}} 4]
751 // Map types:
752 // - OMP_MAP_TO + OMP_MAP_FROM + OMP_MAP_IS_FIRST = 35
753 // - OMP_MAP_PRIVATE_VAL + OMP_MAP_IS_FIRST = 288
754 // CK15: [[TYPES2:@.+]] = {{.+}}constant [2 x i32] [i32 35, i32 288]
755 
756 template<int x>
757 class SSST {
758 public:
759   int a;
760   double b;
761   int &r;
762 
foo(int c)763   void foo(int c) {
764     #pragma omp target
765     {
766       a += c + x;
767       b += (double)(c + x);
768       r += x;
769     }
770   }
771   template<int y>
bar(int c)772   void bar(int c) {
773     #pragma omp target
774     {
775       a += c + x + y;
776       b += (double)(c + x + y);
777       r += x + y;
778     }
779   }
780 
SSST(int a,double b,int & r)781   SSST(int a, double b, int &r) : a(a), b(b), r(r) {}
782 };
783 
784 // CK15-LABEL: implicit_maps_templated_class
implicit_maps_templated_class(int a)785 void implicit_maps_templated_class (int a){
786   SSST<123> ssst(a, (double)a, a);
787 
788   // CK15: define {{.*}}void @{{.+}}foo{{.+}}([[ST]]* {{[^,]+}}, i32 {{[^,]+}})
789   // CK15-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 2, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
790   // CK15-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
791   // CK15-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
792 
793   // CK15-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
794   // CK15-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
795   // CK15-DAG: store i8* [[VALBP0:%.+]], i8** [[BP0]],
796   // CK15-DAG: store i8* [[VALP0:%.+]], i8** [[P0]],
797   // CK15-DAG: [[VALBP0]] = bitcast [[ST]]* [[DECL:%.+]] to i8*
798   // CK15-DAG: [[VALP0]] = bitcast [[ST]]* [[DECL]] to i8*
799 
800   // CK15-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 1
801   // CK15-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 1
802   // CK15-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
803   // CK15-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
804   // CK15-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
805   // CK15-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
806   // CK15-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
807   // CK15-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
808   // CK15-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
809 
810   // CK15: call void [[KERNEL:@.+]]([[ST]]* [[DECL]], i[[sz]] {{.+}})
811   ssst.foo(456);
812 
813   // CK15: define {{.*}}void @{{.+}}bar{{.+}}([[ST]]* {{[^,]+}}, i32 {{[^,]+}})
814   // CK15-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 2, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES2]]{{.+}}, {{.+}}[[TYPES2]]{{.+}})
815   // CK15-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
816   // CK15-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
817 
818   // CK15-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
819   // CK15-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
820   // CK15-DAG: store i8* [[VALBP0:%.+]], i8** [[BP0]],
821   // CK15-DAG: store i8* [[VALP0:%.+]], i8** [[P0]],
822   // CK15-DAG: [[VALBP0]] = bitcast [[ST]]* [[DECL:%.+]] to i8*
823   // CK15-DAG: [[VALP0]] = bitcast [[ST]]* [[DECL]] to i8*
824 
825   // CK15-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 1
826   // CK15-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 1
827   // CK15-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
828   // CK15-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
829   // CK15-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
830   // CK15-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
831   // CK15-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
832   // CK15-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
833   // CK15-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
834 
835   // CK15: call void [[KERNEL2:@.+]]([[ST]]* [[DECL]], i[[sz]] {{.+}})
836   ssst.bar<210>(789);
837 }
838 
839 // CK15: define internal void [[KERNEL]]([[ST]]* [[THIS:%.+]], i[[sz]] [[ARG:%.+]])
840 // CK15: [[ADDR0:%.+]] = alloca [[ST]]*,
841 // CK15: [[ADDR1:%.+]] = alloca i[[sz]],
842 // CK15: store [[ST]]* [[THIS]], [[ST]]** [[ADDR0]],
843 // CK15: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR1]],
844 // CK15: [[REF0:%.+]] = load [[ST]]*, [[ST]]** [[ADDR0]],
845 // CK15-64: [[CADDR1:%.+]] = bitcast i[[sz]]* [[ADDR1]] to i32*
846 // CK15-64: {{.+}} = load i32,  i32* [[CADDR1]],
847 // CK15-32: {{.+}} = load i32, i32* [[ADDR1]],
848 // CK15: {{.+}} = getelementptr inbounds [[ST]], [[ST]]* [[REF0]], i32 0, i32 0
849 
850 // CK15: define internal void [[KERNEL2]]([[ST]]* [[THIS:%.+]], i[[sz]] [[ARG:%.+]])
851 // CK15: [[ADDR0:%.+]] = alloca [[ST]]*,
852 // CK15: [[ADDR1:%.+]] = alloca i[[sz]],
853 // CK15: store [[ST]]* [[THIS]], [[ST]]** [[ADDR0]],
854 // CK15: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR1]],
855 // CK15: [[REF0:%.+]] = load [[ST]]*, [[ST]]** [[ADDR0]],
856 // CK15-64: [[CADDR1:%.+]] = bitcast i[[sz]]* [[ADDR1]] to i32*
857 // CK15-64: {{.+}} = load i32,  i32* [[CADDR1]],
858 // CK15-32: {{.+}} = load i32, i32* [[ADDR1]],
859 // CK15: {{.+}} = getelementptr inbounds [[ST]], [[ST]]* [[REF0]], i32 0, i32 0
860 
861 #endif
862 ///==========================================================================///
863 // RUN: %clang_cc1 -DCK16 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK16 --check-prefix CK16-64
864 // RUN: %clang_cc1 -DCK16 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
865 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK16 --check-prefix CK16-64
866 // RUN: %clang_cc1 -DCK16 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK16 --check-prefix CK16-32
867 // RUN: %clang_cc1 -DCK16 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
868 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK16 --check-prefix CK16-32
869 #ifdef CK16
870 
871 // CK16-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 4]
872 // Map types:
873 // - OMP_MAP_PRIVATE_VAL + OMP_MAP_IS_FIRST = 288
874 // CK16-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
875 
876 template<int y>
foo(int d)877 int foo(int d) {
878   int res = d;
879   #pragma omp target
880   {
881     res += y;
882   }
883   return res;
884 }
885 // CK16-LABEL: implicit_maps_templated_function
implicit_maps_templated_function(int a)886 void implicit_maps_templated_function (int a){
887   int i = a;
888 
889   // CK16: define {{.*}}i32 @{{.+}}foo{{.+}}(i32 {{[^,]+}})
890   // CK16-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
891   // CK16-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
892   // CK16-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
893 
894   // CK16-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
895   // CK16-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
896   // CK16-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
897   // CK16-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
898   // CK16-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
899   // CK16-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
900   // CK16-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
901   // CK16-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
902   // CK16-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
903 
904   // CK16: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
905   i = foo<543>(i);
906 }
907 // CK16: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
908 // CK16: [[ADDR:%.+]] = alloca i[[sz]],
909 // CK16: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
910 // CK16-64: [[CADDR:%.+]] = bitcast i64* [[ADDR]] to i32*
911 // CK16-64: {{.+}} = load i32, i32* [[CADDR]],
912 // CK16-32: {{.+}} = load i32, i32* [[ADDR]],
913 
914 #endif
915 ///==========================================================================///
916 // RUN: %clang_cc1 -DCK17 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK17
917 // RUN: %clang_cc1 -DCK17 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
918 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK17
919 // RUN: %clang_cc1 -DCK17 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK17
920 // RUN: %clang_cc1 -DCK17 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
921 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK17
922 #ifdef CK17
923 
924 // CK17-DAG: [[ST:%.+]] = type { i32, double }
925 // CK17-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} {{16|12}}]
926 // Map types: OMP_MAP_TO + OMP_MAP_FROM + OMP_MAP_IS_FIRST = 35
927 // CK17-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 35]
928 
929 class SSS {
930 public:
931   int a;
932   double b;
933 };
934 
935 // CK17-LABEL: implicit_maps_struct
implicit_maps_struct(int a)936 void implicit_maps_struct (int a){
937   SSS s = {a, (double)a};
938 
939   // CK17-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
940   // CK17-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
941   // CK17-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
942   // CK17-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
943   // CK17-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
944   // CK17-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
945   // CK17-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
946   // CK17-DAG: [[VALBP]] = bitcast [[ST]]* [[DECL:%.+]] to i8*
947   // CK17-DAG: [[VALP]] = bitcast [[ST]]* [[DECL]] to i8*
948 
949   // CK17: call void [[KERNEL:@.+]]([[ST]]* [[DECL]])
950   #pragma omp target
951   {
952     s.a += 1;
953     s.b += 1.0;
954   }
955 }
956 
957 // CK17: define internal void [[KERNEL]]([[ST]]* {{.+}}[[ARG:%.+]])
958 // CK17: [[ADDR:%.+]] = alloca [[ST]]*,
959 // CK17: store [[ST]]* [[ARG]], [[ST]]** [[ADDR]],
960 // CK17: [[REF:%.+]] = load [[ST]]*, [[ST]]** [[ADDR]],
961 // CK17: {{.+}} = getelementptr inbounds [[ST]], [[ST]]* [[REF]], i32 0, i32 0
962 #endif
963 ///==========================================================================///
964 // RUN: %clang_cc1 -DCK18 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK18 --check-prefix CK18-64
965 // RUN: %clang_cc1 -DCK18 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
966 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK18 --check-prefix CK18-64
967 // RUN: %clang_cc1 -DCK18 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK18 --check-prefix CK18-32
968 // RUN: %clang_cc1 -DCK18 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
969 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK18 --check-prefix CK18-32
970 #ifdef CK18
971 
972 // CK18-DAG: [[SIZES:@.+]] = {{.+}}constant [1 x i[[sz:64|32]]] [i{{64|32}} 4]
973 // Map types:
974 // - OMP_MAP_PRIVATE_VAL + OMP_MAP_IS_FIRST = 288
975 // CK18-DAG: [[TYPES:@.+]] = {{.+}}constant [1 x i32] [i32 288]
976 
977 template<typename T>
foo(T d)978 int foo(T d) {
979   #pragma omp target
980   {
981     d += (T)1;
982   }
983   return d;
984 }
985 // CK18-LABEL: implicit_maps_template_type_capture
implicit_maps_template_type_capture(int a)986 void implicit_maps_template_type_capture (int a){
987   int i = a;
988 
989   // CK18: define {{.*}}i32 @{{.+}}foo{{.+}}(i32 {{[^,]+}})
990   // CK18-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZES]]{{.+}}, {{.+}}[[TYPES]]{{.+}})
991   // CK18-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
992   // CK18-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
993 
994   // CK18-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
995   // CK18-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
996   // CK18-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
997   // CK18-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
998   // CK18-DAG: [[VALBP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
999   // CK18-DAG: [[VALP]] = inttoptr i[[sz]] [[VAL:%.+]] to i8*
1000   // CK18-DAG: [[VAL]] = load i[[sz]], i[[sz]]* [[ADDR:%.+]],
1001   // CK18-64-DAG: [[CADDR:%.+]] = bitcast i[[sz]]* [[ADDR]] to i32*
1002   // CK18-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
1003 
1004   // CK18: call void [[KERNEL:@.+]](i[[sz]] [[VAL]])
1005   i = foo(i);
1006 }
1007 // CK18: define internal void [[KERNEL]](i[[sz]] [[ARG:%.+]])
1008 // CK18: [[ADDR:%.+]] = alloca i[[sz]],
1009 // CK18: store i[[sz]] [[ARG]], i[[sz]]* [[ADDR]],
1010 // CK18-64: [[CADDR:%.+]] = bitcast i64* [[ADDR]] to i32*
1011 // CK18-64: {{.+}} = load i32, i32* [[CADDR]],
1012 // CK18-32: {{.+}} = load i32, i32* [[ADDR]],
1013 
1014 #endif
1015 ///==========================================================================///
1016 // RUN: %clang_cc1 -DCK19 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK19 --check-prefix CK19-64
1017 // RUN: %clang_cc1 -DCK19 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
1018 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK19 --check-prefix CK19-64
1019 // RUN: %clang_cc1 -DCK19 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK19 --check-prefix CK19-32
1020 // RUN: %clang_cc1 -DCK19 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
1021 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK19 --check-prefix CK19-32
1022 #ifdef CK19
1023 
1024 // CK19: [[SIZE00:@.+]] = private {{.*}}constant [1 x i[[Z:64|32]]] [i[[Z:64|32]] 4]
1025 // CK19: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i32] [i32 32]
1026 
1027 // CK19: [[SIZE01:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 400]
1028 // CK19: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i32] [i32 33]
1029 
1030 // CK19: [[SIZE02:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 240]
1031 // CK19: [[MTYPE02:@.+]] = private {{.*}}constant [1 x i32] [i32 34]
1032 
1033 // CK19: [[SIZE03:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 240]
1034 // CK19: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1035 
1036 // CK19: [[SIZE04:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 400]
1037 // CK19: [[MTYPE04:@.+]] = private {{.*}}constant [1 x i32] [i32 32]
1038 
1039 // CK19: [[SIZE05:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
1040 // CK19: [[MTYPE05:@.+]] = private {{.*}}constant [1 x i32] [i32 33]
1041 
1042 // CK19: [[MTYPE06:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1043 
1044 // CK19: [[MTYPE07:@.+]] = private {{.*}}constant [1 x i32] [i32 32]
1045 
1046 // CK19: [[SIZE08:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
1047 // CK19: [[MTYPE08:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1048 
1049 // CK19: [[SIZE09:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] {{8|4}}]
1050 // CK19: [[MTYPE09:@.+]] = private {{.*}}constant [1 x i32] [i32 34]
1051 
1052 // CK19: [[SIZE10:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 240]
1053 // CK19: [[MTYPE10:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1054 
1055 // CK19: [[SIZE11:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 240]
1056 // CK19: [[MTYPE11:@.+]] = private {{.*}}constant [1 x i32] [i32 32]
1057 
1058 // CK19: [[SIZE12:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
1059 // CK19: [[MTYPE12:@.+]] = private {{.*}}constant [1 x i32] [i32 33]
1060 
1061 // CK19: [[MTYPE13:@.+]] = private {{.*}}constant [1 x i32] [i32 32]
1062 
1063 // CK19: [[MTYPE14:@.+]] = private {{.*}}constant [1 x i32] [i32 33]
1064 
1065 // CK19: [[SIZE15:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
1066 // CK19: [[MTYPE15:@.+]] = private {{.*}}constant [1 x i32] [i32 34]
1067 
1068 // CK19: [[MTYPE16:@.+]] = private {{.*}}constant [2 x i32] [i32 288, i32 33]
1069 
1070 // CK19: [[SIZE17:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 240]
1071 // CK19: [[MTYPE17:@.+]] = private {{.*}}constant [2 x i32] [i32 288, i32 34]
1072 
1073 // CK19: [[SIZE18:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 240]
1074 // CK19: [[MTYPE18:@.+]] = private {{.*}}constant [2 x i32] [i32 288, i32 35]
1075 
1076 // CK19: [[MTYPE19:@.+]] = private {{.*}}constant [2 x i32] [i32 288, i32 32]
1077 
1078 // CK19: [[SIZE20:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 4]
1079 // CK19: [[MTYPE20:@.+]] = private {{.*}}constant [2 x i32] [i32 288, i32 33]
1080 
1081 // CK19: [[MTYPE21:@.+]] = private {{.*}}constant [2 x i32] [i32 288, i32 35]
1082 
1083 // CK19: [[SIZE22:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 4]
1084 // CK19: [[MTYPE22:@.+]] = private {{.*}}constant [2 x i32] [i32 288, i32 35]
1085 
1086 // CK19: [[SIZE23:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
1087 // CK19: [[MTYPE23:@.+]] = private {{.*}}constant [1 x i32] [i32 39]
1088 
1089 // CK19: [[SIZE24:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 480]
1090 // CK19: [[MTYPE24:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1091 
1092 // CK19: [[SIZE25:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 16]
1093 // CK19: [[MTYPE25:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1094 
1095 // CK19: [[SIZE26:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 24]
1096 // CK19: [[MTYPE26:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1097 
1098 // CK19: [[SIZE27:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
1099 // CK19: [[MTYPE27:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1100 
1101 // CK19: [[SIZE28:@.+]] = private {{.*}}constant [3 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] 16]
1102 // CK19: [[MTYPE28:@.+]] = private {{.*}}constant [3 x i32] [i32 35, i32 19, i32 19]
1103 
1104 // CK19: [[SIZE29:@.+]] = private {{.*}}constant [3 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] 4]
1105 // CK19: [[MTYPE29:@.+]] = private {{.*}}constant [3 x i32] [i32 35, i32 19, i32 19]
1106 
1107 // CK19: [[MTYPE30:@.+]] = private {{.*}}constant [4 x i32] [i32 288, i32 288, i32 288, i32 35]
1108 
1109 // CK19: [[SIZE31:@.+]] = private {{.*}}constant [4 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] 40]
1110 // CK19: [[MTYPE31:@.+]] = private {{.*}}constant [4 x i32] [i32 288, i32 288, i32 288, i32 35]
1111 
1112 // CK19: [[SIZE32:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 13728]
1113 // CK19: [[MTYPE32:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1114 
1115 // CK19: [[SIZE33:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 13728]
1116 // CK19: [[MTYPE33:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1117 
1118 // CK19: [[SIZE34:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 13728]
1119 // CK19: [[MTYPE34:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1120 
1121 // CK19: [[MTYPE35:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1122 
1123 // CK19: [[SIZE36:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 208]
1124 // CK19: [[MTYPE36:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1125 
1126 // CK19: [[MTYPE37:@.+]] = private {{.*}}constant [3 x i32] [i32 288, i32 288, i32 35]
1127 
1128 // CK19: [[MTYPE38:@.+]] = private {{.*}}constant [3 x i32] [i32 288, i32 288, i32 35]
1129 
1130 // CK19: [[MTYPE39:@.+]] = private {{.*}}constant [3 x i32] [i32 288, i32 288, i32 35]
1131 
1132 // CK19: [[MTYPE40:@.+]] = private {{.*}}constant [3 x i32] [i32 288, i32 288, i32 35]
1133 
1134 // CK19: [[SIZE41:@.+]] = private {{.*}}constant [3 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] 208]
1135 // CK19: [[MTYPE41:@.+]] = private {{.*}}constant [3 x i32] [i32 288, i32 288, i32 35]
1136 
1137 // CK19: [[SIZE42:@.+]] = private {{.*}}constant [3 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] 104]
1138 // CK19: [[MTYPE42:@.+]] = private {{.*}}constant [3 x i32] [i32 35, i32 19, i32 19]
1139 
1140 // CK19: [[MTYPE43:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
1141 
1142 // CK19-LABEL: explicit_maps_single
explicit_maps_single(int ii)1143 void explicit_maps_single (int ii){
1144   // Map of a scalar.
1145   int a = ii;
1146 
1147   // Region 00
1148   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE00]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE00]]{{.+}})
1149   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1150   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1151 
1152   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1153   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1154   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1155   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1156   // CK19-DAG: [[CBPVAL0]] = bitcast i32* [[VAR0:%.+]] to i8*
1157   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[VAR0]] to i8*
1158 
1159   // CK19: call void [[CALL00:@.+]](i32* {{[^,]+}})
1160   #pragma omp target map(alloc:a)
1161   {
1162     ++a;
1163   }
1164 
1165   // Map of an array.
1166   int arra[100];
1167 
1168   // Region 01
1169   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE01]]{{.+}})
1170   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1171   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1172 
1173   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1174   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1175   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1176   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1177   // CK19-DAG: [[CBPVAL0]] = bitcast [100 x i32]* [[VAR0:%.+]] to i8*
1178   // CK19-DAG: [[CPVAL0]] = bitcast [100 x i32]* [[VAR0]] to i8*
1179 
1180   // CK19: call void [[CALL01:@.+]]([100 x i32]* {{[^,]+}})
1181   #pragma omp target map(to:arra)
1182   {
1183     arra[50]++;
1184   }
1185 
1186   // Region 02
1187   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE02]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE02]]{{.+}})
1188   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1189   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1190 
1191   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1192   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1193   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1194   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1195   // CK19-DAG: [[CBPVAL0]] = bitcast [100 x i32]* [[VAR0:%.+]] to i8*
1196   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1197   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 20
1198 
1199   // CK19: call void [[CALL02:@.+]]([100 x i32]* {{[^,]+}})
1200   #pragma omp target map(from:arra[20:60])
1201   {
1202     arra[50]++;
1203   }
1204 
1205   // Region 03
1206   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE03]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE03]]{{.+}})
1207   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1208   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1209 
1210   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1211   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1212   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1213   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1214   // CK19-DAG: [[CBPVAL0]] = bitcast [100 x i32]* [[VAR0:%.+]] to i8*
1215   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1216   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 0
1217 
1218   // CK19: call void [[CALL03:@.+]]([100 x i32]* {{[^,]+}})
1219   #pragma omp target map(tofrom:arra[:60])
1220   {
1221     arra[50]++;
1222   }
1223 
1224   // Region 04
1225   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE04]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE04]]{{.+}})
1226   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1227   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1228 
1229   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1230   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1231   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1232   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1233   // CK19-DAG: [[CBPVAL0]] = bitcast [100 x i32]* [[VAR0:%.+]] to i8*
1234   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1235   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 0
1236 
1237   // CK19: call void [[CALL04:@.+]]([100 x i32]* {{[^,]+}})
1238   #pragma omp target map(alloc:arra[:])
1239   {
1240     arra[50]++;
1241   }
1242 
1243   // Region 05
1244   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE05]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE05]]{{.+}})
1245   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1246   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1247 
1248   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1249   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1250   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1251   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1252   // CK19-DAG: [[CBPVAL0]] = bitcast [100 x i32]* [[VAR0:%.+]] to i8*
1253   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1254   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 15
1255 
1256   // CK19: call void [[CALL05:@.+]]([100 x i32]* {{[^,]+}})
1257   #pragma omp target map(to:arra[15])
1258   {
1259     arra[15]++;
1260   }
1261 
1262   // Region 06
1263   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE06]]{{.+}})
1264   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1265   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1266   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
1267 
1268   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1269   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1270   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
1271   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1272   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1273   // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]]
1274   // CK19-DAG: [[CBPVAL0]] = bitcast [100 x i32]* [[VAR0:%.+]] to i8*
1275   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1276   // CK19-DAG: [[CSVAL0]] = mul nuw i{{.+}} %{{.*}}, 4
1277   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} %{{.*}}
1278 
1279   // CK19: call void [[CALL06:@.+]]([100 x i32]* {{[^,]+}})
1280   #pragma omp target map(tofrom:arra[ii:ii+23])
1281   {
1282     arra[50]++;
1283   }
1284 
1285   // Region 07
1286   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE07]]{{.+}})
1287   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1288   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1289   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
1290 
1291   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1292   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1293   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
1294   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1295   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1296   // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]]
1297   // CK19-DAG: [[CBPVAL0]] = bitcast [100 x i32]* [[VAR0:%.+]] to i8*
1298   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1299   // CK19-DAG: [[CSVAL0]] = mul nuw i{{.+}} %{{.*}}, 4
1300   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 0
1301 
1302   // CK19: call void [[CALL07:@.+]]([100 x i32]* {{[^,]+}})
1303   #pragma omp target map(alloc:arra[:ii])
1304   {
1305     arra[50]++;
1306   }
1307 
1308   // Region 08
1309   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE08]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE08]]{{.+}})
1310   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1311   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1312 
1313   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1314   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1315   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1316   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1317   // CK19-DAG: [[CBPVAL0]] = bitcast [100 x i32]* [[VAR0:%.+]] to i8*
1318   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1319   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} %{{.*}}
1320 
1321   // CK19: call void [[CALL08:@.+]]([100 x i32]* {{[^,]+}})
1322   #pragma omp target map(tofrom:arra[ii])
1323   {
1324     arra[15]++;
1325   }
1326 
1327   // Map of a pointer.
1328   int *pa;
1329 
1330   // Region 09
1331   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE09]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE09]]{{.+}})
1332   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1333   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1334 
1335   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1336   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1337   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1338   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1339   // CK19-DAG: [[CBPVAL0]] = bitcast i32** [[VAR0:%.+]] to i8*
1340   // CK19-DAG: [[CPVAL0]] = bitcast i32** [[VAR0]] to i8*
1341 
1342   // CK19: call void [[CALL09:@.+]](i32** {{[^,]+}})
1343   #pragma omp target map(from:pa)
1344   {
1345     pa[50]++;
1346   }
1347 
1348   // Region 10
1349   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE10]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE10]]{{.+}})
1350   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1351   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1352 
1353   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1354   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1355   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1356   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1357   // CK19-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
1358   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1359   // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
1360   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 20
1361   // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
1362 
1363   // CK19: call void [[CALL10:@.+]](i32* {{[^,]+}})
1364   #pragma omp target map(tofrom:pa[20:60])
1365   {
1366     pa[50]++;
1367   }
1368 
1369   // Region 11
1370   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE11]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE11]]{{.+}})
1371   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1372   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1373 
1374   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1375   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1376   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1377   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1378   // CK19-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
1379   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1380   // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
1381   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 0
1382   // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
1383 
1384   // CK19: call void [[CALL11:@.+]](i32* {{[^,]+}})
1385   #pragma omp target map(alloc:pa[:60])
1386   {
1387     pa[50]++;
1388   }
1389 
1390   // Region 12
1391   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE12]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE12]]{{.+}})
1392   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1393   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1394 
1395   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1396   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1397   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1398   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1399   // CK19-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
1400   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1401   // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
1402   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 15
1403   // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
1404 
1405   // CK19: call void [[CALL12:@.+]](i32* {{[^,]+}})
1406   #pragma omp target map(to:pa[15])
1407   {
1408     pa[15]++;
1409   }
1410 
1411   // Region 13
1412   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE13]]{{.+}})
1413   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1414   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1415   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
1416 
1417   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1418   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1419   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
1420   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1421   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1422   // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]]
1423   // CK19-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
1424   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1425   // CK19-DAG: [[CSVAL0]] = mul nuw i{{.+}} %{{.*}}, 4
1426   // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
1427   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} %{{.*}}
1428   // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
1429 
1430   // CK19: call void [[CALL13:@.+]](i32* {{[^,]+}})
1431   #pragma omp target map(alloc:pa[ii-23:ii])
1432   {
1433     pa[50]++;
1434   }
1435 
1436   // Region 14
1437   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE14]]{{.+}})
1438   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1439   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1440   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
1441 
1442   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1443   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1444   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
1445   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1446   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1447   // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]]
1448   // CK19-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
1449   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1450   // CK19-DAG: [[CSVAL0]] = mul nuw i{{.+}} %{{.*}}, 4
1451   // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
1452   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 0
1453   // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
1454 
1455   // CK19: call void [[CALL14:@.+]](i32* {{[^,]+}})
1456   #pragma omp target map(to:pa[:ii])
1457   {
1458     pa[50]++;
1459   }
1460 
1461   // Region 15
1462   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE15]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE15]]{{.+}})
1463   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1464   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1465 
1466   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1467   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1468   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1469   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1470   // CK19-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
1471   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1472   // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
1473   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} %{{.*}}
1474   // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
1475 
1476   // CK19: call void [[CALL15:@.+]](i32* {{[^,]+}})
1477   #pragma omp target map(from:pa[ii+12])
1478   {
1479     pa[15]++;
1480   }
1481 
1482   // Map of a variable-size array.
1483   int va[ii];
1484 
1485   // Region 16
1486   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE16]]{{.+}})
1487   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1488   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1489   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
1490 
1491   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1492   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1493   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
1494   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1495   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1496   // CK19-DAG: store i{{.+}} {{8|4}}, i{{.+}}* [[S0]]
1497   // CK19-DAG: [[CBPVAL0]] = inttoptr i[[Z]] %{{.+}} to i8*
1498   // CK19-DAG: [[CPVAL0]] = inttoptr i[[Z]] %{{.+}}to i8*
1499 
1500   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1501   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1502   // CK19-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1
1503   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1504   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1505   // CK19-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], i{{.+}}* [[S1]]
1506   // CK19-DAG: [[CBPVAL1]] = bitcast i32* [[VAR1:%.+]] to i8*
1507   // CK19-DAG: [[CPVAL1]] = bitcast i32* [[VAR1]] to i8*
1508   // CK19-DAG: [[CSVAL1]] = mul nuw i{{.+}} %{{.*}}, 4
1509 
1510   // CK19: call void [[CALL16:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}})
1511   #pragma omp target map(to:va)
1512   {
1513    va[50]++;
1514   }
1515 
1516   // Region 17
1517   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE17]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE17]]{{.+}})
1518   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1519   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1520 
1521   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1522   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1523   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1524   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1525   // CK19-DAG: [[CBPVAL0]] = inttoptr i[[Z]] %{{.+}} to i8*
1526   // CK19-DAG: [[CPVAL0]] = inttoptr i[[Z]] %{{.+}}to i8*
1527 
1528   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1529   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1530   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1531   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1532   // CK19-DAG: [[CBPVAL1]] = bitcast i32* [[VAR1:%.+]] to i8*
1533   // CK19-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
1534   // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 20
1535 
1536   // CK19: call void [[CALL17:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}})
1537   #pragma omp target map(from:va[20:60])
1538   {
1539    va[50]++;
1540   }
1541 
1542   // Region 18
1543   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE18]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE18]]{{.+}})
1544   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1545   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1546 
1547   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1548   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1549   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1550   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1551   // CK19-DAG: [[CBPVAL0]] = inttoptr i[[Z]] %{{.+}} to i8*
1552   // CK19-DAG: [[CPVAL0]] = inttoptr i[[Z]] %{{.+}}to i8*
1553 
1554   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1555   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1556   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1557   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1558   // CK19-DAG: [[CBPVAL1]] = bitcast i32* [[VAR1:%.+]] to i8*
1559   // CK19-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
1560   // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 0
1561 
1562   // CK19: call void [[CALL18:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}})
1563   #pragma omp target map(tofrom:va[:60])
1564   {
1565    va[50]++;
1566   }
1567 
1568   // Region 19
1569   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE19]]{{.+}})
1570   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1571   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1572   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
1573 
1574   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1575   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1576   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
1577   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1578   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1579   // CK19-DAG: store i{{.+}} {{8|4}}, i{{.+}}* [[S0]]
1580   // CK19-DAG: [[CBPVAL0]] = inttoptr i[[Z]] %{{.+}} to i8*
1581   // CK19-DAG: [[CPVAL0]] = inttoptr i[[Z]] %{{.+}}to i8*
1582 
1583   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1584   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1585   // CK19-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1
1586   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1587   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1588   // CK19-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], i{{.+}}* [[S1]]
1589   // CK19-DAG: [[CBPVAL1]] = bitcast i32* [[VAR1:%.+]] to i8*
1590   // CK19-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
1591   // CK19-DAG: [[CSVAL1]] = mul nuw i{{.+}} %{{.*}}, 4
1592   // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 0
1593 
1594   // CK19: call void [[CALL19:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}})
1595   #pragma omp target map(alloc:va[:])
1596   {
1597    va[50]++;
1598   }
1599 
1600   // Region 20
1601   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE20]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE20]]{{.+}})
1602   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1603   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1604 
1605   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1606   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1607   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1608   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1609   // CK19-DAG: [[CBPVAL0]] = inttoptr i[[Z]] %{{.+}} to i8*
1610   // CK19-DAG: [[CPVAL0]] = inttoptr i[[Z]] %{{.+}}to i8*
1611 
1612   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1613   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1614   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1615   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1616   // CK19-DAG: [[CBPVAL1]] = bitcast i32* [[VAR1:%.+]] to i8*
1617   // CK19-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
1618   // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 15
1619 
1620   // CK19: call void [[CALL20:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}})
1621   #pragma omp target map(to:va[15])
1622   {
1623    va[15]++;
1624   }
1625 
1626   // Region 21
1627   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE21]]{{.+}})
1628   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1629   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1630   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
1631 
1632   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1633   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1634   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
1635   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1636   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1637   // CK19-DAG: store i{{.+}} {{8|4}}, i{{.+}}* [[S0]]
1638   // CK19-DAG: [[CBPVAL0]] = inttoptr i[[Z]] %{{.+}} to i8*
1639   // CK19-DAG: [[CPVAL0]] = inttoptr i[[Z]] %{{.+}}to i8*
1640 
1641   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1642   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1643   // CK19-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1
1644   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1645   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1646   // CK19-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], i{{.+}}* [[S1]]
1647   // CK19-DAG: [[CBPVAL1]] = bitcast i32* [[VAR1:%.+]] to i8*
1648   // CK19-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
1649   // CK19-DAG: [[CSVAL1]] = mul nuw i{{.+}} %{{.*}}, 4
1650   // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} %{{.+}}
1651 
1652   // CK19: call void [[CALL21:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}})
1653   #pragma omp target map(tofrom:va[ii:ii+23])
1654   {
1655    va[50]++;
1656   }
1657 
1658   // Region 22
1659   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE22]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE22]]{{.+}})
1660   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1661   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1662 
1663   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1664   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1665   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1666   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1667   // CK19-DAG: [[CBPVAL0]] = inttoptr i[[Z]] %{{.+}} to i8*
1668   // CK19-DAG: [[CPVAL0]] = inttoptr i[[Z]] %{{.+}}to i8*
1669 
1670   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1671   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1672   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1673   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1674   // CK19-DAG: [[CBPVAL1]] = bitcast i32* [[VAR1:%.+]] to i8*
1675   // CK19-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
1676   // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} %{{.+}}
1677 
1678   // CK19: call void [[CALL22:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}})
1679   #pragma omp target map(tofrom:va[ii])
1680   {
1681    va[15]++;
1682   }
1683 
1684   // Always.
1685   // Region 23
1686   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE23]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE23]]{{.+}})
1687   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1688   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1689 
1690   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1691   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1692   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1693   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1694   // CK19-DAG: [[CBPVAL0]] = bitcast i32* [[VAR0:%.+]] to i8*
1695   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[VAR0]] to i8*
1696 
1697   // CK19: call void [[CALL23:@.+]](i32* {{[^,]+}})
1698   #pragma omp target map(always, tofrom: a)
1699   {
1700    a++;
1701   }
1702 
1703   // Multidimensional arrays.
1704   int marr[4][5][6];
1705   int ***mptr;
1706 
1707   // Region 24
1708   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE24]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE24]]{{.+}})
1709   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1710   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1711 
1712   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1713   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1714   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1715   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1716   // CK19-DAG: [[CBPVAL0]] = bitcast [4 x [5 x [6 x i32]]]* [[VAR0:%.+]] to i8*
1717   // CK19-DAG: [[CPVAL0]] = bitcast [4 x [5 x [6 x i32]]]* [[VAR0]] to i8*
1718 
1719   // CK19: call void [[CALL24:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}})
1720   #pragma omp target map(tofrom: marr)
1721   {
1722    marr[1][2][3]++;
1723   }
1724 
1725   // Region 25
1726   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE25]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE25]]{{.+}})
1727   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1728   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1729 
1730   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1731   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1732   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1733   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1734   // CK19-DAG: [[CBPVAL0]] = bitcast [4 x [5 x [6 x i32]]]* [[VAR0:%.+]] to i8*
1735   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1736   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[6 x i32]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 2
1737   // CK19-DAG: [[SEC00]] = getelementptr {{.*}}[5 x [6 x i32]]* [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2
1738   // CK19-DAG: [[SEC000]] = getelementptr {{.*}}[4 x [5 x [6 x i32]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
1739 
1740   // CK19: call void [[CALL25:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}})
1741   #pragma omp target map(tofrom: marr[1][2][2:4])
1742   {
1743    marr[1][2][3]++;
1744   }
1745 
1746   // Region 26
1747   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE26]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE26]]{{.+}})
1748   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1749   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1750 
1751   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1752   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1753   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1754   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1755   // CK19-DAG: [[CBPVAL0]] = bitcast [4 x [5 x [6 x i32]]]* [[VAR0:%.+]] to i8*
1756   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1757   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[6 x i32]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 0
1758   // CK19-DAG: [[SEC00]] = getelementptr {{.*}}[5 x [6 x i32]]* [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2
1759   // CK19-DAG: [[SEC000]] = getelementptr {{.*}}[4 x [5 x [6 x i32]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
1760 
1761   // CK19: call void [[CALL26:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}})
1762   #pragma omp target map(tofrom: marr[1][2][:])
1763   {
1764    marr[1][2][3]++;
1765   }
1766 
1767   // Region 27
1768   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE27]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE27]]{{.+}})
1769   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1770   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1771 
1772   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1773   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1774   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1775   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1776   // CK19-DAG: [[CBPVAL0]] = bitcast [4 x [5 x [6 x i32]]]* [[VAR0:%.+]] to i8*
1777   // CK19-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
1778   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[6 x i32]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 3
1779   // CK19-DAG: [[SEC00]] = getelementptr {{.*}}[5 x [6 x i32]]* [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2
1780   // CK19-DAG: [[SEC000]] = getelementptr {{.*}}[4 x [5 x [6 x i32]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
1781 
1782   // CK19: call void [[CALL27:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}})
1783   #pragma omp target map(tofrom: marr[1][2][3])
1784   {
1785    marr[1][2][3]++;
1786   }
1787 
1788   // Region 28
1789   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[SIZE28]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE28]]{{.+}})
1790   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1791   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1792 
1793   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1794   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1795   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1796   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1797   // CK19-DAG: [[CBPVAL0]] = bitcast i32*** [[VAR0:%.+]] to i8*
1798   // CK19-DAG: [[CPVAL0]] = bitcast i32*** [[SEC0:%.+]] to i8*
1799   // CK19-DAG: [[VAR0]] = load i32***, i32**** [[PTR:%[^,]+]],
1800   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32*** [[SEC00:[^,]+]], i{{.+}} 1
1801   // CK19-DAG: [[SEC00]] = load i32***, i32**** [[PTR]],
1802 
1803   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1804   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1805   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1806   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1807   // CK19-DAG: [[CBPVAL1]] = bitcast i32*** [[SEC0]] to i8*
1808   // CK19-DAG: [[CPVAL1]] = bitcast i32** [[SEC1:%.+]] to i8*
1809   // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32** [[SEC11:[^,]+]], i{{.+}} 2
1810   // CK19-DAG: [[SEC11]] = load i32**, i32*** [[SEC111:%[^,]+]],
1811   // CK19-DAG: [[SEC111]] = getelementptr {{.*}}i32*** [[SEC1111:[^,]+]], i{{.+}} 1
1812   // CK19-DAG: [[SEC1111]] = load i32***, i32**** [[PTR]],
1813 
1814   // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
1815   // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
1816   // CK19-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
1817   // CK19-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
1818   // CK19-DAG: [[CBPVAL2]] = bitcast i32** [[SEC1]] to i8*
1819   // CK19-DAG: [[CPVAL2]] = bitcast i32* [[SEC2:%.+]] to i8*
1820   // CK19-DAG: [[SEC2]] = getelementptr {{.*}}i32* [[SEC22:[^,]+]], i{{.+}} 2
1821   // CK19-DAG: [[SEC22]] = load i32*, i32** [[SEC222:%[^,]+]],
1822   // CK19-DAG: [[SEC222]] = getelementptr {{.*}}i32** [[SEC2222:[^,]+]], i{{.+}} 2
1823   // CK19-DAG: [[SEC2222]] = load i32**, i32*** [[SEC22222:%[^,]+]],
1824   // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}i32*** [[SEC222222:[^,]+]], i{{.+}} 1
1825   // CK19-DAG: [[SEC222222]] = load i32***, i32**** [[PTR]],
1826 
1827   // CK19: call void [[CALL28:@.+]](i32*** {{[^,]+}})
1828   #pragma omp target map(tofrom: mptr[1][2][2:4])
1829   {
1830     mptr[1][2][3]++;
1831   }
1832 
1833   // Region 29
1834   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[SIZE29]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE29]]{{.+}})
1835   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1836   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1837 
1838   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1839   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1840   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1841   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1842   // CK19-DAG: [[CBPVAL0]] = bitcast i32*** [[VAR0:%.+]] to i8*
1843   // CK19-DAG: [[CPVAL0]] = bitcast i32*** [[SEC0:%.+]] to i8*
1844   // CK19-DAG: [[VAR0]] = load i32***, i32**** [[PTR:%[^,]+]],
1845   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32*** [[SEC00:[^,]+]], i{{.+}} 1
1846   // CK19-DAG: [[SEC00]] = load i32***, i32**** [[PTR]],
1847 
1848   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1849   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1850   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1851   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1852   // CK19-DAG: [[CBPVAL1]] = bitcast i32*** [[SEC0]] to i8*
1853   // CK19-DAG: [[CPVAL1]] = bitcast i32** [[SEC1:%.+]] to i8*
1854   // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32** [[SEC11:[^,]+]], i{{.+}} 2
1855   // CK19-DAG: [[SEC11]] = load i32**, i32*** [[SEC111:%[^,]+]],
1856   // CK19-DAG: [[SEC111]] = getelementptr {{.*}}i32*** [[SEC1111:[^,]+]], i{{.+}} 1
1857   // CK19-DAG: [[SEC1111]] = load i32***, i32**** [[PTR]],
1858 
1859   // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
1860   // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
1861   // CK19-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
1862   // CK19-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
1863   // CK19-DAG: [[CBPVAL2]] = bitcast i32** [[SEC1]] to i8*
1864   // CK19-DAG: [[CPVAL2]] = bitcast i32* [[SEC2:%.+]] to i8*
1865   // CK19-DAG: [[SEC2]] = getelementptr {{.*}}i32* [[SEC22:[^,]+]], i{{.+}} 3
1866   // CK19-DAG: [[SEC22]] = load i32*, i32** [[SEC222:%[^,]+]],
1867   // CK19-DAG: [[SEC222]] = getelementptr {{.*}}i32** [[SEC2222:[^,]+]], i{{.+}} 2
1868   // CK19-DAG: [[SEC2222]] = load i32**, i32*** [[SEC22222:%[^,]+]],
1869   // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}i32*** [[SEC222222:[^,]+]], i{{.+}} 1
1870   // CK19-DAG: [[SEC222222]] = load i32***, i32**** [[PTR]],
1871 
1872   // CK19: call void [[CALL29:@.+]](i32*** {{[^,]+}})
1873   #pragma omp target map(tofrom: mptr[1][2][3])
1874   {
1875     mptr[1][2][3]++;
1876   }
1877 
1878   // Multidimensional VLA.
1879   double mva[23][ii][ii+5];
1880 
1881   // Region 30
1882   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 4, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[4 x i{{.+}}]* [[MTYPE30]]{{.+}})
1883   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1884   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1885   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
1886   //
1887   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1888   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1889   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
1890   // CK19-DAG: store i8* inttoptr (i[[Z]] 23 to i8*), i8** [[BP0]]
1891   // CK19-DAG: store i8* inttoptr (i[[Z]] 23 to i8*), i8** [[P0]]
1892   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S0]]
1893   //
1894   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1895   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1896   // CK19-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1
1897   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1898   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1899   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S1]]
1900   // CK19-DAG: [[CBPVAL1]] = inttoptr i[[Z]] [[VAR1:%.+]] to i8*
1901   // CK19-DAG: [[CPVAL1]] = inttoptr i[[Z]] [[VAR11:%.+]] to i8*
1902   // CK19-64-DAG: [[VAR1]] = zext i32 %{{[^,]+}} to i64
1903   // CK19-64-DAG: [[VAR11]] = zext i32 %{{[^,]+}} to i64
1904   //
1905   // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
1906   // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
1907   // CK19-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2
1908   // CK19-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
1909   // CK19-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
1910   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S2]]
1911   // CK19-DAG: [[CBPVAL2]] = inttoptr i[[Z]] [[VAR2:%.+]] to i8*
1912   // CK19-DAG: [[CPVAL2]] = inttoptr i[[Z]] [[VAR22:%.+]] to i8*
1913   // CK19-64-DAG: [[VAR2]] = zext i32 %{{[^,]+}} to i64
1914   // CK19-64-DAG: [[VAR22]] = zext i32 %{{[^,]+}} to i64
1915   //
1916   // CK19-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 3
1917   // CK19-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3
1918   // CK19-DAG: [[S3:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 3
1919   // CK19-DAG: store i8* [[CBPVAL3:%[^,]+]], i8** [[BP3]]
1920   // CK19-DAG: store i8* [[CPVAL3:%[^,]+]], i8** [[P3]]
1921   // CK19-DAG: store i[[Z]] [[CSVAL3:%[^,]+]], i[[Z]]* [[S3]]
1922   // CK19-DAG: [[CBPVAL3]] = bitcast double* [[VAR3:%.+]] to i8*
1923   // CK19-DAG: [[CPVAL3]] = bitcast double* [[VAR3]] to i8*
1924   // CK19-DAG: [[CSVAL3]] = mul nuw i[[Z]] %{{[^,]+}}, {{8|4}}
1925 
1926   // CK19: call void [[CALL30:@.+]](i[[Z]] 23, i[[Z]] %{{[^,]+}}, i[[Z]] %{{[^,]+}}, double* %{{[^,]+}})
1927   #pragma omp target map(tofrom: mva)
1928   {
1929     mva[1][2][3]++;
1930   }
1931 
1932   // Region 31
1933   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 4, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[4 x i{{.+}}]* [[SIZE31]], {{.+}}getelementptr {{.+}}[4 x i{{.+}}]* [[MTYPE31]]{{.+}})
1934   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1935   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1936   //
1937   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1938   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1939   // CK19-DAG: store i8* inttoptr (i[[Z]] 23 to i8*), i8** [[BP0]]
1940   // CK19-DAG: store i8* inttoptr (i[[Z]] 23 to i8*), i8** [[P0]]
1941   //
1942   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
1943   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
1944   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
1945   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
1946   // CK19-DAG: [[CBPVAL1]] = inttoptr i[[Z]] [[VAR1:%.+]] to i8*
1947   // CK19-DAG: [[CPVAL1]] = inttoptr i[[Z]] [[VAR11:%.+]] to i8*
1948   //
1949   // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
1950   // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
1951   // CK19-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
1952   // CK19-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
1953   // CK19-DAG: [[CBPVAL2]] = inttoptr i[[Z]] [[VAR2:%.+]] to i8*
1954   // CK19-DAG: [[CPVAL2]] = inttoptr i[[Z]] [[VAR22:%.+]] to i8*
1955   //
1956   // CK19-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 3
1957   // CK19-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3
1958   // CK19-DAG: store i8* [[CBPVAL3:%[^,]+]], i8** [[BP3]]
1959   // CK19-DAG: store i8* [[CPVAL3:%[^,]+]], i8** [[P3]]
1960   // CK19-DAG: [[CBPVAL3]] = bitcast double* [[VAR3:%.+]] to i8*
1961   // CK19-DAG: [[CPVAL3]] = bitcast double* [[SEC3:%.+]] to i8*
1962   // CK19-DAG: [[SEC3]] = getelementptr {{.*}}double* [[SEC33:%.+]], i[[Z]] 0
1963   // CK19-DAG: [[SEC33]] = getelementptr {{.*}}double* [[SEC333:%.+]], i[[Z]] [[IDX3:%.+]]
1964   // CK19-DAG: [[IDX3]] = mul nsw i[[Z]] %{{[^,]+}}, %{{[^,]+}}
1965   // CK19-DAG: [[SEC333]] = getelementptr {{.*}}double* [[VAR3]], i[[Z]] [[IDX33:%.+]]
1966   // CK19-DAG: [[IDX33]] = mul nsw i[[Z]] 1, %{{[^,]+}}
1967 
1968   // CK19: call void [[CALL31:@.+]](i[[Z]] 23, i[[Z]] %{{[^,]+}}, i[[Z]] %{{[^,]+}}, double* %{{[^,]+}})
1969   #pragma omp target map(tofrom: mva[1][ii-2][:5])
1970   {
1971     mva[1][2][3]++;
1972   }
1973 
1974   // Multidimensional array sections.
1975   double marras[11][12][13];
1976   double mvlaas[11][ii][13];
1977   double ***mptras;
1978 
1979   // Region 32
1980   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE32]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE32]]{{.+}})
1981   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
1982   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
1983 
1984   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
1985   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
1986   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
1987   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
1988   // CK19-DAG: [[CBPVAL0]] = bitcast [11 x [12 x [13 x double]]]* [[VAR0:%.+]] to i8*
1989   // CK19-DAG: [[CPVAL0]] = bitcast [11 x [12 x [13 x double]]]* [[VAR0]] to i8*
1990 
1991   // CK19: call void [[CALL32:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}})
1992   #pragma omp target map(marras)
1993   {
1994     marras[1][2][3]++;
1995   }
1996 
1997   // Region 33
1998   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE33]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE33]]{{.+}})
1999   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2000   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2001 
2002   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2003   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2004   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2005   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2006   // CK19-DAG: [[CBPVAL0]] = bitcast [11 x [12 x [13 x double]]]* [[VAR0:%.+]] to i8*
2007   // CK19-DAG: [[CPVAL0]] = bitcast [12 x [13 x double]]* [[SEC0:%.+]] to i8*
2008   // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 0
2009 
2010   // CK19: call void [[CALL33:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}})
2011   #pragma omp target map(marras[:])
2012   {
2013     marras[1][2][3]++;
2014   }
2015 
2016   // Region 34
2017   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE34]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE34]]{{.+}})
2018   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2019   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2020 
2021   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2022   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2023   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2024   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2025   // CK19-DAG: [[CBPVAL0]] = bitcast [11 x [12 x [13 x double]]]* [[VAR0:%.+]] to i8*
2026   // CK19-DAG: [[CPVAL0]] = bitcast [12 x [13 x double]]* [[SEC0:%.+]] to i8*
2027   // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 0
2028 
2029   // CK19: call void [[CALL34:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}})
2030   #pragma omp target map(marras[:][:][:])
2031   {
2032     marras[1][2][3]++;
2033   }
2034 
2035   // Region 35
2036   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE35]]{{.+}})
2037   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2038   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2039   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
2040   //
2041   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2042   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2043   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
2044 
2045   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2046   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2047   // CK19-DAG: store i[[Z]] [[CSVAL0:%[^,]+]], i[[Z]]* [[S0]]
2048   // CK19-DAG: [[CBPVAL0]] = bitcast [11 x [12 x [13 x double]]]* [[VAR0:%.+]] to i8*
2049   // CK19-DAG: [[CPVAL0]] = bitcast [13 x double]* [[SEC0:%.+]] to i8*
2050   // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[12 x [13 x double]]* [[SEC00:%[^,]+]], i[[Z]] 0, i[[Z]] 0
2051   // CK19-DAG: [[SEC00]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 1
2052   // CK19-DAG: [[CSVAL0]] = mul nuw i[[Z]] %{{[^,]+}}, 104
2053 
2054   // CK19: call void [[CALL35:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}})
2055   #pragma omp target map(marras[1][:ii][:])
2056   {
2057     marras[1][2][3]++;
2058   }
2059 
2060   // Region 36
2061   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE36]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE36]]{{.+}})
2062   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2063   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2064 
2065   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2066   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2067   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2068   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2069   // CK19-DAG: [[CBPVAL0]] = bitcast [11 x [12 x [13 x double]]]* [[VAR0:%.+]] to i8*
2070   // CK19-DAG: [[CPVAL0]] = bitcast [13 x double]* [[SEC0:%.+]] to i8*
2071   // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[SEC00:%[^,]+]], i{{.+}} 0
2072   // CK19-DAG: [[SEC00]] = getelementptr {{.+}}[12 x [13 x double]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 0
2073   // CK19-DAG: [[SEC000]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 0
2074 
2075   // CK19: call void [[CALL36:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}})
2076   #pragma omp target map(marras[:1][:2][:13])
2077   {
2078     marras[1][2][3]++;
2079   }
2080 
2081   // Region 37
2082   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE37]]{{.+}})
2083   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2084   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2085   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
2086   //
2087   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2088   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2089   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
2090   // CK19-DAG: store i8* inttoptr (i[[Z]] 11 to i8*), i8** [[BP0]]
2091   // CK19-DAG: store i8* inttoptr (i[[Z]] 11 to i8*), i8** [[P0]]
2092   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S0]]
2093   //
2094   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
2095   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
2096   // CK19-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1
2097   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
2098   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
2099   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S1]]
2100   // CK19-DAG: [[CBPVAL1]] = inttoptr i[[Z]] [[VAR1:%.+]] to i8*
2101   // CK19-DAG: [[CPVAL1]] = inttoptr i[[Z]] [[VAR11:%.+]] to i8*
2102   //
2103   // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
2104   // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
2105   // CK19-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2
2106   // CK19-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
2107   // CK19-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
2108   // CK19-DAG: store i[[Z]] [[CSVAL2:%[^,]+]], i[[Z]]* [[S2]]
2109   // CK19-DAG: [[CBPVAL2]] = bitcast [13 x double]* [[VAR2:%.+]] to i8*
2110   // CK19-DAG: [[CPVAL2]] = bitcast [13 x double]* [[VAR2]] to i8*
2111   // CK19-DAG: [[CSVAL2]] = mul nuw i[[Z]] %{{[^,]+}}, 104
2112 
2113   // CK19: call void [[CALL37:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}})
2114   #pragma omp target map(mvlaas)
2115   {
2116     mvlaas[1][2][3]++;
2117   }
2118 
2119   // Region 38
2120   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE38]]{{.+}})
2121   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2122   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2123   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
2124   //
2125   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2126   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2127   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
2128   // CK19-DAG: store i8* inttoptr (i[[Z]] 11 to i8*), i8** [[BP0]]
2129   // CK19-DAG: store i8* inttoptr (i[[Z]] 11 to i8*), i8** [[P0]]
2130   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S0]]
2131   //
2132   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
2133   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
2134   // CK19-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1
2135   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
2136   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
2137   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S1]]
2138   // CK19-DAG: [[CBPVAL1]] = inttoptr i[[Z]] [[VAR1:%.+]] to i8*
2139   // CK19-DAG: [[CPVAL1]] = inttoptr i[[Z]] [[VAR11:%.+]] to i8*
2140   //
2141   // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
2142   // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
2143   // CK19-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2
2144   // CK19-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
2145   // CK19-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
2146   // CK19-DAG: store i[[Z]] [[CSVAL2:%[^,]+]], i[[Z]]* [[S2]]
2147   // CK19-DAG: [[CBPVAL2]] = bitcast [13 x double]* [[VAR2:%.+]] to i8*
2148   // CK19-DAG: [[CPVAL2]] = bitcast [13 x double]* [[SEC2:%.+]] to i8*
2149   // CK19-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC22:%[^,]+]]
2150   // CK19-DAG: [[SEC22]] = mul nsw i[[Z]] 0, %{{[^,]+}}
2151   // CK19-DAG: [[CSVAL2]] = mul nuw i[[Z]] %{{[^,]+}}, 104
2152 
2153   // CK19: call void [[CALL38:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}})
2154   #pragma omp target map(mvlaas[:])
2155   {
2156     mvlaas[1][2][3]++;
2157   }
2158 
2159   // Region 39
2160   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE39]]{{.+}})
2161   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2162   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2163   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
2164   //
2165   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2166   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2167   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
2168   // CK19-DAG: store i8* inttoptr (i[[Z]] 11 to i8*), i8** [[BP0]]
2169   // CK19-DAG: store i8* inttoptr (i[[Z]] 11 to i8*), i8** [[P0]]
2170   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S0]]
2171   //
2172   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
2173   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
2174   // CK19-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1
2175   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
2176   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
2177   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S1]]
2178   // CK19-DAG: [[CBPVAL1]] = inttoptr i[[Z]] [[VAR1:%.+]] to i8*
2179   // CK19-DAG: [[CPVAL1]] = inttoptr i[[Z]] [[VAR11:%.+]] to i8*
2180   //
2181   // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
2182   // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
2183   // CK19-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2
2184   // CK19-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
2185   // CK19-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
2186   // CK19-DAG: store i[[Z]] [[CSVAL2:%[^,]+]], i[[Z]]* [[S2]]
2187   // CK19-DAG: [[CBPVAL2]] = bitcast [13 x double]* [[VAR2:%.+]] to i8*
2188   // CK19-DAG: [[CPVAL2]] = bitcast [13 x double]* [[SEC2:%.+]] to i8*
2189   // CK19-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC22:%[^,]+]]
2190   // CK19-DAG: [[SEC22]] = mul nsw i[[Z]] 0, %{{[^,]+}}
2191   // CK19-DAG: [[CSVAL2]] = mul nuw i[[Z]] %{{[^,]+}}, 104
2192 
2193   // CK19: call void [[CALL39:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}})
2194   #pragma omp target map(mvlaas[:][:][:])
2195   {
2196     mvlaas[1][2][3]++;
2197   }
2198 
2199   // Region 40
2200   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE40]]{{.+}})
2201   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2202   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2203   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
2204   //
2205   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2206   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2207   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
2208   // CK19-DAG: store i8* inttoptr (i[[Z]] 11 to i8*), i8** [[BP0]]
2209   // CK19-DAG: store i8* inttoptr (i[[Z]] 11 to i8*), i8** [[P0]]
2210   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S0]]
2211   //
2212   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
2213   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
2214   // CK19-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1
2215   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
2216   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
2217   // CK19-DAG: store i[[Z]] {{8|4}}, i[[Z]]* [[S1]]
2218   // CK19-DAG: [[CBPVAL1]] = inttoptr i[[Z]] [[VAR1:%.+]] to i8*
2219   // CK19-DAG: [[CPVAL1]] = inttoptr i[[Z]] [[VAR11:%.+]] to i8*
2220   //
2221   // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
2222   // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
2223   // CK19-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2
2224   // CK19-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
2225   // CK19-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
2226   // CK19-DAG: store i[[Z]] [[CSVAL2:%[^,]+]], i[[Z]]* [[S2]]
2227   // CK19-DAG: [[CBPVAL2]] = bitcast [13 x double]* [[VAR2:%.+]] to i8*
2228   // CK19-DAG: [[CPVAL2]] = bitcast [13 x double]* [[SEC2:%.+]] to i8*
2229   // CK19-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[SEC22:%[^,]+]], i[[Z]] 0
2230   // CK19-DAG: [[SEC22]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC222:%[^,]+]]
2231   // CK19-DAG: [[SEC222]] = mul nsw i[[Z]] 1, %{{[^,]+}}
2232 
2233   // CK19: call void [[CALL40:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}})
2234   #pragma omp target map(mvlaas[1][:ii][:])
2235   {
2236     mvlaas[1][2][3]++;
2237   }
2238 
2239   // Region 41
2240   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[SIZE41]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE41]]{{.+}})
2241   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2242   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2243   //
2244   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2245   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2246   // CK19-DAG: store i8* inttoptr (i[[Z]] 11 to i8*), i8** [[BP0]]
2247   // CK19-DAG: store i8* inttoptr (i[[Z]] 11 to i8*), i8** [[P0]]
2248   //
2249   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
2250   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
2251   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
2252   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
2253   // CK19-DAG: [[CBPVAL1]] = inttoptr i[[Z]] [[VAR1:%.+]] to i8*
2254   // CK19-DAG: [[CPVAL1]] = inttoptr i[[Z]] [[VAR11:%.+]] to i8*
2255   //
2256   // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
2257   // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
2258   // CK19-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
2259   // CK19-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
2260   // CK19-DAG: [[CBPVAL2]] = bitcast [13 x double]* [[VAR2:%.+]] to i8*
2261   // CK19-DAG: [[CPVAL2]] = bitcast [13 x double]* [[SEC2:%.+]] to i8*
2262   // CK19-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[SEC22:%[^,]+]], i[[Z]] 0
2263   // CK19-DAG: [[SEC22]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC222:%[^,]+]]
2264   // CK19-DAG: [[SEC222]] = mul nsw i[[Z]] 0, %{{[^,]+}}
2265 
2266   // CK19: call void [[CALL41:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}})
2267   #pragma omp target map(mvlaas[:1][:2][:13])
2268   {
2269     mvlaas[1][2][3]++;
2270   }
2271 
2272   // Region 42
2273   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[SIZE42]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE42]]{{.+}})
2274   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2275   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2276 
2277   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2278   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2279   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2280   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2281   // CK19-DAG: [[CBPVAL0]] = bitcast double*** [[VAR0:%.+]] to i8*
2282   // CK19-DAG: [[CPVAL0]] = bitcast double*** [[SEC0:%.+]] to i8*
2283   // CK19-DAG: [[VAR0]] = load double***, double**** [[PTR:%[^,]+]],
2284   // CK19-DAG: [[SEC0]] = getelementptr {{.*}}double*** [[SEC00:[^,]+]], i{{.+}} 0
2285   // CK19-DAG: [[SEC00]] = load double***, double**** [[PTR]],
2286 
2287   // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
2288   // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
2289   // CK19-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
2290   // CK19-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
2291   // CK19-DAG: [[CBPVAL1]] = bitcast double*** [[SEC0]] to i8*
2292   // CK19-DAG: [[CPVAL1]] = bitcast double** [[SEC1:%.+]] to i8*
2293   // CK19-DAG: [[SEC1]] = getelementptr {{.*}}double** [[SEC11:[^,]+]], i{{.+}} 2
2294   // CK19-DAG: [[SEC11]] = load double**, double*** [[SEC111:%[^,]+]],
2295   // CK19-DAG: [[SEC111]] = getelementptr {{.*}}double*** [[SEC1111:[^,]+]], i{{.+}} 0
2296   // CK19-DAG: [[SEC1111]] = load double***, double**** [[PTR]],
2297 
2298   // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
2299   // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
2300   // CK19-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
2301   // CK19-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
2302   // CK19-DAG: [[CBPVAL2]] = bitcast double** [[SEC1]] to i8*
2303   // CK19-DAG: [[CPVAL2]] = bitcast double* [[SEC2:%.+]] to i8*
2304   // CK19-DAG: [[SEC2]] = getelementptr {{.*}}double* [[SEC22:[^,]+]], i{{.+}} 0
2305   // CK19-DAG: [[SEC22]] = load double*, double** [[SEC222:%[^,]+]],
2306   // CK19-DAG: [[SEC222]] = getelementptr {{.*}}double** [[SEC2222:[^,]+]], i{{.+}} 2
2307   // CK19-DAG: [[SEC2222]] = load double**, double*** [[SEC22222:%[^,]+]],
2308   // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}double*** [[SEC222222:[^,]+]], i{{.+}} 0
2309   // CK19-DAG: [[SEC222222]] = load double***, double**** [[PTR]],
2310 
2311   // CK19: call void [[CALL42:@.+]](double*** {{[^,]+}})
2312   #pragma omp target map(mptras[:1][2][:13])
2313   {
2314     mptras[1][2][3]++;
2315   }
2316 
2317   // Region 43 - the memory is not contiguous for this map - will map the whole last dimension.
2318   // CK19-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i[[Z]]* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE43]]{{.+}})
2319   // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2320   // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2321   // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]]
2322   //
2323   // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2324   // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2325   // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0
2326 
2327   // CK19-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2328   // CK19-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2329   // CK19-DAG: store i[[Z]] [[CSVAL0:%[^,]+]], i[[Z]]* [[S0]]
2330   // CK19-DAG: [[CBPVAL0]] = bitcast [11 x [12 x [13 x double]]]* [[VAR0:%.+]] to i8*
2331   // CK19-DAG: [[CPVAL0]] = bitcast [13 x double]* [[SEC0:%.+]] to i8*
2332   // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[12 x [13 x double]]* [[SEC00:%[^,]+]], i[[Z]] 0, i[[Z]] 0
2333   // CK19-DAG: [[SEC00]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 1
2334   // CK19-DAG: [[CSVAL0]] = mul nuw i[[Z]] %{{[^,]+}}, 104
2335 
2336   // CK19: call void [[CALL43:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}})
2337   #pragma omp target map(marras[1][:ii][1:])
2338   {
2339     marras[1][2][3]++;
2340   }
2341 
2342 }
2343 
2344 // CK19: define {{.+}}[[CALL00]]
2345 // CK19: define {{.+}}[[CALL01]]
2346 // CK19: define {{.+}}[[CALL02]]
2347 // CK19: define {{.+}}[[CALL03]]
2348 // CK19: define {{.+}}[[CALL04]]
2349 // CK19: define {{.+}}[[CALL05]]
2350 // CK19: define {{.+}}[[CALL06]]
2351 // CK19: define {{.+}}[[CALL07]]
2352 // CK19: define {{.+}}[[CALL08]]
2353 // CK19: define {{.+}}[[CALL09]]
2354 // CK19: define {{.+}}[[CALL10]]
2355 // CK19: define {{.+}}[[CALL11]]
2356 // CK19: define {{.+}}[[CALL12]]
2357 // CK19: define {{.+}}[[CALL13]]
2358 // CK19: define {{.+}}[[CALL14]]
2359 // CK19: define {{.+}}[[CALL15]]
2360 // CK19: define {{.+}}[[CALL16]]
2361 // CK19: define {{.+}}[[CALL17]]
2362 // CK19: define {{.+}}[[CALL18]]
2363 // CK19: define {{.+}}[[CALL19]]
2364 // CK19: define {{.+}}[[CALL20]]
2365 // CK19: define {{.+}}[[CALL21]]
2366 // CK19: define {{.+}}[[CALL22]]
2367 // CK19: define {{.+}}[[CALL23]]
2368 // CK19: define {{.+}}[[CALL24]]
2369 // CK19: define {{.+}}[[CALL25]]
2370 // CK19: define {{.+}}[[CALL26]]
2371 // CK19: define {{.+}}[[CALL27]]
2372 // CK19: define {{.+}}[[CALL28]]
2373 // CK19: define {{.+}}[[CALL29]]
2374 // CK19: define {{.+}}[[CALL30]]
2375 // CK19: define {{.+}}[[CALL31]]
2376 // CK19: define {{.+}}[[CALL32]]
2377 // CK19: define {{.+}}[[CALL33]]
2378 // CK19: define {{.+}}[[CALL34]]
2379 // CK19: define {{.+}}[[CALL35]]
2380 // CK19: define {{.+}}[[CALL36]]
2381 // CK19: define {{.+}}[[CALL37]]
2382 // CK19: define {{.+}}[[CALL38]]
2383 // CK19: define {{.+}}[[CALL39]]
2384 // CK19: define {{.+}}[[CALL40]]
2385 // CK19: define {{.+}}[[CALL41]]
2386 // CK19: define {{.+}}[[CALL42]]
2387 // CK19: define {{.+}}[[CALL43]]
2388 
2389 #endif
2390 ///==========================================================================///
2391 // RUN: %clang_cc1 -DCK20 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK20 --check-prefix CK20-64
2392 // RUN: %clang_cc1 -DCK20 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
2393 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK20 --check-prefix CK20-64
2394 // RUN: %clang_cc1 -DCK20 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK20 --check-prefix CK20-32
2395 // RUN: %clang_cc1 -DCK20 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
2396 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK20 --check-prefix CK20-32
2397 #ifdef CK20
2398 
2399 // CK20: [[SIZE00:@.+]] = private {{.*}}constant [1 x i[[Z:64|32]]] [i[[Z:64|32]] 4]
2400 // CK20: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i32] [i32 33]
2401 
2402 // CK20: [[SIZE01:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 20]
2403 // CK20: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i32] [i32 33]
2404 
2405 // CK20: [[SIZE02:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
2406 // CK20: [[MTYPE02:@.+]] = private {{.*}}constant [1 x i32] [i32 34]
2407 
2408 // CK20: [[SIZE03:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 12]
2409 // CK20: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i32] [i32 34]
2410 
2411 // CK20-LABEL: explicit_maps_references_and_function_args
explicit_maps_references_and_function_args(int a,float b,int (& c)[10],float * d)2412 void explicit_maps_references_and_function_args (int a, float b, int (&c)[10], float *d){
2413 
2414   int &aa = a;
2415   float &bb = b;
2416   int (&cc)[10] = c;
2417   float *&dd = d;
2418 
2419   // Region 00
2420   // CK20-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE00]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE00]]{{.+}})
2421   // CK20-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2422   // CK20-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2423 
2424   // CK20-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2425   // CK20-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2426   // CK20-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2427   // CK20-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2428   // CK20-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
2429   // CK20-DAG: [[CPVAL0]] = bitcast i32* [[RVAR00:%.+]] to i8*
2430   // CK20-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
2431   // CK20-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
2432 
2433   // CK20: call void [[CALL00:@.+]](i32* {{[^,]+}})
2434   #pragma omp target map(to:aa)
2435   {
2436     aa += 1;
2437   }
2438 
2439   // Region 01
2440   // CK20-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE01]]{{.+}})
2441   // CK20-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2442   // CK20-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2443 
2444   // CK20-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2445   // CK20-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2446   // CK20-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2447   // CK20-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2448   // CK20-DAG: [[CBPVAL0]] = bitcast [10 x i32]* [[RVAR0:%.+]] to i8*
2449   // CK20-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
2450   // CK20-DAG: [[SEC0]] = getelementptr {{.*}}[10 x i32]* [[RVAR00:%.+]], i{{.+}} 0, i{{.+}} 0
2451   // CK20-DAG: [[RVAR0]] = load [10 x i32]*, [10 x i32]** [[VAR0:%[^,]+]]
2452   // CK20-DAG: [[RVAR00]] = load [10 x i32]*, [10 x i32]** [[VAR0]]
2453 
2454   // CK20: call void [[CALL01:@.+]]([10 x i32]* {{[^,]+}})
2455   #pragma omp target map(to:cc[:5])
2456   {
2457     cc[3] += 1;
2458   }
2459 
2460   // Region 02
2461   // CK20-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE02]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE02]]{{.+}})
2462   // CK20-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2463   // CK20-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2464 
2465   // CK20-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2466   // CK20-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2467   // CK20-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2468   // CK20-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2469   // CK20-DAG: [[CBPVAL0]] = bitcast float* [[VAR0:%.+]] to i8*
2470   // CK20-DAG: [[CPVAL0]] = bitcast float* [[VAR0]] to i8*
2471 
2472   // CK20: call void [[CALL02:@.+]](float* {{[^,]+}})
2473   #pragma omp target map(from:b)
2474   {
2475     b += 1.0f;
2476   }
2477 
2478   // Region 03
2479   // CK20-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE03]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE03]]{{.+}})
2480   // CK20-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2481   // CK20-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2482 
2483   // CK20-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2484   // CK20-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2485   // CK20-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2486   // CK20-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2487   // CK20-DAG: [[CBPVAL0]] = bitcast float* [[RVAR0:%.+]] to i8*
2488   // CK20-DAG: [[CPVAL0]] = bitcast float* [[SEC0:%.+]] to i8*
2489   // CK20-DAG: [[RVAR0]] = load float*, float** [[VAR0:%[^,]+]]
2490   // CK20-DAG: [[SEC0]] = getelementptr {{.*}}float* [[RVAR00:%.+]], i{{.+}} 2
2491   // CK20-DAG: [[RVAR00]] = load float*, float** [[VAR0]]
2492 
2493   // CK20: call void [[CALL03:@.+]](float* {{[^,]+}})
2494   #pragma omp target map(from:d[2:3])
2495   {
2496     d[2] += 1.0f;
2497   }
2498 }
2499 
2500 // CK20: define {{.+}}[[CALL00]]
2501 // CK20: define {{.+}}[[CALL01]]
2502 // CK20: define {{.+}}[[CALL02]]
2503 // CK20: define {{.+}}[[CALL03]]
2504 
2505 #endif
2506 ///==========================================================================///
2507 // RUN: %clang_cc1 -DCK21 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK21 --check-prefix CK21-64
2508 // RUN: %clang_cc1 -DCK21 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
2509 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK21 --check-prefix CK21-64
2510 // RUN: %clang_cc1 -DCK21 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK21 --check-prefix CK21-32
2511 // RUN: %clang_cc1 -DCK21 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
2512 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK21 --check-prefix CK21-32
2513 #ifdef CK21
2514 // CK21: [[ST:%.+]] = type { i32, i32, float* }
2515 
2516 // CK21: [[SIZE00:@.+]] = private {{.*}}constant [1 x i[[Z:64|32]]] [i[[Z:64|32]] 4]
2517 // CK21: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2518 
2519 // CK21: [[SIZE01:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 492]
2520 // CK21: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2521 
2522 // CK21: [[SIZE02:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 500]
2523 // CK21: [[MTYPE02:@.+]] = private {{.*}}constant [2 x i32] [i32 34, i32 18]
2524 
2525 // CK21: [[SIZE03:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 492]
2526 // CK21: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i32] [i32 34]
2527 
2528 // CK21: [[SIZE04:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
2529 // CK21: [[MTYPE04:@.+]] = private {{.*}}constant [1 x i32] [i32 34]
2530 
2531 // CK21: [[SIZE05:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] 4, i[[Z]] 4]
2532 // CK21: [[MTYPE05:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 3]
2533 
2534 // CK21-LABEL: explicit_maps_template_args_and_members
2535 
2536 template <int X, typename T>
2537 struct CC {
2538   T A;
2539   int A2;
2540   float *B;
2541 
fooCC2542   int foo(T arg) {
2543     float la[X];
2544     T *lb;
2545 
2546     // Region 00
2547     // CK21-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE00]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE00]]{{.+}})
2548     // CK21-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2549     // CK21-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2550 
2551     // CK21-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2552     // CK21-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2553     // CK21-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2554     // CK21-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2555     // CK21-DAG: [[CBPVAL0]] = bitcast [[ST]]* [[VAR0:%.+]] to i8*
2556     // CK21-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
2557     // CK21-DAG: [[SEC0]] = getelementptr {{.*}}[[ST]]* [[VAR0:%.+]], i{{.+}} 0, i{{.+}} 0
2558 
2559     // CK21: call void [[CALL00:@.+]]([[ST]]* {{[^,]+}})
2560     #pragma omp target map(A)
2561     {
2562       A += 1;
2563     }
2564 
2565     // Region 01
2566     // CK21-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE01]]{{.+}})
2567     // CK21-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2568     // CK21-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2569 
2570     // CK21-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2571     // CK21-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2572     // CK21-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2573     // CK21-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2574     // CK21-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
2575     // CK21-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
2576     // CK21-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
2577     // CK21-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 0
2578     // CK21-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
2579 
2580     // CK21: call void [[CALL01:@.+]](i32* {{[^,]+}})
2581     #pragma omp target map(lb[:X])
2582     {
2583       lb[4] += 1;
2584     }
2585 
2586     // Region 02
2587     // CK21-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE02]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE02]]{{.+}})
2588     // CK21-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2589     // CK21-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2590 
2591     // CK21-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2592     // CK21-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2593     // CK21-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2594     // CK21-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2595     // CK21-DAG: [[CBPVAL0]] = bitcast [[ST]]* [[VAR0:%.+]] to i8*
2596     // CK21-DAG: [[CPVAL0]] = bitcast float** [[SEC0:%.+]] to i8*
2597     // CK21-DAG: [[SEC0]] = getelementptr {{.*}}[[ST]]* [[VAR0]], i{{.+}} 0, i{{.+}} 2
2598 
2599     // CK21-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
2600     // CK21-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
2601     // CK21-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
2602     // CK21-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
2603     // CK21-DAG: [[CBPVAL1]] = bitcast float** [[SEC0]] to i8*
2604     // CK21-DAG: [[CPVAL1]] = bitcast float* [[SEC1:%.+]] to i8*
2605     // CK21-DAG: [[SEC1]] = getelementptr {{.*}}float* [[RVAR1:%[^,]+]], i{{.+}} 123
2606     // CK21-DAG: [[RVAR1]] = load float*, float** [[SEC1_:%[^,]+]]
2607     // CK21-DAG: [[SEC1_]] = getelementptr {{.*}}[[ST]]* [[VAR0]], i{{.+}} 0, i{{.+}} 2
2608 
2609     // CK21: call void [[CALL02:@.+]]([[ST]]* {{[^,]+}})
2610     #pragma omp target map(from:B[X:X+2])
2611     {
2612       B[2] += 1.0f;
2613     }
2614 
2615     // Region 03
2616     // CK21-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE03]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE03]]{{.+}})
2617     // CK21-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2618     // CK21-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2619 
2620     // CK21-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2621     // CK21-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2622     // CK21-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2623     // CK21-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2624     // CK21-DAG: [[CBPVAL0]] = bitcast [123 x float]* [[VAR0:%.+]] to i8*
2625     // CK21-DAG: [[CPVAL0]] = bitcast [123 x float]* [[VAR0]] to i8*
2626 
2627     // CK21: call void [[CALL03:@.+]]([123 x float]* {{[^,]+}})
2628     #pragma omp target map(from:la)
2629     {
2630       la[3] += 1.0f;
2631     }
2632 
2633     // Region 04
2634     // CK21-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE04]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE04]]{{.+}})
2635     // CK21-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2636     // CK21-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2637 
2638     // CK21-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2639     // CK21-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2640     // CK21-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2641     // CK21-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2642     // CK21-DAG: [[CBPVAL0]] = bitcast i32* [[VAR0:%.+]] to i8*
2643     // CK21-DAG: [[CPVAL0]] = bitcast i32* [[VAR0]] to i8*
2644 
2645     // CK21: call void [[CALL04:@.+]](i32* {{[^,]+}})
2646     #pragma omp target map(from:arg)
2647     {
2648       arg +=1;
2649     }
2650 
2651     // Make sure the extra flag is passed to the second map.
2652     // Region 05
2653     // CK21-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE05]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE05]]{{.+}})
2654     // CK21-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2655     // CK21-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2656 
2657     // CK21-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2658     // CK21-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2659     // CK21-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2660     // CK21-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2661     // CK21-DAG: [[CBPVAL0]] = bitcast [[ST]]* [[VAR0:%.+]] to i8*
2662     // CK21-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
2663     // CK21-DAG: [[SEC0]] = getelementptr {{.*}}[[ST]]* [[VAR0]], i{{.+}} 0, i{{.+}} 0
2664 
2665     // CK21-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
2666     // CK21-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
2667     // CK21-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
2668     // CK21-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
2669     // CK21-DAG: [[CBPVAL1]] = bitcast [[ST]]* [[VAR1:%.+]] to i8*
2670     // CK21-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
2671     // CK21-DAG: [[SEC1]] = getelementptr {{.*}}[[ST]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
2672 
2673     // CK21: call void [[CALL05:@.+]]([[ST]]* {{[^,]+}})
2674     #pragma omp target map(A, A2)
2675     {
2676       A += 1;
2677       A2 += 1;
2678     }
2679     return A;
2680   }
2681 };
2682 
explicit_maps_template_args_and_members(int a)2683 int explicit_maps_template_args_and_members(int a){
2684   CC<123,int> c;
2685   return c.foo(a);
2686 }
2687 
2688 // CK21: define {{.+}}[[CALL00]]
2689 // CK21: define {{.+}}[[CALL01]]
2690 // CK21: define {{.+}}[[CALL02]]
2691 // CK21: define {{.+}}[[CALL03]]
2692 // CK21: define {{.+}}[[CALL04]]
2693 // CK21: define {{.+}}[[CALL05]]
2694 #endif
2695 ///==========================================================================///
2696 // RUN: %clang_cc1 -DCK22 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK22 --check-prefix CK22-64
2697 // RUN: %clang_cc1 -DCK22 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
2698 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK22 --check-prefix CK22-64
2699 // RUN: %clang_cc1 -DCK22 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK22 --check-prefix CK22-32
2700 // RUN: %clang_cc1 -DCK22 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
2701 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK22 --check-prefix CK22-32
2702 #ifdef CK22
2703 
2704 // CK22-DAG: [[ST:%.+]] = type { float }
2705 // CK22-DAG: [[STT:%.+]] = type { i32 }
2706 
2707 // CK22: [[SIZE00:@.+]] = private {{.*}}constant [1 x i[[Z:64|32]]] [i[[Z:64|32]] 4]
2708 // CK22: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2709 
2710 // CK22: [[SIZE01:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 400]
2711 // CK22: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2712 
2713 // CK22: [[SIZE02:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] {{8|4}}]
2714 // CK22: [[MTYPE02:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2715 
2716 // CK22: [[SIZE03:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 16]
2717 // CK22: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2718 
2719 // CK22: [[SIZE04:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 20]
2720 // CK22: [[MTYPE04:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2721 
2722 // CK22: [[SIZE05:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
2723 // CK22: [[MTYPE05:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2724 
2725 // CK22: [[SIZE06:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 400]
2726 // CK22: [[MTYPE06:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2727 
2728 // CK22: [[SIZE07:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] {{8|4}}]
2729 // CK22: [[MTYPE07:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2730 
2731 // CK22: [[SIZE08:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 16]
2732 // CK22: [[MTYPE08:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2733 
2734 // CK22: [[SIZE09:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 20]
2735 // CK22: [[MTYPE09:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2736 
2737 // CK22: [[SIZE10:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
2738 // CK22: [[MTYPE10:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2739 
2740 // CK22: [[SIZE11:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 400]
2741 // CK22: [[MTYPE11:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2742 
2743 // CK22: [[SIZE12:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] {{8|4}}]
2744 // CK22: [[MTYPE12:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2745 
2746 // CK22: [[SIZE13:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 16]
2747 // CK22: [[MTYPE13:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2748 
2749 // CK22: [[SIZE14:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 20]
2750 // CK22: [[MTYPE14:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
2751 
2752 int a;
2753 int c[100];
2754 int *d;
2755 
2756 struct ST {
2757   float fa;
2758 };
2759 
2760 ST sa ;
2761 ST sc[100];
2762 ST *sd;
2763 
2764 template<typename T>
2765 struct STT {
2766   T fa;
2767 };
2768 
2769 STT<int> sta ;
2770 STT<int> stc[100];
2771 STT<int> *std;
2772 
2773 // CK22-LABEL: explicit_maps_globals
explicit_maps_globals(void)2774 int explicit_maps_globals(void){
2775   // Region 00
2776   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE00]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE00]]{{.+}})
2777   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2778   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2779 
2780   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2781   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2782   // CK22-DAG: store i8* bitcast (i32* @a to i8*), i8** [[BP0]]
2783   // CK22-DAG: store i8* bitcast (i32* @a to i8*), i8** [[P0]]
2784 
2785   // CK22: call void [[CALL00:@.+]](i32* {{[^,]+}})
2786   #pragma omp target map(a)
2787   { a+=1; }
2788 
2789   // Region 01
2790   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE01]]{{.+}})
2791   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2792   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2793 
2794   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2795   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2796   // CK22-DAG: store i8* bitcast ([100 x i32]* @c to i8*), i8** [[BP0]]
2797   // CK22-DAG: store i8* bitcast ([100 x i32]* @c to i8*), i8** [[P0]]
2798 
2799   // CK22: call void [[CALL01:@.+]]([100 x i32]* {{[^,]+}})
2800   #pragma omp target map(c)
2801   { c[3]+=1; }
2802 
2803   // Region 02
2804   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE02]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE02]]{{.+}})
2805   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2806   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2807 
2808   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2809   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2810   // CK22-DAG: store i8* bitcast (i32** @d to i8*), i8** [[BP0]]
2811   // CK22-DAG: store i8* bitcast (i32** @d to i8*), i8** [[P0]]
2812 
2813   // CK22: call void [[CALL02:@.+]](i32** {{[^,]+}})
2814   #pragma omp target map(d)
2815   { d[3]+=1; }
2816 
2817   // Region 03
2818   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE03]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE03]]{{.+}})
2819   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2820   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2821 
2822   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2823   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2824   // CK22-DAG: store i8* bitcast ([100 x i32]* @c to i8*), i8** [[BP0]]
2825   // CK22-DAG: store i8* bitcast (i32* getelementptr inbounds ([100 x i32], [100 x i32]* @c, i{{.+}} 0, i{{.+}} 1) to i8*), i8** [[P0]]
2826 
2827   // CK22: call void [[CALL03:@.+]]([100 x i32]* {{[^,]+}})
2828   #pragma omp target map(c[1:4])
2829   { c[3]+=1; }
2830 
2831   // Region 04
2832   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE04]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE04]]{{.+}})
2833   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2834   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2835 
2836   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2837   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2838   // CK22-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2839   // CK22-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2840   // CK22-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
2841   // CK22-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
2842   // CK22-DAG: [[RVAR0]] = load i32*, i32** @d
2843   // CK22-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 2
2844   // CK22-DAG: [[RVAR00]] = load i32*, i32** @d
2845 
2846   // CK22: call void [[CALL04:@.+]](i32* {{[^,]+}})
2847   #pragma omp target map(d[2:5])
2848   { d[3]+=1; }
2849 
2850   // Region 05
2851   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE05]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE05]]{{.+}})
2852   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2853   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2854 
2855   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2856   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2857   // CK22-DAG: store i8* bitcast ([[ST]]* @sa to i8*), i8** [[BP0]]
2858   // CK22-DAG: store i8* bitcast ([[ST]]* @sa to i8*), i8** [[P0]]
2859 
2860   // CK22: call void [[CALL05:@.+]]([[ST]]* {{[^,]+}})
2861   #pragma omp target map(sa)
2862   { sa.fa+=1; }
2863 
2864   // Region 06
2865   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE06]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE06]]{{.+}})
2866   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2867   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2868 
2869   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2870   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2871   // CK22-DAG: store i8* bitcast ([100 x [[ST]]]* @sc to i8*), i8** [[BP0]]
2872   // CK22-DAG: store i8* bitcast ([100 x [[ST]]]* @sc to i8*), i8** [[P0]]
2873 
2874   // CK22: call void [[CALL06:@.+]]([100 x [[ST]]]* {{[^,]+}})
2875   #pragma omp target map(sc)
2876   { sc[3].fa+=1; }
2877 
2878   // Region 07
2879   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE07]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE07]]{{.+}})
2880   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2881   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2882 
2883   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2884   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2885   // CK22-DAG: store i8* bitcast ([[ST]]** @sd to i8*), i8** [[BP0]]
2886   // CK22-DAG: store i8* bitcast ([[ST]]** @sd to i8*), i8** [[P0]]
2887 
2888   // CK22: call void [[CALL07:@.+]]([[ST]]** {{[^,]+}})
2889   #pragma omp target map(sd)
2890   { sd[3].fa+=1; }
2891 
2892   // Region 08
2893   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE08]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE08]]{{.+}})
2894   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2895   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2896 
2897   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2898   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2899   // CK22-DAG: store i8* bitcast ([100 x [[ST]]]* @sc to i8*), i8** [[BP0]]
2900   // CK22-DAG: store i8* bitcast ([[ST]]* getelementptr inbounds ([100 x [[ST]]], [100 x [[ST]]]* @sc, i{{.+}} 0, i{{.+}} 1) to i8*), i8** [[P0]]
2901 
2902   // CK22: call void [[CALL08:@.+]]([100 x [[ST]]]* {{[^,]+}})
2903   #pragma omp target map(sc[1:4])
2904   { sc[3].fa+=1; }
2905 
2906   // Region 09
2907   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE09]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE09]]{{.+}})
2908   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2909   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2910 
2911   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2912   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2913   // CK22-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2914   // CK22-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2915   // CK22-DAG: [[CBPVAL0]] = bitcast [[ST]]* [[RVAR0:%.+]] to i8*
2916   // CK22-DAG: [[CPVAL0]] = bitcast [[ST]]* [[SEC0:%.+]] to i8*
2917   // CK22-DAG: [[RVAR0]] = load [[ST]]*, [[ST]]** @sd
2918   // CK22-DAG: [[SEC0]] = getelementptr {{.*}}[[ST]]* [[RVAR00:%.+]], i{{.+}} 2
2919   // CK22-DAG: [[RVAR00]] = load [[ST]]*, [[ST]]** @sd
2920 
2921   // CK22: call void [[CALL09:@.+]]([[ST]]* {{[^,]+}})
2922   #pragma omp target map(sd[2:5])
2923   { sd[3].fa+=1; }
2924 
2925   // Region 10
2926   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE10]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE10]]{{.+}})
2927   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2928   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2929 
2930   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2931   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2932   // CK22-DAG: store i8* bitcast ([[STT]]* @sta to i8*), i8** [[BP0]]
2933   // CK22-DAG: store i8* bitcast ([[STT]]* @sta to i8*), i8** [[P0]]
2934 
2935   // CK22: call void [[CALL10:@.+]]([[STT]]* {{[^,]+}})
2936   #pragma omp target map(sta)
2937   { sta.fa+=1; }
2938 
2939   // Region 11
2940   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE11]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE11]]{{.+}})
2941   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2942   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2943 
2944   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2945   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2946   // CK22-DAG: store i8* bitcast ([100 x [[STT]]]* @stc to i8*), i8** [[BP0]]
2947   // CK22-DAG: store i8* bitcast ([100 x [[STT]]]* @stc to i8*), i8** [[P0]]
2948 
2949   // CK22: call void [[CALL11:@.+]]([100 x [[STT]]]* {{[^,]+}})
2950   #pragma omp target map(stc)
2951   { stc[3].fa+=1; }
2952 
2953   // Region 12
2954   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE12]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE12]]{{.+}})
2955   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2956   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2957 
2958   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2959   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2960   // CK22-DAG: store i8* bitcast ([[STT]]** @std to i8*), i8** [[BP0]]
2961   // CK22-DAG: store i8* bitcast ([[STT]]** @std to i8*), i8** [[P0]]
2962 
2963   // CK22: call void [[CALL12:@.+]]([[STT]]** {{[^,]+}})
2964   #pragma omp target map(std)
2965   { std[3].fa+=1; }
2966 
2967   // Region 13
2968   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE13]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE13]]{{.+}})
2969   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2970   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2971 
2972   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2973   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2974   // CK22-DAG: store i8* bitcast ([100 x [[STT]]]* @stc to i8*), i8** [[BP0]]
2975   // CK22-DAG: store i8* bitcast ([[STT]]* getelementptr inbounds ([100 x [[STT]]], [100 x [[STT]]]* @stc, i{{.+}} 0, i{{.+}} 1) to i8*), i8** [[P0]]
2976 
2977   // CK22: call void [[CALL13:@.+]]([100 x [[STT]]]* {{[^,]+}})
2978   #pragma omp target map(stc[1:4])
2979   { stc[3].fa+=1; }
2980 
2981   // Region 14
2982   // CK22-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE14]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE14]]{{.+}})
2983   // CK22-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
2984   // CK22-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
2985 
2986   // CK22-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
2987   // CK22-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
2988   // CK22-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
2989   // CK22-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
2990   // CK22-DAG: [[CBPVAL0]] = bitcast [[STT]]* [[RVAR0:%.+]] to i8*
2991   // CK22-DAG: [[CPVAL0]] = bitcast [[STT]]* [[SEC0:%.+]] to i8*
2992   // CK22-DAG: [[RVAR0]] = load [[STT]]*, [[STT]]** @std
2993   // CK22-DAG: [[SEC0]] = getelementptr {{.*}}[[STT]]* [[RVAR00:%.+]], i{{.+}} 2
2994   // CK22-DAG: [[RVAR00]] = load [[STT]]*, [[STT]]** @std
2995 
2996   // CK22: call void [[CALL14:@.+]]([[STT]]* {{[^,]+}})
2997   #pragma omp target map(std[2:5])
2998   { std[3].fa+=1; }
2999 
3000   return 0;
3001 }
3002 // CK22: define {{.+}}[[CALL00]]
3003 // CK22: define {{.+}}[[CALL01]]
3004 // CK22: define {{.+}}[[CALL02]]
3005 // CK22: define {{.+}}[[CALL03]]
3006 // CK22: define {{.+}}[[CALL04]]
3007 // CK22: define {{.+}}[[CALL05]]
3008 // CK22: define {{.+}}[[CALL06]]
3009 // CK22: define {{.+}}[[CALL07]]
3010 // CK22: define {{.+}}[[CALL08]]
3011 // CK22: define {{.+}}[[CALL09]]
3012 // CK22: define {{.+}}[[CALL10]]
3013 // CK22: define {{.+}}[[CALL11]]
3014 // CK22: define {{.+}}[[CALL12]]
3015 // CK22: define {{.+}}[[CALL13]]
3016 // CK22: define {{.+}}[[CALL14]]
3017 #endif
3018 ///==========================================================================///
3019 // RUN: %clang_cc1 -std=c++11 -DCK23 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK23 --check-prefix CK23-64
3020 // RUN: %clang_cc1 -std=c++11 -DCK23 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
3021 // RUN: %clang_cc1 -std=c++11 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK23 --check-prefix CK23-64
3022 // RUN: %clang_cc1 -std=c++11 -DCK23 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK23 --check-prefix CK23-32
3023 // RUN: %clang_cc1 -std=c++11 -DCK23 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
3024 // RUN: %clang_cc1 -std=c++11 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK23 --check-prefix CK23-32
3025 #ifdef CK23
3026 
3027 // CK23: [[SIZE00:@.+]] = private {{.*}}constant [1 x i[[Z:64|32]]] [i[[Z:64|32]] 4]
3028 // CK23: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3029 
3030 // CK23: [[SIZE01:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
3031 // CK23: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3032 
3033 // CK23: [[SIZE02:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 400]
3034 // CK23: [[MTYPE02:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3035 
3036 // CK23: [[SIZE03:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] {{8|4}}]
3037 // CK23: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3038 
3039 // CK23: [[SIZE04:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 16]
3040 // CK23: [[MTYPE04:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3041 
3042 // CK23: [[SIZE05:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 16]
3043 // CK23: [[MTYPE05:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3044 
3045 // CK23-LABEL: explicit_maps_inside_captured
explicit_maps_inside_captured(int a)3046 int explicit_maps_inside_captured(int a){
3047   float b;
3048   float c[100];
3049   float *d;
3050 
3051   // CK23: call void @{{.*}}explicit_maps_inside_captured{{.*}}([[SA:%.+]]* {{.*}})
3052   // CK23: define {{.*}}explicit_maps_inside_captured{{.*}}
3053   [&](void){
3054     // Region 00
3055     // CK23-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE00]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE00]]{{.+}})
3056     // CK23-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3057     // CK23-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3058 
3059     // CK23-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3060     // CK23-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3061     // CK23-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3062     // CK23-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3063     // CK23-DAG: [[CBPVAL0]] = bitcast i32* [[VAR0:%.+]] to i8*
3064     // CK23-DAG: [[CPVAL0]] = bitcast i32* [[VAR00:%.+]] to i8*
3065     // CK23-DAG: [[VAR0]] = load i32*, i32** [[CAP0:%[^,]+]]
3066     // CK23-DAG: [[CAP0]] = getelementptr inbounds [[SA]], [[SA]]
3067     // CK23-DAG: [[VAR00]] = load i32*, i32** [[CAP00:%[^,]+]]
3068     // CK23-DAG: [[CAP00]] = getelementptr inbounds [[SA]], [[SA]]
3069 
3070     // CK23: call void [[CALL00:@.+]](i32* {{[^,]+}})
3071     #pragma omp target map(a)
3072       { a+=1; }
3073     // Region 01
3074     // CK23-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE01]]{{.+}})
3075     // CK23-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3076     // CK23-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3077 
3078     // CK23-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3079     // CK23-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3080     // CK23-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3081     // CK23-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3082     // CK23-DAG: [[CBPVAL0]] = bitcast float* [[VAR0:%.+]] to i8*
3083     // CK23-DAG: [[CPVAL0]] = bitcast float* [[VAR00:%.+]] to i8*
3084     // CK23-DAG: [[VAR0]] = load float*, float** [[CAP0:%[^,]+]]
3085     // CK23-DAG: [[CAP0]] = getelementptr inbounds [[SA]], [[SA]]
3086     // CK23-DAG: [[VAR00]] = load float*, float** [[CAP00:%[^,]+]]
3087     // CK23-DAG: [[CAP00]] = getelementptr inbounds [[SA]], [[SA]]
3088 
3089     // CK23: call void [[CALL01:@.+]](float* {{[^,]+}})
3090     #pragma omp target map(b)
3091       { b+=1; }
3092     // Region 02
3093     // CK23-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE02]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE02]]{{.+}})
3094     // CK23-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3095     // CK23-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3096 
3097     // CK23-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3098     // CK23-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3099     // CK23-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3100     // CK23-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3101     // CK23-DAG: [[CBPVAL0]] = bitcast [100 x float]* [[VAR0:%.+]] to i8*
3102     // CK23-DAG: [[CPVAL0]] = bitcast [100 x float]* [[VAR00:%.+]] to i8*
3103     // CK23-DAG: [[VAR0]] = load [100 x float]*, [100 x float]** [[CAP0:%[^,]+]]
3104     // CK23-DAG: [[CAP0]] = getelementptr inbounds [[SA]], [[SA]]
3105     // CK23-DAG: [[VAR00]] = load [100 x float]*, [100 x float]** [[CAP00:%[^,]+]]
3106     // CK23-DAG: [[CAP00]] = getelementptr inbounds [[SA]], [[SA]]
3107 
3108     // CK23: call void [[CALL02:@.+]]([100 x float]* {{[^,]+}})
3109     #pragma omp target map(c)
3110       { c[3]+=1; }
3111 
3112     // Region 03
3113     // CK23-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE03]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE03]]{{.+}})
3114     // CK23-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3115     // CK23-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3116 
3117     // CK23-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3118     // CK23-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3119     // CK23-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3120     // CK23-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3121     // CK23-DAG: [[CBPVAL0]] = bitcast float** [[VAR0:%.+]] to i8*
3122     // CK23-DAG: [[CPVAL0]] = bitcast float** [[VAR00:%.+]] to i8*
3123     // CK23-DAG: [[VAR0]] = load float**, float*** [[CAP0:%[^,]+]]
3124     // CK23-DAG: [[CAP0]] = getelementptr inbounds [[SA]], [[SA]]
3125     // CK23-DAG: [[VAR00]] = load float**, float*** [[CAP00:%[^,]+]]
3126     // CK23-DAG: [[CAP00]] = getelementptr inbounds [[SA]], [[SA]]
3127 
3128     // CK23: call void [[CALL03:@.+]](float** {{[^,]+}})
3129     #pragma omp target map(d)
3130       { d[3]+=1; }
3131     // Region 04
3132     // CK23-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE04]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE04]]{{.+}})
3133     // CK23-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3134     // CK23-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3135 
3136     // CK23-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3137     // CK23-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3138     // CK23-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3139     // CK23-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3140     // CK23-DAG: [[CBPVAL0]] = bitcast [100 x float]* [[VAR0:%.+]] to i8*
3141     // CK23-DAG: [[CPVAL0]] = bitcast float* [[SEC0:%.+]] to i8*
3142     // CK23-DAG: [[SEC0]] = getelementptr {{.*}}[100 x float]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 2
3143     // CK23-DAG: [[VAR0]] = load [100 x float]*, [100 x float]** [[CAP0:%[^,]+]]
3144     // CK23-DAG: [[CAP0]] = getelementptr inbounds [[SA]], [[SA]]
3145     // CK23-DAG: [[VAR00]] = load [100 x float]*, [100 x float]** [[CAP00:%[^,]+]]
3146     // CK23-DAG: [[CAP00]] = getelementptr inbounds [[SA]], [[SA]]
3147 
3148     // CK23: call void [[CALL04:@.+]]([100 x float]* {{[^,]+}})
3149     #pragma omp target map(c[2:4])
3150       { c[3]+=1; }
3151 
3152     // Region 05
3153     // CK23-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE05]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE05]]{{.+}})
3154     // CK23-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3155     // CK23-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3156 
3157     // CK23-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3158     // CK23-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3159     // CK23-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3160     // CK23-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3161     // CK23-DAG: [[CBPVAL0]] = bitcast float* [[RVAR0:%.+]] to i8*
3162     // CK23-DAG: [[CPVAL0]] = bitcast float* [[SEC0:%.+]] to i8*
3163     // CK23-DAG: [[RVAR0]] = load float*, float** [[VAR0:%[^,]+]]
3164     // CK23-DAG: [[SEC0]] = getelementptr {{.*}}float* [[RVAR00:%.+]], i{{.+}} 2
3165     // CK23-DAG: [[RVAR00]] = load float*, float** [[VAR00:%[^,]+]]
3166     // CK23-DAG: [[VAR0]] = load float**, float*** [[CAP0:%[^,]+]]
3167     // CK23-DAG: [[CAP0]] = getelementptr inbounds [[SA]], [[SA]]
3168     // CK23-DAG: [[VAR00]] = load float**, float*** [[CAP00:%[^,]+]]
3169     // CK23-DAG: [[CAP00]] = getelementptr inbounds [[SA]], [[SA]]
3170 
3171     // CK23: call void [[CALL05:@.+]](float* {{[^,]+}})
3172     #pragma omp target map(d[2:4])
3173       { d[3]+=1; }
3174   }();
3175   return b;
3176 }
3177 
3178 // CK23: define {{.+}}[[CALL00]]
3179 // CK23: define {{.+}}[[CALL01]]
3180 // CK23: define {{.+}}[[CALL02]]
3181 // CK23: define {{.+}}[[CALL03]]
3182 // CK23: define {{.+}}[[CALL04]]
3183 // CK23: define {{.+}}[[CALL05]]
3184 #endif
3185 ///==========================================================================///
3186 // RUN: %clang_cc1 -DCK24 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK24 --check-prefix CK24-64
3187 // RUN: %clang_cc1 -DCK24 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
3188 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK24 --check-prefix CK24-64
3189 // RUN: %clang_cc1 -DCK24 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK24 --check-prefix CK24-32
3190 // RUN: %clang_cc1 -DCK24 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
3191 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK24 --check-prefix CK24-32
3192 #ifdef CK24
3193 
3194 // CK24-DAG: [[SC:%.+]] = type { i32, [[SB:%.+]], [[SB:%.+]]*, [10 x i32] }
3195 // CK24-DAG: [[SB]] = type { i32, [[SA:%.+]], [10 x [[SA:%.+]]], [10 x [[SA:%.+]]*], [[SA:%.+]]* }
3196 // CK24-DAG: [[SA]] = type { i32, [[SA]]*, [10 x i32] }
3197 
3198 struct SA{
3199   int a;
3200   struct SA *p;
3201   int b[10];
3202 };
3203 struct SB{
3204   int a;
3205   struct SA s;
3206   struct SA sa[10];
3207   struct SA *sp[10];
3208   struct SA *p;
3209 };
3210 struct SC{
3211   int a;
3212   struct SB s;
3213   struct SB *p;
3214   int b[10];
3215 };
3216 
3217 // CK24: [[SIZE01:@.+]] = private {{.*}}constant [1 x i[[Z:64|32]]] [i[[Z:64|32]] 4]
3218 // CK24: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3219 
3220 // CK24: [[SIZE02:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] {{56|48}}]
3221 // CK24: [[MTYPE02:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3222 
3223 // CK24: [[SIZE03:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
3224 // CK24: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3225 
3226 // CK24: [[SIZE04:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 20]
3227 // CK24: [[MTYPE04:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3228 
3229 // CK24: [[SIZE05:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{3560|2880}}]
3230 // CK24: [[MTYPE05:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 19]
3231 
3232 // CK24: [[SIZE06:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
3233 // CK24: [[MTYPE06:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3234 
3235 // CK24: [[SIZE07:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 4]
3236 // CK24: [[MTYPE07:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 19]
3237 
3238 // CK24: [[SIZE08:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 4]
3239 // CK24: [[MTYPE08:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 19]
3240 
3241 // CK24: [[SIZE09:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 4]
3242 // CK24: [[MTYPE09:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 19]
3243 
3244 // CK24: [[SIZE10:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 8]
3245 // CK24: [[MTYPE10:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3246 
3247 // CK24: [[SIZE11:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{8|4}}]
3248 // CK24: [[MTYPE11:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 19]
3249 
3250 // CK24: [[SIZE12:@.+]] = private {{.*}}constant [4 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] 4]
3251 // CK24: [[MTYPE12:@.+]] = private {{.*}}constant [4 x i32] [i32 35, i32 19, i32 19, i32 19]
3252 
3253 // CK24: [[SIZE13:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
3254 // CK24: [[MTYPE13:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3255 
3256 // CK24: [[SIZE14:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] {{56|48}}]
3257 // CK24: [[MTYPE14:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3258 
3259 // CK24: [[SIZE15:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
3260 // CK24: [[MTYPE15:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3261 
3262 // CK24: [[SIZE16:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 20]
3263 // CK24: [[MTYPE16:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3264 
3265 // CK24: [[SIZE17:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{3560|2880}}]
3266 // CK24: [[MTYPE17:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 19]
3267 
3268 // CK24: [[SIZE18:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
3269 // CK24: [[MTYPE18:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3270 
3271 // CK24: [[SIZE19:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 4]
3272 // CK24: [[MTYPE19:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 19]
3273 
3274 // CK24: [[SIZE20:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 4]
3275 // CK24: [[MTYPE20:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 19]
3276 
3277 // CK24: [[SIZE21:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] 4]
3278 // CK24: [[MTYPE21:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 19]
3279 
3280 // CK24: [[SIZE22:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] {{8|4}}]
3281 // CK24: [[MTYPE22:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
3282 
3283 // CK24: [[SIZE23:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{8|4}}]
3284 // CK24: [[MTYPE23:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 19]
3285 
3286 // CK24: [[SIZE24:@.+]] = private {{.*}}constant [4 x i[[Z]]] [i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] {{8|4}}, i[[Z]] 4]
3287 // CK24: [[MTYPE24:@.+]] = private {{.*}}constant [4 x i32] [i32 35, i32 19, i32 19, i32 19]
3288 
3289 // CK24-LABEL: explicit_maps_struct_fields
explicit_maps_struct_fields(int a)3290 int explicit_maps_struct_fields(int a){
3291   SC s;
3292   SC *p;
3293 
3294 // Region 01
3295 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE01]]{{.+}})
3296 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3297 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3298 
3299 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3300 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3301 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3302 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3303 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3304 // CK24-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
3305 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 0
3306 
3307 // CK24: call void [[CALL01:@.+]]([[SC]]* {{[^,]+}})
3308 #pragma omp target map(s.a)
3309   { s.a++; }
3310 
3311 // Region 02
3312 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE02]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE02]]{{.+}})
3313 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3314 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3315 
3316 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3317 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3318 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3319 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3320 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3321 // CK24-DAG: [[CPVAL0]] = bitcast [[SA]]* [[SEC0:%.+]] to i8*
3322 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SB]]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 1
3323 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
3324 
3325 // CK24: call void [[CALL02:@.+]]([[SC]]* {{[^,]+}})
3326 #pragma omp target map(s.s.s)
3327   { s.a++; }
3328 
3329 // Region 03
3330 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE03]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE03]]{{.+}})
3331 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3332 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3333 
3334 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3335 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3336 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3337 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3338 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3339 // CK24-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
3340 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SA]]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3341 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SB]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 1
3342 // CK24-DAG: [[SEC000]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
3343 
3344 // CK24: call void [[CALL03:@.+]]([[SC]]* {{[^,]+}})
3345 #pragma omp target map(s.s.s.a)
3346   { s.a++; }
3347 
3348 // Region 04
3349 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE04]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE04]]{{.+}})
3350 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3351 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3352 
3353 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3354 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3355 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3356 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3357 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3358 // CK24-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
3359 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[10 x i32]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3360 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 3
3361 
3362 // CK24: call void [[CALL04:@.+]]([[SC]]* {{[^,]+}})
3363 #pragma omp target map(s.b[:5])
3364   { s.a++; }
3365 
3366 // Region 05
3367 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE05]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE05]]{{.+}})
3368 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3369 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3370 
3371 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3372 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3373 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3374 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3375 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3376 // CK24-DAG: [[CPVAL0]] = bitcast [[SB]]** [[SEC0:%.+]] to i8*
3377 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 2
3378 
3379 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3380 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3381 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3382 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3383 // CK24-DAG: [[CBPVAL1]] = bitcast [[SB]]** [[SEC0]] to i8*
3384 // CK24-DAG: [[CPVAL1]] = bitcast [[SB]]* [[SEC1:%.+]] to i8*
3385 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[[SB]]* [[SEC11:%[^,]+]], i{{.+}} 0
3386 // CK24-DAG: [[SEC11]] = load [[SB]]*, [[SB]]** [[SEC111:%[^,]+]],
3387 // CK24-DAG: [[SEC111]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 2
3388 
3389 // CK24: call void [[CALL05:@.+]]([[SC]]* {{[^,]+}})
3390 #pragma omp target map(s.p[:5])
3391   { s.a++; }
3392 
3393 // Region 06
3394 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE06]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE06]]{{.+}})
3395 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3396 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3397 
3398 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3399 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3400 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3401 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3402 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3403 // CK24-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
3404 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SA]]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3405 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[10 x [[SA]]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 3
3406 // CK24-DAG: [[SEC000]] = getelementptr {{.*}}[[SB]]* [[SEC0000:%[^,]+]], i{{.+}} 0, i{{.+}} 2
3407 // CK24-DAG: [[SEC0000]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
3408 
3409 // CK24: call void [[CALL06:@.+]]([[SC]]* {{[^,]+}})
3410 #pragma omp target map(s.s.sa[3].a)
3411   { s.a++; }
3412 
3413 // Region 07
3414 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE07]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE07]]{{.+}})
3415 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3416 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3417 
3418 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3419 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3420 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3421 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3422 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3423 // CK24-DAG: [[CPVAL0]] = bitcast [[SA]]** [[SEC0:%.+]] to i8*
3424 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[10 x [[SA]]*]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 3
3425 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SB]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 3
3426 // CK24-DAG: [[SEC000]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
3427 
3428 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3429 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3430 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3431 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3432 // CK24-DAG: [[CBPVAL1]] = bitcast [[SA]]** [[SEC0]] to i8*
3433 // CK24-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
3434 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[[SA]]* [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3435 // CK24-DAG: [[SEC11]] = load [[SA]]*, [[SA]]** [[SEC111:%[^,]+]],
3436 // CK24-DAG: [[SEC111]] = getelementptr {{.*}}[10 x [[SA]]*]* [[SEC1111:%[^,]+]], i{{.+}} 0, i{{.+}} 3
3437 // CK24-DAG: [[SEC1111]] = getelementptr {{.*}}[[SB]]* [[SEC11111:%[^,]+]], i{{.+}} 0, i{{.+}} 3
3438 // CK24-DAG: [[SEC11111]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
3439 
3440 // CK24: call void [[CALL07:@.+]]([[SC]]* {{[^,]+}})
3441 #pragma omp target map(s.s.sp[3]->a)
3442   { s.a++; }
3443 
3444 // Region 08
3445 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE08]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE08]]{{.+}})
3446 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3447 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3448 
3449 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3450 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3451 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3452 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3453 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3454 // CK24-DAG: [[CPVAL0]] = bitcast [[SB]]** [[SEC0:%.+]] to i8*
3455 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 2
3456 
3457 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3458 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3459 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3460 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3461 // CK24-DAG: [[CBPVAL1]] = bitcast [[SB]]** [[SEC0]] to i8*
3462 // CK24-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
3463 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[[SB]]* [[SEC11:%[^,]+]], i{{.+}} 0
3464 // CK24-DAG: [[SEC11]] = load [[SB]]*, [[SB]]** [[SEC111:%[^,]+]],
3465 // CK24-DAG: [[SEC111]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 2
3466 
3467 // CK24: call void [[CALL08:@.+]]([[SC]]* {{[^,]+}})
3468 #pragma omp target map(s.p->a)
3469   { s.a++; }
3470 
3471 // Region 09
3472 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE09]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE09]]{{.+}})
3473 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3474 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3475 
3476 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3477 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3478 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3479 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3480 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3481 // CK24-DAG: [[CPVAL0]] = bitcast [[SA]]** [[SEC0:%.+]] to i8*
3482 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SB]]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 4
3483 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
3484 
3485 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3486 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3487 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3488 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3489 // CK24-DAG: [[CBPVAL1]] = bitcast [[SA]]** [[SEC0]] to i8*
3490 // CK24-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
3491 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[[SA]]* [[SEC11:%[^,]+]], i{{.+}} 0
3492 // CK24-DAG: [[SEC11]] = load [[SA]]*, [[SA]]** [[SEC111:%[^,]+]],
3493 // CK24-DAG: [[SEC111]] = getelementptr {{.*}}[[SB]]* [[SEC1111:[^,]+]], i{{.+}} 0, i{{.+}} 4
3494 // CK24-DAG: [[SEC1111]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
3495 
3496 // CK24: call void [[CALL09:@.+]]([[SC]]* {{[^,]+}})
3497 #pragma omp target map(s.s.p->a)
3498   { s.a++; }
3499 
3500 // Region 10
3501 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE10]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE10]]{{.+}})
3502 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3503 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3504 
3505 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3506 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3507 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3508 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3509 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3510 // CK24-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
3511 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[10 x i32]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3512 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SA]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 2
3513 // CK24-DAG: [[SEC000]] = getelementptr {{.*}}[[SB]]* [[SEC0000:%[^,]+]], i{{.+}} 0, i{{.+}} 1
3514 // CK24-DAG: [[SEC0000]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
3515 
3516 // CK24: call void [[CALL10:@.+]]([[SC]]* {{[^,]+}})
3517 #pragma omp target map(s.s.s.b[:2])
3518   { s.a++; }
3519 
3520 // Region 11
3521 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE11]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE11]]{{.+}})
3522 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3523 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3524 
3525 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3526 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3527 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3528 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3529 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3530 // CK24-DAG: [[CPVAL0]] = bitcast [[SA]]** [[SEC0:%.+]] to i8*
3531 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SB]]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 4
3532 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
3533 
3534 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3535 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3536 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3537 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3538 // CK24-DAG: [[CBPVAL1]] = bitcast [[SA]]** [[SEC0]] to i8*
3539 // CK24-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
3540 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[10 x i32]* [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3541 // CK24-DAG: [[SEC11]] = getelementptr {{.*}}[[SA]]* [[SEC111:%[^,]+]], i{{.+}} 0, i{{.+}} 2
3542 // CK24-DAG: [[SEC111]] = load [[SA]]*, [[SA]]** [[SEC1111:%[^,]+]],
3543 // CK24-DAG: [[SEC1111]] = getelementptr {{.*}}[[SB]]* [[SEC11111:%[^,]+]], i{{.+}} 0, i{{.+}} 4
3544 // CK24-DAG: [[SEC11111]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1
3545 
3546 // CK24: call void [[CALL11:@.+]]([[SC]]* {{[^,]+}})
3547 #pragma omp target map(s.s.p->b[:2])
3548   { s.a++; }
3549 
3550 // Region 12
3551 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 4, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[4 x i{{.+}}]* [[SIZE12]], {{.+}}getelementptr {{.+}}[4 x i{{.+}}]* [[MTYPE12]]{{.+}})
3552 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3553 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3554 
3555 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3556 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3557 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3558 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3559 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3560 // CK24-DAG: [[CPVAL0]] = bitcast [[SB]]** [[SEC0:%.+]] to i8*
3561 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 2
3562 
3563 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3564 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3565 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3566 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3567 // CK24-DAG: [[CBPVAL1]] = bitcast [[SB]]** [[SEC0]] to i8*
3568 // CK24-DAG: [[CPVAL1]] = bitcast [[SA]]** [[SEC1:%.+]] to i8*
3569 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[[SB]]* [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 4
3570 // CK24-DAG: [[SEC11]] = load [[SB]]*, [[SB]]** [[SEC111:%[^,]+]],
3571 // CK24-DAG: [[SEC111]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 2
3572 
3573 // CK24-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
3574 // CK24-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
3575 // CK24-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
3576 // CK24-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
3577 // CK24-DAG: [[CBPVAL2]] = bitcast [[SA]]** [[SEC1]] to i8*
3578 // CK24-DAG: [[CPVAL2]] = bitcast [[SA]]** [[SEC2:%.+]] to i8*
3579 // CK24-DAG: [[SEC2]] = getelementptr {{.*}}[[SA]]* [[SEC22:%[^,]+]], i{{.+}} 0, i{{.+}} 1
3580 // CK24-DAG: [[SEC22]] = load [[SA]]*, [[SA]]** [[SEC222:%[^,]+]],
3581 // CK24-DAG: [[SEC222]] = getelementptr {{.*}}[[SB]]* [[SEC2222:%[^,]+]], i{{.+}} 0, i{{.+}} 4
3582 // CK24-DAG: [[SEC2222]] = load [[SB]]*, [[SB]]** [[SEC22222:%[^,]+]],
3583 // CK24-DAG: [[SEC22222]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 2
3584 
3585 // CK24-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 3
3586 // CK24-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3
3587 // CK24-DAG: store i8* [[CBPVAL3:%[^,]+]], i8** [[BP3]]
3588 // CK24-DAG: store i8* [[CPVAL3:%[^,]+]], i8** [[P3]]
3589 // CK24-DAG: [[CBPVAL3]] = bitcast [[SA]]** [[SEC2]] to i8*
3590 // CK24-DAG: [[CPVAL3]] = bitcast i32* [[SEC3:%.+]] to i8*
3591 // CK24-DAG: [[SEC3]] = getelementptr {{.*}}[[SA]]* [[SEC33:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3592 // CK24-DAG: [[SEC33]] = load [[SA]]*, [[SA]]** [[SEC333:%[^,]+]],
3593 // CK24-DAG: [[SEC333]] = getelementptr {{.*}}[[SA]]* [[SEC3333:%[^,]+]], i{{.+}} 0, i{{.+}} 1
3594 // CK24-DAG: [[SEC3333]] = load [[SA]]*, [[SA]]** [[SEC33333:%[^,]+]],
3595 // CK24-DAG: [[SEC33333]] = getelementptr {{.*}}[[SB]]* [[SEC333333:%[^,]+]], i{{.+}} 0, i{{.+}} 4
3596 // CK24-DAG: [[SEC333333]] = load [[SB]]*, [[SB]]** [[SEC3333333:%[^,]+]],
3597 // CK24-DAG: [[SEC3333333]] = getelementptr {{.*}}[[SC]]* [[VAR0]], i{{.+}} 0, i{{.+}} 2
3598 
3599 // CK24: call void [[CALL12:@.+]]([[SC]]* {{[^,]+}})
3600 #pragma omp target map(s.p->p->p->a)
3601   { s.a++; }
3602 
3603 //
3604 // Same thing but starting from a pointer.
3605 //
3606 // Region 13
3607 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE13]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE13]]{{.+}})
3608 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3609 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3610 
3611 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3612 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3613 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3614 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3615 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3616 // CK24-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
3617 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 0
3618 
3619 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3620 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3621 
3622 // CK24: call void [[CALL13:@.+]]([[SC]]* {{[^,]+}})
3623 #pragma omp target map(p->a)
3624   { p->a++; }
3625 
3626 // Region 14
3627 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE14]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE14]]{{.+}})
3628 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3629 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3630 
3631 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3632 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3633 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3634 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3635 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3636 // CK24-DAG: [[CPVAL0]] = bitcast [[SA]]* [[SEC0:%.+]] to i8*
3637 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SB]]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 1
3638 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1
3639 
3640 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3641 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3642 
3643 // CK24: call void [[CALL14:@.+]]([[SC]]* {{[^,]+}})
3644 #pragma omp target map(p->s.s)
3645   { p->a++; }
3646 
3647 // Region 15
3648 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE15]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE15]]{{.+}})
3649 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3650 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3651 
3652 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3653 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3654 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3655 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3656 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3657 // CK24-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
3658 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SA]]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3659 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SB]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 1
3660 // CK24-DAG: [[SEC000]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1
3661 
3662 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3663 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3664 
3665 // CK24: call void [[CALL15:@.+]]([[SC]]* {{[^,]+}})
3666 #pragma omp target map(p->s.s.a)
3667   { p->a++; }
3668 
3669 // Region 16
3670 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE16]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE16]]{{.+}})
3671 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3672 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3673 
3674 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3675 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3676 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3677 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3678 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3679 // CK24-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
3680 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[10 x i32]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3681 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 3
3682 
3683 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3684 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3685 
3686 // CK24: call void [[CALL16:@.+]]([[SC]]* {{[^,]+}})
3687 #pragma omp target map(p->b[:5])
3688   { p->a++; }
3689 
3690 // Region 17
3691 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE17]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE17]]{{.+}})
3692 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3693 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3694 
3695 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3696 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3697 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3698 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3699 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3700 // CK24-DAG: [[CPVAL0]] = bitcast [[SB]]** [[SEC0:%.+]] to i8*
3701 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 2
3702 
3703 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3704 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3705 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3706 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3707 // CK24-DAG: [[CBPVAL1]] = bitcast [[SB]]** [[SEC0]] to i8*
3708 // CK24-DAG: [[CPVAL1]] = bitcast [[SB]]* [[SEC1:%.+]] to i8*
3709 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[[SB]]* [[SEC11:%[^,]+]], i{{.+}} 0
3710 // CK24-DAG: [[SEC11]] = load [[SB]]*, [[SB]]** [[SEC111:%[^,]+]],
3711 // CK24-DAG: [[SEC111]] = getelementptr {{.*}}[[SC]]* [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 2
3712 
3713 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3714 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3715 // CK24-DAG: [[VAR000]] = load [[SC]]*, [[SC]]** %{{.+}}
3716 
3717 // CK24: call void [[CALL17:@.+]]([[SC]]* {{[^,]+}})
3718 #pragma omp target map(p->p[:5])
3719   { p->a++; }
3720 
3721 // Region 18
3722 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE18]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE18]]{{.+}})
3723 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3724 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3725 
3726 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3727 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3728 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3729 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3730 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3731 // CK24-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
3732 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SA]]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3733 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[10 x [[SA]]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 3
3734 // CK24-DAG: [[SEC000]] = getelementptr {{.*}}[[SB]]* [[SEC0000:%[^,]+]], i{{.+}} 0, i{{.+}} 2
3735 // CK24-DAG: [[SEC0000]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1
3736 
3737 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3738 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3739 
3740 // CK24: call void [[CALL18:@.+]]([[SC]]* {{[^,]+}})
3741 #pragma omp target map(p->s.sa[3].a)
3742   { p->a++; }
3743 
3744 // Region 19
3745 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE19]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE19]]{{.+}})
3746 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3747 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3748 
3749 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3750 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3751 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3752 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3753 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3754 // CK24-DAG: [[CPVAL0]] = bitcast [[SA]]** [[SEC0:%.+]] to i8*
3755 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[10 x [[SA]]*]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 3
3756 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SB]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 3
3757 // CK24-DAG: [[SEC000]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1
3758 
3759 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3760 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3761 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3762 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3763 // CK24-DAG: [[CBPVAL1]] = bitcast [[SA]]** [[SEC0]] to i8*
3764 // CK24-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
3765 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[[SA]]* [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3766 // CK24-DAG: [[SEC11]] = load [[SA]]*, [[SA]]** [[SEC111:%[^,]+]],
3767 // CK24-DAG: [[SEC111]] = getelementptr {{.*}}[10 x [[SA]]*]* [[SEC1111:%[^,]+]], i{{.+}} 0, i{{.+}} 3
3768 // CK24-DAG: [[SEC1111]] = getelementptr {{.*}}[[SB]]* [[SEC11111:%[^,]+]], i{{.+}} 0, i{{.+}} 3
3769 // CK24-DAG: [[SEC11111]] = getelementptr {{.*}}[[SC]]* [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 1
3770 
3771 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3772 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3773 // CK24-DAG: [[VAR000]] = load [[SC]]*, [[SC]]** %{{.+}}
3774 
3775 // CK24: call void [[CALL19:@.+]]([[SC]]* {{[^,]+}})
3776 #pragma omp target map(p->s.sp[3]->a)
3777   { p->a++; }
3778 
3779 // Region 20
3780 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE20]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE20]]{{.+}})
3781 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3782 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3783 
3784 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3785 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3786 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3787 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3788 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3789 // CK24-DAG: [[CPVAL0]] = bitcast [[SB]]** [[SEC0:%.+]] to i8*
3790 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 2
3791 
3792 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3793 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3794 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3795 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3796 // CK24-DAG: [[CBPVAL1]] = bitcast [[SB]]** [[SEC0]] to i8*
3797 // CK24-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
3798 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[[SB]]* [[SEC11:%[^,]+]], i{{.+}} 0
3799 // CK24-DAG: [[SEC11]] = load [[SB]]*, [[SB]]** [[SEC111:%[^,]+]],
3800 // CK24-DAG: [[SEC111]] = getelementptr {{.*}}[[SC]]* [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 2
3801 
3802 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3803 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3804 // CK24-DAG: [[VAR000]] = load [[SC]]*, [[SC]]** %{{.+}}
3805 
3806 // CK24: call void [[CALL20:@.+]]([[SC]]* {{[^,]+}})
3807 #pragma omp target map(p->p->a)
3808   { p->a++; }
3809 
3810 // Region 21
3811 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE21]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE21]]{{.+}})
3812 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3813 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3814 
3815 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3816 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3817 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3818 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3819 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3820 // CK24-DAG: [[CPVAL0]] = bitcast [[SA]]** [[SEC0:%.+]] to i8*
3821 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SB]]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 4
3822 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1
3823 
3824 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3825 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3826 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3827 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3828 // CK24-DAG: [[CBPVAL1]] = bitcast [[SA]]** [[SEC0]] to i8*
3829 // CK24-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
3830 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[[SA]]* [[SEC11:%[^,]+]], i{{.+}} 0
3831 // CK24-DAG: [[SEC11]] = load [[SA]]*, [[SA]]** [[SEC111:%[^,]+]],
3832 // CK24-DAG: [[SEC111]] = getelementptr {{.*}}[[SB]]* [[SEC1111:[^,]+]], i{{.+}} 0, i{{.+}} 4
3833 // CK24-DAG: [[SEC1111]] = getelementptr {{.*}}[[SC]]* [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 1
3834 
3835 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3836 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3837 // CK24-DAG: [[VAR000]] = load [[SC]]*, [[SC]]** %{{.+}}
3838 
3839 // CK24: call void [[CALL21:@.+]]([[SC]]* {{[^,]+}})
3840 #pragma omp target map(p->s.p->a)
3841   { p->a++; }
3842 
3843 // Region 22
3844 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE22]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE22]]{{.+}})
3845 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3846 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3847 
3848 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3849 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3850 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3851 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3852 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3853 // CK24-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
3854 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[10 x i32]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3855 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SA]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 2
3856 // CK24-DAG: [[SEC000]] = getelementptr {{.*}}[[SB]]* [[SEC0000:%[^,]+]], i{{.+}} 0, i{{.+}} 1
3857 // CK24-DAG: [[SEC0000]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1
3858 
3859 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3860 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3861 
3862 // CK24: call void [[CALL22:@.+]]([[SC]]* {{[^,]+}})
3863 #pragma omp target map(p->s.s.b[:2])
3864   { p->a++; }
3865 
3866 // Region 23
3867 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE23]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE23]]{{.+}})
3868 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3869 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3870 
3871 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3872 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3873 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3874 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3875 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3876 // CK24-DAG: [[CPVAL0]] = bitcast [[SA]]** [[SEC0:%.+]] to i8*
3877 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SB]]* [[SEC00:%[^,]+]], i{{.+}} 0, i{{.+}} 4
3878 // CK24-DAG: [[SEC00]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 1
3879 
3880 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3881 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3882 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3883 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3884 // CK24-DAG: [[CBPVAL1]] = bitcast [[SA]]** [[SEC0]] to i8*
3885 // CK24-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
3886 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[10 x i32]* [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3887 // CK24-DAG: [[SEC11]] = getelementptr {{.*}}[[SA]]* [[SEC111:%[^,]+]], i{{.+}} 0, i{{.+}} 2
3888 // CK24-DAG: [[SEC111]] = load [[SA]]*, [[SA]]** [[SEC1111:%[^,]+]],
3889 // CK24-DAG: [[SEC1111]] = getelementptr {{.*}}[[SB]]* [[SEC11111:%[^,]+]], i{{.+}} 0, i{{.+}} 4
3890 // CK24-DAG: [[SEC11111]] = getelementptr {{.*}}[[SC]]* [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 1
3891 
3892 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3893 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3894 // CK24-DAG: [[VAR000]] = load [[SC]]*, [[SC]]** %{{.+}}
3895 
3896 // CK24: call void [[CALL23:@.+]]([[SC]]* {{[^,]+}})
3897 #pragma omp target map(p->s.p->b[:2])
3898   { p->a++; }
3899 
3900 // Region 24
3901 // CK24-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 4, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[4 x i{{.+}}]* [[SIZE24]], {{.+}}getelementptr {{.+}}[4 x i{{.+}}]* [[MTYPE24]]{{.+}})
3902 // CK24-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
3903 // CK24-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
3904 
3905 // CK24-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
3906 // CK24-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
3907 // CK24-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
3908 // CK24-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
3909 // CK24-DAG: [[CBPVAL0]] = bitcast [[SC]]* [[VAR0:%.+]] to i8*
3910 // CK24-DAG: [[CPVAL0]] = bitcast [[SB]]** [[SEC0:%.+]] to i8*
3911 // CK24-DAG: [[SEC0]] = getelementptr {{.*}}[[SC]]* [[VAR00:%.+]], i{{.+}} 0, i{{.+}} 2
3912 
3913 // CK24-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
3914 // CK24-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
3915 // CK24-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
3916 // CK24-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
3917 // CK24-DAG: [[CBPVAL1]] = bitcast [[SB]]** [[SEC0]] to i8*
3918 // CK24-DAG: [[CPVAL1]] = bitcast [[SA]]** [[SEC1:%.+]] to i8*
3919 // CK24-DAG: [[SEC1]] = getelementptr {{.*}}[[SB]]* [[SEC11:%[^,]+]], i{{.+}} 0, i{{.+}} 4
3920 // CK24-DAG: [[SEC11]] = load [[SB]]*, [[SB]]** [[SEC111:%[^,]+]],
3921 // CK24-DAG: [[SEC111]] = getelementptr {{.*}}[[SC]]* [[VAR000:%.+]], i{{.+}} 0, i{{.+}} 2
3922 
3923 // CK24-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2
3924 // CK24-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2
3925 // CK24-DAG: store i8* [[CBPVAL2:%[^,]+]], i8** [[BP2]]
3926 // CK24-DAG: store i8* [[CPVAL2:%[^,]+]], i8** [[P2]]
3927 // CK24-DAG: [[CBPVAL2]] = bitcast [[SA]]** [[SEC1]] to i8*
3928 // CK24-DAG: [[CPVAL2]] = bitcast [[SA]]** [[SEC2:%.+]] to i8*
3929 // CK24-DAG: [[SEC2]] = getelementptr {{.*}}[[SA]]* [[SEC22:%[^,]+]], i{{.+}} 0, i{{.+}} 1
3930 // CK24-DAG: [[SEC22]] = load [[SA]]*, [[SA]]** [[SEC222:%[^,]+]],
3931 // CK24-DAG: [[SEC222]] = getelementptr {{.*}}[[SB]]* [[SEC2222:%[^,]+]], i{{.+}} 0, i{{.+}} 4
3932 // CK24-DAG: [[SEC2222]] = load [[SB]]*, [[SB]]** [[SEC22222:%[^,]+]],
3933 // CK24-DAG: [[SEC22222]] = getelementptr {{.*}}[[SC]]* [[VAR0000:%.+]], i{{.+}} 0, i{{.+}} 2
3934 
3935 // CK24-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 3
3936 // CK24-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3
3937 // CK24-DAG: store i8* [[CBPVAL3:%[^,]+]], i8** [[BP3]]
3938 // CK24-DAG: store i8* [[CPVAL3:%[^,]+]], i8** [[P3]]
3939 // CK24-DAG: [[CBPVAL3]] = bitcast [[SA]]** [[SEC2]] to i8*
3940 // CK24-DAG: [[CPVAL3]] = bitcast i32* [[SEC3:%.+]] to i8*
3941 // CK24-DAG: [[SEC3]] = getelementptr {{.*}}[[SA]]* [[SEC33:%[^,]+]], i{{.+}} 0, i{{.+}} 0
3942 // CK24-DAG: [[SEC33]] = load [[SA]]*, [[SA]]** [[SEC333:%[^,]+]],
3943 // CK24-DAG: [[SEC333]] = getelementptr {{.*}}[[SA]]* [[SEC3333:%[^,]+]], i{{.+}} 0, i{{.+}} 1
3944 // CK24-DAG: [[SEC3333]] = load [[SA]]*, [[SA]]** [[SEC33333:%[^,]+]],
3945 // CK24-DAG: [[SEC33333]] = getelementptr {{.*}}[[SB]]* [[SEC333333:%[^,]+]], i{{.+}} 0, i{{.+}} 4
3946 // CK24-DAG: [[SEC333333]] = load [[SB]]*, [[SB]]** [[SEC3333333:%[^,]+]],
3947 // CK24-DAG: [[SEC3333333]] = getelementptr {{.*}}[[SC]]* [[VAR00000:%.+]], i{{.+}} 0, i{{.+}} 2
3948 
3949 // CK24-DAG: [[VAR0]] = load [[SC]]*, [[SC]]** %{{.+}}
3950 // CK24-DAG: [[VAR00]] = load [[SC]]*, [[SC]]** %{{.+}}
3951 // CK24-DAG: [[VAR000]] = load [[SC]]*, [[SC]]** %{{.+}}
3952 // CK24-DAG: [[VAR0000]] = load [[SC]]*, [[SC]]** %{{.+}}
3953 // CK24-DAG: [[VAR00000]] = load [[SC]]*, [[SC]]** %{{.+}}
3954 
3955 // CK24: call void [[CALL24:@.+]]([[SC]]* {{[^,]+}})
3956 #pragma omp target map(p->p->p->p->a)
3957   { p->a++; }
3958 
3959   return s.a;
3960 }
3961 
3962 // CK24: define {{.+}}[[CALL01]]
3963 // CK24: define {{.+}}[[CALL02]]
3964 // CK24: define {{.+}}[[CALL03]]
3965 // CK24: define {{.+}}[[CALL04]]
3966 // CK24: define {{.+}}[[CALL05]]
3967 // CK24: define {{.+}}[[CALL06]]
3968 // CK24: define {{.+}}[[CALL07]]
3969 // CK24: define {{.+}}[[CALL08]]
3970 // CK24: define {{.+}}[[CALL09]]
3971 // CK24: define {{.+}}[[CALL10]]
3972 // CK24: define {{.+}}[[CALL11]]
3973 // CK24: define {{.+}}[[CALL12]]
3974 // CK24: define {{.+}}[[CALL13]]
3975 // CK24: define {{.+}}[[CALL14]]
3976 // CK24: define {{.+}}[[CALL15]]
3977 // CK24: define {{.+}}[[CALL16]]
3978 // CK24: define {{.+}}[[CALL17]]
3979 // CK24: define {{.+}}[[CALL18]]
3980 // CK24: define {{.+}}[[CALL19]]
3981 // CK24: define {{.+}}[[CALL20]]
3982 // CK24: define {{.+}}[[CALL21]]
3983 // CK24: define {{.+}}[[CALL22]]
3984 // CK24: define {{.+}}[[CALL23]]
3985 // CK24: define {{.+}}[[CALL24]]
3986 #endif
3987 ///==========================================================================///
3988 // RUN: %clang_cc1 -DCK25 -std=c++11 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK25 --check-prefix CK25-64
3989 // RUN: %clang_cc1 -DCK25 -std=c++11 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
3990 // RUN: %clang_cc1 -fopenmp -std=c++11 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK25 --check-prefix CK25-64
3991 // RUN: %clang_cc1 -DCK25 -std=c++11 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK25 --check-prefix CK25-32
3992 // RUN: %clang_cc1 -DCK25 -std=c++11 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
3993 // RUN: %clang_cc1 -fopenmp -std=c++11 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK25 --check-prefix CK25-32
3994 #ifdef CK25
3995 // CK25: [[ST:%.+]] = type { i32, float }
3996 // CK25: [[CA00:%.+]] = type { [[ST]]* }
3997 // CK25: [[CA01:%.+]] = type { i32* }
3998 
3999 // CK25: [[SIZE00:@.+]] = private {{.*}}constant [1 x i[[Z:64|32]]] [i[[Z:64|32]] 4]
4000 // CK25: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i32] [i32 33]
4001 
4002 // CK25: [[SIZE01:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
4003 // CK25: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i32] [i32 33]
4004 
4005 // CK25-LABEL: explicit_maps_with_inner_lambda
4006 
4007 template <int X, typename T>
4008 struct CC {
4009   T A;
4010   float B;
4011 
fooCC4012   int foo(T arg) {
4013     // Region 00
4014     // CK25-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE00]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE00]]{{.+}})
4015     // CK25-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4016     // CK25-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4017 
4018     // CK25-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4019     // CK25-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4020     // CK25-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4021     // CK25-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4022     // CK25-DAG: [[CBPVAL0]] = bitcast [[ST]]* [[VAR0:%.+]] to i8*
4023     // CK25-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
4024     // CK25-DAG: [[SEC0]] = getelementptr {{.*}}[[ST]]* [[VAR0:%.+]], i{{.+}} 0, i{{.+}} 0
4025 
4026     // CK25: call void [[CALL00:@.+]]([[ST]]* {{[^,]+}})
4027     #pragma omp target map(to:A)
4028     {
4029       [&]() {
4030         A += 1;
4031       }();
4032     }
4033 
4034     // Region 01
4035     // CK25-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE01]]{{.+}})
4036     // CK25-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4037     // CK25-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4038 
4039     // CK25-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4040     // CK25-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4041     // CK25-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4042     // CK25-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4043     // CK25-DAG: [[CBPVAL0]] = bitcast i32* [[VAR0:%.+]] to i8*
4044     // CK25-DAG: [[CPVAL0]] = bitcast i32* [[VAR0]] to i8*
4045 
4046     // CK25: call void [[CALL01:@.+]](i32* {{[^,]+}})
4047     #pragma omp target map(to:arg)
4048     {
4049       [&]() {
4050         arg += 1;
4051       }();
4052     }
4053 
4054     return A+arg;
4055   }
4056 };
4057 
explicit_maps_with_inner_lambda(int a)4058 int explicit_maps_with_inner_lambda(int a){
4059   CC<123,int> c;
4060   return c.foo(a);
4061 }
4062 
4063 // CK25: define {{.+}}[[CALL00]]([[ST]]* [[VAL:%.+]])
4064 // CK25: store [[ST]]* [[VAL]], [[ST]]** [[VALADDR:%[^,]+]],
4065 // CK25: [[VAL1:%.+]] = load [[ST]]*, [[ST]]** [[VALADDR]],
4066 // CK25: [[VALADDR1:%.+]] = getelementptr inbounds [[CA00]], [[CA00]]* [[CA:%[^,]+]], i32 0, i32 0
4067 // CK25: store [[ST]]* [[VAL1]], [[ST]]** [[VALADDR1]],
4068 // CK25: call void {{.*}}[[LAMBDA:@.+]]{{.*}}([[CA00]]* [[CA]])
4069 
4070 // CK25: define {{.+}}[[LAMBDA]]
4071 
4072 // CK25: define {{.+}}[[CALL01]](i32* {{.*}}[[VAL:%.+]])
4073 // CK25: store i32* [[VAL]], i32** [[VALADDR:%[^,]+]],
4074 // CK25: [[VAL1:%.+]] = load i32*, i32** [[VALADDR]],
4075 // CK25: [[VALADDR1:%.+]] = getelementptr inbounds [[CA01]], [[CA01]]* [[CA:%[^,]+]], i32 0, i32 0
4076 // CK25: store i32* [[VAL1]], i32** [[VALADDR1]],
4077 // CK25: call void {{.*}}[[LAMBDA]]{{.*}}([[CA01]]* [[CA]])
4078 #endif
4079 ///==========================================================================///
4080 // RUN: %clang_cc1 -DCK26 -std=c++11 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK26 --check-prefix CK26-64
4081 // RUN: %clang_cc1 -DCK26 -std=c++11 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
4082 // RUN: %clang_cc1 -fopenmp -std=c++11 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK26 --check-prefix CK26-64
4083 // RUN: %clang_cc1 -DCK26 -std=c++11 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK26 --check-prefix CK26-32
4084 // RUN: %clang_cc1 -DCK26 -std=c++11 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
4085 // RUN: %clang_cc1 -fopenmp -std=c++11 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK26 --check-prefix CK26-32
4086 #ifdef CK26
4087 // CK26: [[ST:%.+]] = type { i32, float*, i32, float* }
4088 
4089 // CK26: [[SIZE00:@.+]] = private {{.*}}constant [2 x i[[Z:64|32]]] [i[[Z:64|32]] {{32|16}}, i[[Z:64|32]] 4]
4090 // CK26: [[MTYPE00:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 35]
4091 
4092 // CK26: [[SIZE01:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{32|16}}, i[[Z]] 4]
4093 // CK26: [[MTYPE01:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 35]
4094 
4095 // CK26: [[SIZE02:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{32|16}}, i[[Z]] 4]
4096 // CK26: [[MTYPE02:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 35]
4097 
4098 // CK26: [[SIZE03:@.+]] = private {{.*}}constant [2 x i[[Z]]] [i[[Z]] {{32|16}}, i[[Z]] 4]
4099 // CK26: [[MTYPE03:@.+]] = private {{.*}}constant [2 x i32] [i32 35, i32 35]
4100 
4101 // CK26-LABEL: explicit_maps_with_private_class_members
4102 
4103 struct CC {
4104   int fA;
4105   float &fB;
4106   int pA;
4107   float &pB;
4108 
CCCC4109   CC(float &B) : fB(B), pB(B) {
4110 
4111     // CK26: call {{.*}}@__kmpc_fork_call{{.*}} [[OUTCALL:@.+]] to void (i32*, i32*, ...)*
4112     // define {{.*}}void [[OUTCALL]]
4113     #pragma omp parallel firstprivate(fA,fB) private(pA,pB)
4114     {
4115       // Region 00
4116       // CK26-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE00]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE00]]{{.+}})
4117       // CK26-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4118       // CK26-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4119 
4120       // CK26-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4121       // CK26-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4122       // CK26-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4123       // CK26-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4124       // CK26-DAG: [[CBPVAL0]] = bitcast [[ST]]* [[VAR0:%.+]] to i8*
4125       // CK26-DAG: [[CPVAL0]] = bitcast [[ST]]* [[VAR0]] to i8*
4126 
4127       // CK26-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
4128       // CK26-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
4129       // CK26-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
4130       // CK26-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
4131       // CK26-DAG: [[CBPVAL1]] = bitcast i32* [[VAR1:%.+]] to i8*
4132       // CK26-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
4133       // CK26-DAG: [[VAR1]] = load i32*, i32** [[PVT:%.+]],
4134       // CK26-DAG: [[SEC1]] = load i32*, i32** [[PVT]],
4135 
4136       // CK26: call void [[CALL00:@.+]]([[ST]]* {{[^,]+}}, i32* {{[^,]+}})
4137       #pragma omp target map(fA)
4138       {
4139         ++fA;
4140       }
4141 
4142       // Region 01
4143       // CK26-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE01]]{{.+}})
4144       // CK26-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4145       // CK26-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4146 
4147       // CK26-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4148       // CK26-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4149       // CK26-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4150       // CK26-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4151       // CK26-DAG: [[CBPVAL0]] = bitcast [[ST]]* [[VAR0:%.+]] to i8*
4152       // CK26-DAG: [[CPVAL0]] = bitcast [[ST]]* [[VAR0]] to i8*
4153 
4154       // CK26-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
4155       // CK26-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
4156       // CK26-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
4157       // CK26-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
4158       // CK26-DAG: [[CBPVAL1]] = bitcast float* [[VAR1:%.+]] to i8*
4159       // CK26-DAG: [[CPVAL1]] = bitcast float* [[SEC1:%.+]] to i8*
4160       // CK26-DAG: [[VAR1]] = load float*, float** [[PVT:%.+]],
4161       // CK26-DAG: [[SEC1]] = load float*, float** [[PVT]],
4162 
4163       // CK26: call void [[CALL01:@.+]]([[ST]]* {{[^,]+}}, float* {{[^,]+}})
4164       #pragma omp target map(fB)
4165       {
4166         fB += 1.0;
4167       }
4168 
4169       // Region 02
4170       // CK26-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE02]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE02]]{{.+}})
4171       // CK26-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4172       // CK26-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4173 
4174       // CK26-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4175       // CK26-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4176       // CK26-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4177       // CK26-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4178       // CK26-DAG: [[CBPVAL0]] = bitcast [[ST]]* [[VAR0:%.+]] to i8*
4179       // CK26-DAG: [[CPVAL0]] = bitcast [[ST]]* [[VAR0]] to i8*
4180 
4181       // CK26-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
4182       // CK26-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
4183       // CK26-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
4184       // CK26-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
4185       // CK26-DAG: [[CBPVAL1]] = bitcast i32* [[VAR1:%.+]] to i8*
4186       // CK26-DAG: [[CPVAL1]] = bitcast i32* [[SEC1:%.+]] to i8*
4187       // CK26-DAG: [[VAR1]] = load i32*, i32** [[PVT:%.+]],
4188       // CK26-DAG: [[SEC1]] = load i32*, i32** [[PVT]],
4189 
4190       // CK26: call void [[CALL02:@.+]]([[ST]]* {{[^,]+}}, i32* {{[^,]+}})
4191       #pragma omp target map(pA)
4192       {
4193         ++pA;
4194       }
4195 
4196       // Region 01
4197       // CK26-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 2, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[SIZE03]], {{.+}}getelementptr {{.+}}[2 x i{{.+}}]* [[MTYPE03]]{{.+}})
4198       // CK26-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4199       // CK26-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4200 
4201       // CK26-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4202       // CK26-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4203       // CK26-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4204       // CK26-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4205       // CK26-DAG: [[CBPVAL0]] = bitcast [[ST]]* [[VAR0:%.+]] to i8*
4206       // CK26-DAG: [[CPVAL0]] = bitcast [[ST]]* [[VAR0]] to i8*
4207 
4208       // CK26-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1
4209       // CK26-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1
4210       // CK26-DAG: store i8* [[CBPVAL1:%[^,]+]], i8** [[BP1]]
4211       // CK26-DAG: store i8* [[CPVAL1:%[^,]+]], i8** [[P1]]
4212       // CK26-DAG: [[CBPVAL1]] = bitcast float* [[VAR1:%.+]] to i8*
4213       // CK26-DAG: [[CPVAL1]] = bitcast float* [[SEC1:%.+]] to i8*
4214       // CK26-DAG: [[VAR1]] = load float*, float** [[PVT:%.+]],
4215       // CK26-DAG: [[SEC1]] = load float*, float** [[PVT]],
4216 
4217       // CK26: call void [[CALL03:@.+]]([[ST]]* {{[^,]+}}, float* {{[^,]+}})
4218       #pragma omp target map(pB)
4219       {
4220         pB += 1.0;
4221       }
4222     }
4223   }
4224 
fooCC4225   int foo() {
4226     return fA + pA;
4227   }
4228 };
4229 
4230 // Make sure the private instance is used in all target regions.
4231 // CK26: define {{.+}}[[CALL00]]({{.*}}i32*{{.*}}[[PVTARG:%.+]])
4232 // CK26: store i32* [[PVTARG]], i32** [[PVTADDR:%.+]],
4233 // CK26: [[ADDR:%.+]] = load i32*, i32** [[PVTADDR]],
4234 // CK26: [[VAL:%.+]] = load i32, i32* [[ADDR]],
4235 // CK26: add nsw i32 [[VAL]], 1
4236 
4237 // CK26: define {{.+}}[[CALL01]]({{.*}}float*{{.*}}[[PVTARG:%.+]])
4238 // CK26: store float* [[PVTARG]], float** [[PVTADDR:%.+]],
4239 // CK26: [[ADDR:%.+]] = load float*, float** [[PVTADDR]],
4240 // CK26: [[VAL:%.+]] = load float, float* [[ADDR]],
4241 // CK26: [[EXT:%.+]] = fpext float [[VAL]] to double
4242 // CK26: fadd double [[EXT]], 1.000000e+00
4243 
4244 // CK26: define {{.+}}[[CALL02]]({{.*}}i32*{{.*}}[[PVTARG:%.+]])
4245 // CK26: store i32* [[PVTARG]], i32** [[PVTADDR:%.+]],
4246 // CK26: [[ADDR:%.+]] = load i32*, i32** [[PVTADDR]],
4247 // CK26: [[VAL:%.+]] = load i32, i32* [[ADDR]],
4248 // CK26: add nsw i32 [[VAL]], 1
4249 
4250 // CK26: define {{.+}}[[CALL03]]({{.*}}float*{{.*}}[[PVTARG:%.+]])
4251 // CK26: store float* [[PVTARG]], float** [[PVTADDR:%.+]],
4252 // CK26: [[ADDR:%.+]] = load float*, float** [[PVTADDR]],
4253 // CK26: [[VAL:%.+]] = load float, float* [[ADDR]],
4254 // CK26: [[EXT:%.+]] = fpext float [[VAL]] to double
4255 // CK26: fadd double [[EXT]], 1.000000e+00
4256 
explicit_maps_with_private_class_members()4257 int explicit_maps_with_private_class_members(){
4258   float B;
4259   CC c(B);
4260   return c.foo();
4261 }
4262 #endif
4263 ///==========================================================================///
4264 // RUN: %clang_cc1 -DCK27 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK27 --check-prefix CK27-64
4265 // RUN: %clang_cc1 -DCK27 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
4266 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK27 --check-prefix CK27-64
4267 // RUN: %clang_cc1 -DCK27 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s  --check-prefix CK27 --check-prefix CK27-32
4268 // RUN: %clang_cc1 -DCK27 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s
4269 // RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s  --check-prefix CK27 --check-prefix CK27-32
4270 #ifdef CK27
4271 
4272 // CK27: [[SIZE00:@.+]] = private {{.*}}constant [1 x i[[Z:64|32]]] zeroinitializer
4273 // CK27: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i32] [i32 32]
4274 
4275 // CK27: [[SIZE01:@.+]] = private {{.*}}constant [1 x i[[Z]]] zeroinitializer
4276 // CK27: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
4277 
4278 // CK27: [[SIZE02:@.+]] = private {{.*}}constant [1 x i[[Z]]] zeroinitializer
4279 // CK27: [[MTYPE02:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
4280 
4281 // CK27: [[SIZE03:@.+]] = private {{.*}}constant [1 x i[[Z]]] zeroinitializer
4282 // CK27: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i32] [i32 35]
4283 
4284 // CK27: [[SIZE05:@.+]] = private {{.*}}constant [1 x i[[Z]]] zeroinitializer
4285 // CK27: [[MTYPE05:@.+]] = private {{.*}}constant [1 x i32] [i32 32]
4286 
4287 // CK27: [[SIZE07:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 4]
4288 // CK27: [[MTYPE07:@.+]] = private {{.*}}constant [1 x i32] [i32 288]
4289 
4290 // CK27: [[SIZE09:@.+]] = private {{.*}}constant [1 x i[[Z]]] [i[[Z]] 40]
4291 // CK27: [[MTYPE09:@.+]] = private {{.*}}constant [1 x i32] [i32 161]
4292 
4293 // CK27-LABEL: zero_size_section_and_private_maps
zero_size_section_and_private_maps(int ii)4294 void zero_size_section_and_private_maps (int ii){
4295 
4296   // Map of a pointer.
4297   int *pa;
4298 
4299   // Region 00
4300   // CK27-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE00]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE00]]{{.+}})
4301   // CK27-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4302   // CK27-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4303 
4304   // CK27-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4305   // CK27-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4306   // CK27-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4307   // CK27-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4308   // CK27-DAG: [[CBPVAL0]] = bitcast i32* [[VAR0:%.+]] to i8*
4309   // CK27-DAG: [[CPVAL0]] = bitcast i32* [[VAR0]] to i8*
4310 
4311   // CK27: call void [[CALL00:@.+]](i32* {{[^,]+}})
4312   #pragma omp target
4313   {
4314     pa[50]++;
4315   }
4316 
4317   // Region 01
4318   // CK27-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE01]]{{.+}})
4319   // CK27-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4320   // CK27-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4321 
4322   // CK27-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4323   // CK27-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4324   // CK27-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4325   // CK27-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4326   // CK27-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
4327   // CK27-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
4328   // CK27-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
4329   // CK27-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 0
4330   // CK27-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
4331 
4332   // CK27: call void [[CALL01:@.+]](i32* {{[^,]+}})
4333   #pragma omp target map(pa[:0])
4334   {
4335     pa[50]++;
4336   }
4337 
4338   // Region 02
4339   // CK27-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE02]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE02]]{{.+}})
4340   // CK27-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4341   // CK27-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4342 
4343   // CK27-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4344   // CK27-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4345   // CK27-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4346   // CK27-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4347   // CK27-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
4348   // CK27-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
4349   // CK27-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
4350   // CK27-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 0
4351   // CK27-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
4352 
4353   // CK27: call void [[CALL02:@.+]](i32* {{[^,]+}})
4354   #pragma omp target map(pa[0:0])
4355   {
4356     pa[50]++;
4357   }
4358 
4359   // Region 03
4360   // CK27-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE03]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE03]]{{.+}})
4361   // CK27-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4362   // CK27-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4363 
4364   // CK27-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4365   // CK27-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4366   // CK27-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4367   // CK27-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4368   // CK27-DAG: [[CBPVAL0]] = bitcast i32* [[RVAR0:%.+]] to i8*
4369   // CK27-DAG: [[CPVAL0]] = bitcast i32* [[SEC0:%.+]] to i8*
4370   // CK27-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]]
4371   // CK27-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} %{{.+}}
4372   // CK27-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]]
4373 
4374   // CK27: call void [[CALL03:@.+]](i32* {{[^,]+}})
4375   #pragma omp target map(pa[ii:0])
4376   {
4377     pa[50]++;
4378   }
4379 
4380   int *pvtPtr;
4381   int pvtScl;
4382   int pvtArr[10];
4383 
4384   // Region 04
4385   // CK27: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 0, i8** null, i8** null, i{{64|32}}* null, i32* null)
4386   // CK27: call void [[CALL04:@.+]]()
4387   #pragma omp target private(pvtPtr)
4388   {
4389     pvtPtr[5]++;
4390   }
4391 
4392   // Region 05
4393   // CK27-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE05]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE05]]{{.+}})
4394   // CK27-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4395   // CK27-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4396 
4397   // CK27-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4398   // CK27-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4399   // CK27-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4400   // CK27-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4401   // CK27-DAG: [[CBPVAL0]] = bitcast i32* [[VAR0:%.+]] to i8*
4402   // CK27-DAG: [[CPVAL0]] = bitcast i32* [[VAR0]] to i8*
4403 
4404   // CK27: call void [[CALL05:@.+]](i32* {{[^,]+}})
4405   #pragma omp target firstprivate(pvtPtr)
4406   {
4407     pvtPtr[5]++;
4408   }
4409 
4410   // Region 06
4411   // CK27: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 0, i8** null, i8** null, i{{64|32}}* null, i32* null)
4412   // CK27: call void [[CALL06:@.+]]()
4413   #pragma omp target private(pvtScl)
4414   {
4415     pvtScl++;
4416   }
4417 
4418   // Region 07
4419   // CK27-DAG: call i32 @__tgt_target(i32 {{.+}}, i8* {{.+}}, i32 1, i8** [[BPGEP:%[0-9]+]], i8** [[PGEP:%[0-9]+]], {{.+}}[[SIZE07]]{{.+}}, {{.+}}[[MTYPE07]]{{.+}})
4420   // CK27-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BPS:%[^,]+]], i32 0, i32 0
4421   // CK27-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[PS:%[^,]+]], i32 0, i32 0
4422   // CK27-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BPS]], i32 0, i32 0
4423   // CK27-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[PS]], i32 0, i32 0
4424   // CK27-DAG: store i8* [[VALBP:%.+]], i8** [[BP1]],
4425   // CK27-DAG: store i8* [[VALP:%.+]], i8** [[P1]],
4426   // CK27-DAG: [[VALBP]] = inttoptr i[[Z]] [[VAL:%.+]] to i8*
4427   // CK27-DAG: [[VALP]] = inttoptr i[[Z]] [[VAL:%.+]] to i8*
4428   // CK27-DAG: [[VAL]] = load i[[Z]], i[[Z]]* [[ADDR:%.+]],
4429   // CK27-64-DAG: [[CADDR:%.+]] = bitcast i[[Z]]* [[ADDR]] to i32*
4430   // CK27-64-DAG: store i32 {{.+}}, i32* [[CADDR]],
4431 
4432   // CK27: call void [[CALL07:@.+]](i[[Z]] [[VAL]])
4433   #pragma omp target firstprivate(pvtScl)
4434   {
4435     pvtScl++;
4436   }
4437 
4438   // Region 08
4439   // CK27: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 0, i8** null, i8** null, i{{64|32}}* null, i32* null)
4440   // CK27: call void [[CALL08:@.+]]()
4441   #pragma omp target private(pvtArr)
4442   {
4443     pvtArr[5]++;
4444   }
4445 
4446   // Region 09
4447   // CK27-DAG: call i32 @__tgt_target(i32 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE09]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE09]]{{.+}})
4448   // CK27-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]]
4449   // CK27-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]]
4450 
4451   // CK27-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0
4452   // CK27-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0
4453   // CK27-DAG: store i8* [[CBPVAL0:%[^,]+]], i8** [[BP0]]
4454   // CK27-DAG: store i8* [[CPVAL0:%[^,]+]], i8** [[P0]]
4455   // CK27-DAG: [[CBPVAL0]] = bitcast [10 x i32]* [[VAR0:%.+]] to i8*
4456   // CK27-DAG: [[CPVAL0]] = bitcast [10 x i32]* [[VAR0]] to i8*
4457 
4458   // CK27: call void [[CALL09:@.+]]([10 x i32]* {{[^,]+}})
4459   #pragma omp target firstprivate(pvtArr)
4460   {
4461     pvtArr[5]++;
4462   }
4463 }
4464 
4465 // CK27: define {{.+}}[[CALL00]]
4466 // CK27: define {{.+}}[[CALL01]]
4467 // CK27: define {{.+}}[[CALL02]]
4468 // CK27: define {{.+}}[[CALL03]]
4469 // CK27: define {{.+}}[[CALL04]]
4470 // CK27: define {{.+}}[[CALL05]]
4471 // CK27: define {{.+}}[[CALL06]]
4472 // CK27: define {{.+}}[[CALL07]]
4473 #endif
4474 #endif
4475