1// expected-no-diagnostics 2#ifndef HEADER_INC 3#define HEADER_INC 4 5// This file is regex-heavy and takes a long time to execute the test. To speed 6// testing up, test execution is split over multiple fimes. The RUN commands are 7// in the corresponding .cpp files now. Do not add them here. 8 9// SIMD-ONLY18-NOT: {{__kmpc|__tgt}} 10#ifdef CK19 11 12// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 13// CK19: [[SIZE00:@.+]] = private {{.*}}constant [1 x i64] [i64 4] 14// CK19-USE: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i64] [i64 32] 15// CK19-NOUSE: [[MTYPE00:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer 16 17// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 18// CK19: [[SIZE00n:@.+]] = private {{.*}}constant [1 x i64] [i64 4] 19// CK19-USE: [[MTYPE00n:@.+]] = private {{.*}}constant [1 x i64] [i64 32] 20// CK19-NOUSE: [[MTYPE00n:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer 21 22// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 23// CK19: [[SIZE01:@.+]] = private {{.*}}constant [1 x i64] [i64 400] 24// CK19-USE: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i64] [i64 33] 25// CK19-NOUSE: [[MTYPE01:@.+]] = private {{.*}}constant [1 x i64] [i64 1] 26 27// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 28// CK19: [[SIZE02:@.+]] = private {{.*}}constant [1 x i64] [i64 240] 29// CK19-USE: [[MTYPE02:@.+]] = private {{.*}}constant [1 x i64] [i64 34] 30// CK19-NOUSE: [[MTYPE02:@.+]] = private {{.*}}constant [1 x i64] [i64 2] 31 32// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 33// CK19: [[SIZE03:@.+]] = private {{.*}}constant [1 x i64] [i64 240] 34// CK19-USE: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 35// CK19-NOUSE: [[MTYPE03:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 36 37// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 38// CK19: [[SIZE04:@.+]] = private {{.*}}constant [1 x i64] [i64 400] 39// CK19-USE: [[MTYPE04:@.+]] = private {{.*}}constant [1 x i64] [i64 32] 40// CK19-NOUSE: [[MTYPE04:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer 41 42// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 43// CK19: [[SIZE05:@.+]] = private {{.*}}constant [1 x i64] [i64 4] 44// CK19-USE: [[MTYPE05:@.+]] = private {{.*}}constant [1 x i64] [i64 33] 45// CK19-NOUSE: [[MTYPE05:@.+]] = private {{.*}}constant [1 x i64] [i64 1] 46 47// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 48// CK19-USE: [[MTYPE06:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 49// CK19-NOUSE: [[MTYPE06:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 50 51// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 52// CK19-USE: [[MTYPE07:@.+]] = private {{.*}}constant [1 x i64] [i64 32] 53// CK19-NOUSE: [[MTYPE07:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer 54 55// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 56// CK19: [[SIZE08:@.+]] = private {{.*}}constant [1 x i64] [i64 4] 57// CK19-USE: [[MTYPE08:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 58// CK19-NOUSE: [[MTYPE08:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 59 60// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 61// CK19: [[SIZE09:@.+]] = private {{.*}}constant [1 x i64] [i64 {{8|4}}] 62// CK19-USE: [[MTYPE09:@.+]] = private {{.*}}constant [1 x i64] [i64 34] 63// CK19-NOUSE: [[MTYPE09:@.+]] = private {{.*}}constant [1 x i64] [i64 2] 64 65// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 66// CK19: [[SIZE10:@.+]] = private {{.*}}constant [1 x i64] [i64 240] 67// CK19-USE: [[MTYPE10:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 68// CK19-NOUSE: [[MTYPE10:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 69 70// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 71// CK19: [[SIZE11:@.+]] = private {{.*}}constant [1 x i64] [i64 240] 72// CK19-USE: [[MTYPE11:@.+]] = private {{.*}}constant [1 x i64] [i64 32] 73// CK19-NOUSE: [[MTYPE11:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer 74 75// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 76// CK19: [[SIZE12:@.+]] = private {{.*}}constant [1 x i64] [i64 4] 77// CK19-USE: [[MTYPE12:@.+]] = private {{.*}}constant [1 x i64] [i64 33] 78// CK19-NOUSE: [[MTYPE12:@.+]] = private {{.*}}constant [1 x i64] [i64 1] 79 80// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 81// CK19-USE: [[MTYPE13:@.+]] = private {{.*}}constant [1 x i64] [i64 32] 82// CK19-NOUSE: [[MTYPE13:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer 83 84// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 85// CK19-USE: [[MTYPE14:@.+]] = private {{.*}}constant [1 x i64] [i64 33] 86// CK19-NOUSE: [[MTYPE14:@.+]] = private {{.*}}constant [1 x i64] [i64 1] 87 88// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 89// CK19: [[SIZE15:@.+]] = private {{.*}}constant [1 x i64] [i64 4] 90// CK19-USE: [[MTYPE15:@.+]] = private {{.*}}constant [1 x i64] [i64 34] 91// CK19-NOUSE: [[MTYPE15:@.+]] = private {{.*}}constant [1 x i64] [i64 2] 92 93// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 94// CK19-USE: [[MTYPE16:@.+]] = private {{.*}}constant [2 x i64] [i64 800, i64 33] 95// CK19-NOUSE: [[MTYPE16:@.+]] = private {{.*}}constant [1 x i64] [i64 1] 96 97// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 98// CK19-USE: [[SIZE17:@.+]] = private {{.*}}constant [2 x i64] [i64 {{8|4}}, i64 240] 99// CK19-USE: [[MTYPE17:@.+]] = private {{.*}}constant [2 x i64] [i64 800, i64 34] 100// CK19-NOUSE: [[SIZE17:@.+]] = private {{.*}}constant [1 x i64] [i64 240] 101// CK19-NOUSE: [[MTYPE17:@.+]] = private {{.*}}constant [1 x i64] [i64 2] 102 103// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 104// CK19-USE: [[SIZE18:@.+]] = private {{.*}}constant [2 x i64] [i64 {{8|4}}, i64 240] 105// CK19-USE: [[MTYPE18:@.+]] = private {{.*}}constant [2 x i64] [i64 800, i64 35] 106// CK19-NOUSE: [[SIZE18:@.+]] = private {{.*}}constant [1 x i64] [i64 240] 107// CK19-NOUSE: [[MTYPE18:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 108 109// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 110// CK19-USE: [[MTYPE19:@.+]] = private {{.*}}constant [2 x i64] [i64 800, i64 32] 111// CK19-NOUSE: [[MTYPE19:@.+]] = private {{.*}}constant [1 x i64] zeroinitializer 112 113// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 114// CK19-USE: [[SIZE20:@.+]] = private {{.*}}constant [2 x i64] [i64 {{8|4}}, i64 4] 115// CK19-USE: [[MTYPE20:@.+]] = private {{.*}}constant [2 x i64] [i64 800, i64 33] 116// CK19-NOUSE: [[SIZE20:@.+]] = private {{.*}}constant [1 x i64] [i64 4] 117// CK19-NOUSE: [[MTYPE20:@.+]] = private {{.*}}constant [1 x i64] [i64 1] 118 119// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 120// CK19-USE: [[MTYPE21:@.+]] = private {{.*}}constant [2 x i64] [i64 800, i64 35] 121// CK19-NOUSE: [[MTYPE21:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 122 123// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 124// CK19-USE: [[SIZE22:@.+]] = private {{.*}}constant [2 x i64] [i64 {{8|4}}, i64 4] 125// CK19-USE: [[MTYPE22:@.+]] = private {{.*}}constant [2 x i64] [i64 800, i64 35] 126// CK19-NOUSE: [[SIZE22:@.+]] = private {{.*}}constant [1 x i64] [i64 4] 127// CK19-NOUSE: [[MTYPE22:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 128 129// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 130// CK19: [[SIZE23:@.+]] = private {{.*}}constant [1 x i64] [i64 4] 131// CK19-USE: [[MTYPE23:@.+]] = private {{.*}}constant [1 x i64] [i64 39] 132// CK19-NOUSE: [[MTYPE23:@.+]] = private {{.*}}constant [1 x i64] [i64 7] 133 134// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 135// CK19: [[SIZE24:@.+]] = private {{.*}}constant [1 x i64] [i64 480] 136// CK19-USE: [[MTYPE24:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 137// CK19-NOUSE: [[MTYPE24:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 138 139// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 140// CK19: [[SIZE25:@.+]] = private {{.*}}constant [1 x i64] [i64 16] 141// CK19-USE: [[MTYPE25:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 142// CK19-NOUSE: [[MTYPE25:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 143 144// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 145// CK19: [[SIZE26:@.+]] = private {{.*}}constant [1 x i64] [i64 24] 146// CK19-USE: [[MTYPE26:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 147// CK19-NOUSE: [[MTYPE26:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 148 149// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 150// CK19: [[SIZE27:@.+]] = private {{.*}}constant [1 x i64] [i64 4] 151// CK19-USE: [[MTYPE27:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 152// CK19-NOUSE: [[MTYPE27:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 153 154// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 155// CK19: [[SIZE28:@.+]] = private {{.*}}constant [3 x i64] [i64 {{8|4}}, i64 {{8|4}}, i64 16] 156// CK19-USE: [[MTYPE28:@.+]] = private {{.*}}constant [3 x i64] [i64 35, i64 16, i64 19] 157// CK19-NOUSE: [[MTYPE28:@.+]] = private {{.*}}constant [3 x i64] [i64 3, i64 16, i64 19] 158 159// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 160// CK19: [[SIZE29:@.+]] = private {{.*}}constant [3 x i64] [i64 {{8|4}}, i64 {{8|4}}, i64 4] 161// CK19-USE: [[MTYPE29:@.+]] = private {{.*}}constant [3 x i64] [i64 35, i64 16, i64 19] 162// CK19-NOUSE: [[MTYPE29:@.+]] = private {{.*}}constant [3 x i64] [i64 3, i64 16, i64 19] 163 164// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 165// CK19-USE: [[MTYPE30:@.+]] = private {{.*}}constant [4 x i64] [i64 800, i64 800, i64 800, i64 35] 166// CK19-NOUSE: [[MTYPE30:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 167 168// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 169// CK19-USE: [[SIZE31:@.+]] = private {{.*}}constant [4 x i64] [i64 {{8|4}}, i64 {{8|4}}, i64 {{8|4}}, i64 40] 170// CK19-USE: [[MTYPE31:@.+]] = private {{.*}}constant [4 x i64] [i64 800, i64 800, i64 800, i64 35] 171// CK19-NOUSE: [[SIZE31:@.+]] = private {{.*}}constant [1 x i64] [i64 40] 172// CK19-NOUSE: [[MTYPE31:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 173 174// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 175// CK19: [[SIZE32:@.+]] = private {{.*}}constant [1 x i64] [i64 13728] 176// CK19-USE: [[MTYPE32:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 177// CK19-NOUSE: [[MTYPE32:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 178 179// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 180// CK19: [[SIZE33:@.+]] = private {{.*}}constant [1 x i64] [i64 13728] 181// CK19-USE: [[MTYPE33:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 182// CK19-NOUSE: [[MTYPE33:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 183 184// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 185// CK19: [[SIZE34:@.+]] = private {{.*}}constant [1 x i64] [i64 13728] 186// CK19-USE: [[MTYPE34:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 187// CK19-NOUSE: [[MTYPE34:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 188 189// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 190// CK19-USE: [[MTYPE35:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 191// CK19-NOUSE: [[MTYPE35:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 192 193// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 194// CK19: [[SIZE36:@.+]] = private {{.*}}constant [1 x i64] [i64 208] 195// CK19-USE: [[MTYPE36:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 196// CK19-NOUSE: [[MTYPE36:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 197 198// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 199// CK19-USE: [[MTYPE37:@.+]] = private {{.*}}constant [3 x i64] [i64 800, i64 800, i64 35] 200// CK19-NOUSE: [[MTYPE37:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 201 202// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 203// CK19-USE: [[MTYPE38:@.+]] = private {{.*}}constant [3 x i64] [i64 800, i64 800, i64 35] 204// CK19-NOUSE: [[MTYPE38:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 205 206// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 207// CK19-USE: [[MTYPE39:@.+]] = private {{.*}}constant [3 x i64] [i64 800, i64 800, i64 35] 208// CK19-NOUSE: [[MTYPE39:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 209 210// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 211// CK19-USE: [[MTYPE40:@.+]] = private {{.*}}constant [3 x i64] [i64 800, i64 800, i64 35] 212// CK19-NOUSE: [[MTYPE40:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 213 214// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 215// CK19-USE: [[SIZE41:@.+]] = private {{.*}}constant [3 x i64] [i64 {{8|4}}, i64 {{8|4}}, i64 208] 216// CK19-USE: [[MTYPE41:@.+]] = private {{.*}}constant [3 x i64] [i64 800, i64 800, i64 35] 217// CK19-NOUSE: [[SIZE41:@.+]] = private {{.*}}constant [1 x i64] [i64 208] 218// CK19-NOUSE: [[MTYPE41:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 219 220// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 221// CK19: [[SIZE42:@.+]] = private {{.*}}constant [3 x i64] [i64 {{8|4}}, i64 {{8|4}}, i64 104] 222// CK19-USE: [[MTYPE42:@.+]] = private {{.*}}constant [3 x i64] [i64 35, i64 16, i64 19] 223// CK19-NOUSE: [[MTYPE42:@.+]] = private {{.*}}constant [3 x i64] [i64 3, i64 16, i64 19] 224 225// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 226// CK19-USE: [[MTYPE43:@.+]] = private {{.*}}constant [1 x i64] [i64 35] 227// CK19-NOUSE: [[MTYPE43:@.+]] = private {{.*}}constant [1 x i64] [i64 3] 228 229// CK19-LABEL: @.__omp_offloading_{{.*}}explicit_maps_single{{.*}}_l{{[0-9]+}}.region_id = weak constant i8 0 230// CK19: [[SIZE44:@.+]] = private {{.*}}constant [1 x i64] [i64 320] 231// CK19-USE: [[MTYPE44:@.+]] = private {{.*}}constant [1 x i64] [i64 34] 232// CK19-NOUSE: [[MTYPE44:@.+]] = private {{.*}}constant [1 x i64] [i64 2] 233 234// CK19-LABEL: explicit_maps_single{{.*}}( 235void explicit_maps_single (int ii){ 236 // Map of a scalar. 237 int a = ii; 238 239 // Region 00 240 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE00]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE00]]{{.+}}, i8** null, i8** null) 241 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 242 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 243 244 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 245 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 246 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 247 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 248 // CK19-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] 249 // CK19-DAG: store i32* [[VAR0]], i32** [[CP0]] 250 251 // CK19-USE: call void [[CALL00:@.+]](i32* {{[^,]+}}) 252 // CK19-NOUSE: call void [[CALL00:@.+]]() 253 #pragma omp target map(alloc:a) 254 { 255#ifdef USE 256 ++a; 257#endif 258 } 259 260 // Map of a scalar in nested region. 261 int b = a; 262 263 // Region 00n 264 // CK19-DAG: call i32 @__tgt_target_teams_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE00n]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE00n]]{{.+}}, i8** null, i8** null, i32 1, i32 0) 265 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 266 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 267 268 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 269 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 270 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 271 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 272 // CK19-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] 273 // CK19-DAG: store i32* [[VAR0]], i32** [[CP0]] 274 275 // CK19-USE: call void [[CALL00n:@.+]](i32* {{[^,]+}}) 276 // CK19-NOUSE: call void [[CALL00n:@.+]]() 277 #pragma omp target map(alloc:b) 278 #pragma omp parallel 279 { 280#ifdef USE 281 ++b; 282#endif 283 } 284 285 // Map of an array. 286 int arra[100]; 287 288 // Region 01 289 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE01]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE01]]{{.+}}, i8** null, i8** null) 290 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 291 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 292 293 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 294 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 295 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** 296 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [100 x i32]** 297 // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] 298 // CK19-DAG: store [100 x i32]* [[VAR0]], [100 x i32]** [[CP0]] 299 300 // CK19-USE: call void [[CALL01:@.+]]([100 x i32]* {{[^,]+}}) 301 // CK19-NOUSE: call void [[CALL01:@.+]]() 302 #pragma omp target map(to:arra) 303 { 304#ifdef USE 305 arra[50]++; 306#endif 307 } 308 309 // Region 02 310 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE02]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE02]]{{.+}}, i8** null, i8** null) 311 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 312 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 313 314 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 315 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 316 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** 317 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 318 // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] 319 // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] 320 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 20 321 322 // CK19-USE: call void [[CALL02:@.+]]([100 x i32]* {{[^,]+}}) 323 // CK19-NOUSE: call void [[CALL02:@.+]]() 324 #pragma omp target map(from:arra[20:60]) 325 { 326#ifdef USE 327 arra[50]++; 328#endif 329 } 330 331 // Region 03 332 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE03]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE03]]{{.+}}, i8** null, i8** null) 333 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 334 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 335 336 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 337 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 338 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** 339 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 340 // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] 341 // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] 342 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 0 343 344 // CK19-USE: call void [[CALL03:@.+]]([100 x i32]* {{[^,]+}}) 345 // CK19-NOUSE: call void [[CALL03:@.+]]() 346 #pragma omp target map(tofrom:arra[:60]) 347 { 348#ifdef USE 349 arra[50]++; 350#endif 351 } 352 353 // Region 04 354 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE04]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE04]]{{.+}}, i8** null, i8** null) 355 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 356 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 357 358 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 359 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 360 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** 361 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 362 // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] 363 // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] 364 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 0 365 366 // CK19-USE: call void [[CALL04:@.+]]([100 x i32]* {{[^,]+}}) 367 // CK19-NOUSE: call void [[CALL04:@.+]]() 368 #pragma omp target map(alloc:arra[:]) 369 { 370#ifdef USE 371 arra[50]++; 372#endif 373 } 374 375 // Region 05 376 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE05]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE05]]{{.+}}, i8** null, i8** null) 377 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 378 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 379 380 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 381 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 382 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** 383 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 384 // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] 385 // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] 386 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 15 387 388 // CK19-USE: call void [[CALL05:@.+]]([100 x i32]* {{[^,]+}}) 389 // CK19-NOUSE: call void [[CALL05:@.+]]() 390 #pragma omp target map(to:arra[15]) 391 { 392#ifdef USE 393 arra[15]++; 394#endif 395 } 396 397 // Region 06 398 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE06]]{{.+}}, i8** null, i8** null) 399 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 400 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 401 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 402 403 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 404 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 405 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 406 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** 407 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 408 // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] 409 // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] 410 // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] 411 // CK19-DAG: [[CSVAL0]] = {{mul nuw i.+ %.*, 4|sext i32 .+ to i64}} 412 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} %{{.*}} 413 414 // CK19-USE: call void [[CALL06:@.+]]([100 x i32]* {{[^,]+}}) 415 // CK19-NOUSE: call void [[CALL06:@.+]]() 416 #pragma omp target map(tofrom:arra[ii:ii+23]) 417 { 418#ifdef USE 419 arra[50]++; 420#endif 421 } 422 423 // Region 07 424 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE07]]{{.+}}, i8** null, i8** null) 425 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 426 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 427 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 428 429 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 430 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 431 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 432 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** 433 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 434 // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] 435 // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] 436 // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] 437 // CK19-DAG: [[CSVAL0]] = {{mul nuw i.+ %.*, 4|sext i32 .+ to i64}} 438 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 0 439 440 // CK19-USE: call void [[CALL07:@.+]]([100 x i32]* {{[^,]+}}) 441 // CK19-NOUSE: call void [[CALL07:@.+]]() 442 #pragma omp target map(alloc:arra[:ii]) 443 { 444#ifdef USE 445 arra[50]++; 446#endif 447 } 448 449 // Region 08 450 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE08]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE08]]{{.+}}, i8** null, i8** null) 451 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 452 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 453 454 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 455 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 456 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** 457 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 458 // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] 459 // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] 460 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} %{{.*}} 461 462 // CK19-USE: call void [[CALL08:@.+]]([100 x i32]* {{[^,]+}}) 463 // CK19-NOUSE: call void [[CALL08:@.+]]() 464 #pragma omp target map(tofrom:arra[ii]) 465 { 466#ifdef USE 467 arra[15]++; 468#endif 469 } 470 471 // Map of a pointer. 472 int *pa; 473 474 // Region 09 475 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE09]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE09]]{{.+}}, i8** null, i8** null) 476 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 477 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 478 479 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 480 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 481 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32*** 482 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32*** 483 // CK19-DAG: store i32** [[VAR0:%.+]], i32*** [[CBP0]] 484 // CK19-DAG: store i32** [[VAR0]], i32*** [[CP0]] 485 486 // CK19-USE: call void [[CALL09:@.+]](i32** {{[^,]+}}) 487 // CK19-NOUSE: call void [[CALL09:@.+]]() 488 #pragma omp target map(from:pa) 489 { 490#ifdef USE 491 pa[50]++; 492#endif 493 } 494 495 // Region 10 496 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE10]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE10]]{{.+}}, i8** null, i8** null) 497 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 498 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 499 500 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 501 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 502 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 503 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 504 // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] 505 // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 506 // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] 507 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 20 508 // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] 509 510 // CK19-USE: call void [[CALL10:@.+]](i32* {{[^,]+}}) 511 // CK19-NOUSE: call void [[CALL10:@.+]]() 512 #pragma omp target map(tofrom:pa[20:60]) 513 { 514#ifdef USE 515 pa[50]++; 516#endif 517 } 518 519 // Region 11 520 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE11]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE11]]{{.+}}, i8** null, i8** null) 521 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 522 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 523 524 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 525 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 526 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 527 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 528 // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] 529 // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 530 // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] 531 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 0 532 // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] 533 534 // CK19-USE: call void [[CALL11:@.+]](i32* {{[^,]+}}) 535 // CK19-NOUSE: call void [[CALL11:@.+]]() 536 #pragma omp target map(alloc:pa[:60]) 537 { 538#ifdef USE 539 pa[50]++; 540#endif 541 } 542 543 // Region 12 544 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE12]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE12]]{{.+}}, i8** null, i8** null) 545 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 546 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 547 548 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 549 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 550 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 551 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 552 // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] 553 // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 554 // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] 555 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 15 556 // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] 557 558 // CK19-USE: call void [[CALL12:@.+]](i32* {{[^,]+}}) 559 // CK19-NOUSE: call void [[CALL12:@.+]]() 560 #pragma omp target map(to:pa[15]) 561 { 562#ifdef USE 563 pa[15]++; 564#endif 565 } 566 567 // Region 13 568 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE13]]{{.+}}, i8** null, i8** null) 569 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 570 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 571 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 572 573 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 574 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 575 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 576 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 577 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 578 // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] 579 // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 580 // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] 581 // CK19-DAG: [[CSVAL0]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} 582 // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] 583 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} %{{.*}} 584 // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] 585 586 // CK19-USE: call void [[CALL13:@.+]](i32* {{[^,]+}}) 587 // CK19-NOUSE: call void [[CALL13:@.+]]() 588 #pragma omp target map(alloc:pa[ii-23:ii]) 589 { 590#ifdef USE 591 pa[50]++; 592#endif 593 } 594 595 // Region 14 596 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE14]]{{.+}}, i8** null, i8** null) 597 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 598 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 599 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 600 601 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 602 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 603 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 604 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 605 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 606 // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] 607 // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 608 // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] 609 // CK19-DAG: [[CSVAL0]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} 610 // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] 611 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 0 612 // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] 613 614 // CK19-USE: call void [[CALL14:@.+]](i32* {{[^,]+}}) 615 // CK19-NOUSE: call void [[CALL14:@.+]]() 616 #pragma omp target map(to:pa[:ii]) 617 { 618#ifdef USE 619 pa[50]++; 620#endif 621 } 622 623 // Region 15 624 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE15]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE15]]{{.+}}, i8** null, i8** null) 625 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 626 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 627 628 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 629 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 630 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 631 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 632 // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] 633 // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 634 // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] 635 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} %{{.*}} 636 // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] 637 638 // CK19-USE: call void [[CALL15:@.+]](i32* {{[^,]+}}) 639 // CK19-NOUSE: call void [[CALL15:@.+]]() 640 #pragma omp target map(from:pa[ii+12]) 641 { 642#ifdef USE 643 pa[15]++; 644#endif 645 } 646 647 // Map of a variable-size array. 648 int va[ii]; 649 650 // Region 16 651 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|2}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[MTYPE16]]{{.+}}, i8** null, i8** null) 652 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 653 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 654 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 655 656 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 657 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 658 // CK19-USE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 659 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z:64|32]]* 660 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 661 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] 662 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] 663 // CK19-USE-DAG: store i{{.+}} {{8|4}}, i{{.+}}* [[S0]] 664 665 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 666 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 667 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 668 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** 669 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** 670 // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] 671 // CK19-USE-DAG: store i32* [[VAR1]], i32** [[CP1]] 672 // CK19-USE-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], i{{.+}}* [[S1]] 673 // CK19-USE-DAG: [[CSVAL1]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} 674 675 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 676 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 677 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 678 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 679 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 680 // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] 681 // CK19-NOUSE-DAG: store i32* [[VAR0]], i32** [[CP0]] 682 // CK19-NOUSE-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] 683 // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} 684 685 // CK19-USE: call void [[CALL16:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) 686 // CK19-NOUSE: call void [[CALL16:@.+]]() 687 #pragma omp target map(to:va) 688 { 689#ifdef USE 690 va[50]++; 691#endif 692 } 693 694 // Region 17 695 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|2}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[SIZE17]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[MTYPE17]]{{.+}}, i8** null, i8** null) 696 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 697 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 698 699 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 700 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 701 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 702 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 703 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] 704 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] 705 706 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 707 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 708 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** 709 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** 710 // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] 711 // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] 712 // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 20 713 714 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 715 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 716 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 717 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 718 // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] 719 // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 720 // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} 20 721 722 // CK19-USE: call void [[CALL17:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) 723 // CK19-NOUSE: call void [[CALL17:@.+]]() 724 #pragma omp target map(from:va[20:60]) 725 { 726#ifdef USE 727 va[50]++; 728#endif 729 } 730 731 // Region 18 732 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|2}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[SIZE18]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[MTYPE18]]{{.+}}, i8** null, i8** null) 733 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 734 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 735 736 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 737 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 738 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 739 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 740 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] 741 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] 742 743 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 744 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 745 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** 746 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** 747 // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] 748 // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] 749 // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 0 750 751 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 752 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 753 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 754 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 755 // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] 756 // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 757 // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} 0 758 759 // CK19-USE: call void [[CALL18:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) 760 // CK19-NOUSE: call void [[CALL18:@.+]]() 761 #pragma omp target map(tofrom:va[:60]) 762 { 763#ifdef USE 764 va[50]++; 765#endif 766 } 767 768 // Region 19 769 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|2}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[MTYPE19]]{{.+}}, i8** null, i8** null) 770 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 771 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 772 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 773 774 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 775 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 776 // CK19-USE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 777 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 778 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 779 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] 780 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] 781 // CK19-USE-DAG: store i{{.+}} {{8|4}}, i{{.+}}* [[S0]] 782 783 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 784 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 785 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 786 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** 787 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** 788 // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] 789 // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] 790 // CK19-USE-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], i{{.+}}* [[S1]] 791 // CK19-USE-DAG: [[CSVAL1]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} 792 // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 0 793 794 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 795 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 796 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 797 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 798 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 799 // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] 800 // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 801 // CK19-NOUSE-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] 802 // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} 803 // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} 0 804 805 // CK19-USE: call void [[CALL19:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) 806 // CK19-NOUSE: call void [[CALL19:@.+]]() 807 #pragma omp target map(alloc:va[:]) 808 { 809#ifdef USE 810 va[50]++; 811#endif 812 } 813 814 // Region 20 815 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|2}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[SIZE20]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[MTYPE20]]{{.+}}, i8** null, i8** null) 816 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 817 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 818 819 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 820 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 821 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 822 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 823 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] 824 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] 825 826 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 827 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 828 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** 829 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** 830 // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] 831 // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] 832 // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 15 833 834 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 835 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 836 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 837 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 838 // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] 839 // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 840 // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} 15 841 842 // CK19-USE: call void [[CALL20:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) 843 // CK19-NOUSE: call void [[CALL20:@.+]]() 844 #pragma omp target map(to:va[15]) 845 { 846#ifdef USE 847 va[15]++; 848#endif 849 } 850 851 // Region 21 852 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|2}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[MTYPE21]]{{.+}}, i8** null, i8** null) 853 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 854 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 855 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 856 857 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 858 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 859 // CK19-USE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 860 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 861 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 862 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] 863 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] 864 // CK19-USE-DAG: store i{{.+}} {{8|4}}, i{{.+}}* [[S0]] 865 866 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 867 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 868 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 869 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** 870 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** 871 // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] 872 // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] 873 // CK19-USE-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], i{{.+}}* [[S1]] 874 // CK19-USE-DAG: [[CSVAL1]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} 875 // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} %{{.+}} 876 877 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 878 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 879 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 880 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 881 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 882 // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] 883 // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 884 // CK19-NOUSE-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] 885 // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} 886 // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} %{{.+}} 887 888 // CK19-USE: call void [[CALL21:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) 889 // CK19-NOUSE: call void [[CALL21:@.+]]() 890 #pragma omp target map(tofrom:va[ii:ii+23]) 891 { 892#ifdef USE 893 va[50]++; 894#endif 895 } 896 897 // Region 22 898 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|2}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[SIZE22]], {{.+}}getelementptr {{.+}}[{{1|2}} x i{{.+}}]* [[MTYPE22]]{{.+}}, i8** null, i8** null) 899 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 900 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 901 902 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 903 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 904 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 905 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 906 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] 907 // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] 908 909 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 910 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 911 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** 912 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** 913 // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] 914 // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] 915 // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} %{{.+}} 916 917 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 918 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 919 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 920 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 921 // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] 922 // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 923 // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} %{{.+}} 924 925 // CK19-USE: call void [[CALL22:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) 926 // CK19-NOUSE: call void [[CALL22:@.+]]() 927 #pragma omp target map(tofrom:va[ii]) 928 { 929#ifdef USE 930 va[15]++; 931#endif 932 } 933 934 // Always. 935 // Region 23 936 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE23]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE23]]{{.+}}, i8** null, i8** null) 937 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 938 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 939 940 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 941 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 942 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** 943 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 944 // CK19-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] 945 // CK19-DAG: store i32* [[VAR0]], i32** [[CP0]] 946 947 // CK19-USE: call void [[CALL23:@.+]](i32* {{[^,]+}}) 948 // CK19-NOUSE: call void [[CALL23:@.+]]() 949 #pragma omp target map(always, tofrom: a) 950 { 951#ifdef USE 952 a++; 953#endif 954 } 955 956 // Multidimensional arrays. 957 int marr[4][5][6]; 958 int ***mptr; 959 960 // Region 24 961 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE24]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE24]]{{.+}}, i8** null, i8** null) 962 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 963 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 964 965 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 966 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 967 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [4 x [5 x [6 x i32]]]** 968 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [4 x [5 x [6 x i32]]]** 969 // CK19-DAG: store [4 x [5 x [6 x i32]]]* [[VAR0:%.+]], [4 x [5 x [6 x i32]]]** [[CBP0]] 970 // CK19-DAG: store [4 x [5 x [6 x i32]]]* [[VAR0]], [4 x [5 x [6 x i32]]]** [[CP0]] 971 972 // CK19-USE: call void [[CALL24:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}}) 973 // CK19-NOUSE: call void [[CALL24:@.+]]() 974 #pragma omp target map(tofrom: marr) 975 { 976#ifdef USE 977 marr[1][2][3]++; 978#endif 979 } 980 981 // Region 25 982 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE25]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE25]]{{.+}}, i8** null, i8** null) 983 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 984 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 985 986 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 987 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 988 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [4 x [5 x [6 x i32]]]** 989 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 990 // CK19-DAG: store [4 x [5 x [6 x i32]]]* [[VAR0:%.+]], [4 x [5 x [6 x i32]]]** [[CBP0]] 991 // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 992 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[6 x i32]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 2 993 // CK19-DAG: [[SEC00]] = getelementptr {{.*}}[5 x [6 x i32]]* [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2 994 // CK19-DAG: [[SEC000]] = getelementptr {{.*}}[4 x [5 x [6 x i32]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1 995 996 // CK19-USE: call void [[CALL25:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}}) 997 // CK19-NOUSE: call void [[CALL25:@.+]]() 998 #pragma omp target map(tofrom: marr[1][2][2:4]) 999 { 1000#ifdef USE 1001 marr[1][2][3]++; 1002#endif 1003 } 1004 1005 // Region 26 1006 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE26]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE26]]{{.+}}, i8** null, i8** null) 1007 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1008 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1009 1010 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1011 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1012 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [4 x [5 x [6 x i32]]]** 1013 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 1014 // CK19-DAG: store [4 x [5 x [6 x i32]]]* [[VAR0:%.+]], [4 x [5 x [6 x i32]]]** [[CBP0]] 1015 // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 1016 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[6 x i32]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 0 1017 // CK19-DAG: [[SEC00]] = getelementptr {{.*}}[5 x [6 x i32]]* [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2 1018 // CK19-DAG: [[SEC000]] = getelementptr {{.*}}[4 x [5 x [6 x i32]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1 1019 1020 // CK19-USE: call void [[CALL26:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}}) 1021 // CK19-NOUSE: call void [[CALL26:@.+]]() 1022 #pragma omp target map(tofrom: marr[1][2][:]) 1023 { 1024#ifdef USE 1025 marr[1][2][3]++; 1026#endif 1027 } 1028 1029 // Region 27 1030 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE27]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE27]]{{.+}}, i8** null, i8** null) 1031 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1032 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1033 1034 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1035 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1036 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [4 x [5 x [6 x i32]]]** 1037 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 1038 // CK19-DAG: store [4 x [5 x [6 x i32]]]* [[VAR0:%.+]], [4 x [5 x [6 x i32]]]** [[CBP0]] 1039 // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] 1040 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[6 x i32]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 3 1041 // CK19-DAG: [[SEC00]] = getelementptr {{.*}}[5 x [6 x i32]]* [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2 1042 // CK19-DAG: [[SEC000]] = getelementptr {{.*}}[4 x [5 x [6 x i32]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1 1043 1044 // CK19-USE: call void [[CALL27:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}}) 1045 // CK19-NOUSE: call void [[CALL27:@.+]]() 1046 #pragma omp target map(tofrom: marr[1][2][3]) 1047 { 1048#ifdef USE 1049 marr[1][2][3]++; 1050#endif 1051 } 1052 1053 // Region 28 1054 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[SIZE28]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE28]]{{.+}}, i8** null, i8** null) 1055 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1056 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1057 1058 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1059 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1060 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32**** 1061 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32**** 1062 // CK19-DAG: store i32*** [[VAR0:%.+]], i32**** [[CBP0]] 1063 // CK19-DAG: store i32*** [[SEC0:%.+]], i32**** [[CP0]] 1064 // CK19-DAG: [[VAR0]] = load i32***, i32**** [[PTR:%[^,]+]], 1065 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32*** [[SEC00:[^,]+]], i{{.+}} 1 1066 // CK19-DAG: [[SEC00]] = load i32***, i32**** [[PTR]], 1067 1068 // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 1069 // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 1070 // CK19-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32**** 1071 // CK19-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32*** 1072 // CK19-DAG: store i32*** [[SEC0]], i32**** [[CBP1]] 1073 // CK19-DAG: store i32** [[SEC1:%.+]], i32*** [[CP1]] 1074 // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32** [[SEC11:[^,]+]], i{{.+}} 2 1075 // CK19-DAG: [[SEC11]] = load i32**, i32*** [[SEC111:%[^,]+]], 1076 // CK19-DAG: [[SEC111]] = getelementptr {{.*}}i32*** [[SEC1111:[^,]+]], i{{.+}} 1 1077 // CK19-DAG: [[SEC1111]] = load i32***, i32**** [[PTR]], 1078 1079 // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1080 // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 1081 // CK19-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to i32*** 1082 // CK19-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to i32** 1083 // CK19-DAG: store i32** [[SEC1]], i32*** [[CBP2]] 1084 // CK19-DAG: store i32* [[SEC2:%.+]], i32** [[CP2]] 1085 // CK19-DAG: [[SEC2]] = getelementptr {{.*}}i32* [[SEC22:[^,]+]], i{{.+}} 2 1086 // CK19-DAG: [[SEC22]] = load i32*, i32** [[SEC222:%[^,]+]], 1087 // CK19-DAG: [[SEC222]] = getelementptr {{.*}}i32** [[SEC2222:[^,]+]], i{{.+}} 2 1088 // CK19-DAG: [[SEC2222]] = load i32**, i32*** [[SEC22222:%[^,]+]], 1089 // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}i32*** [[SEC222222:[^,]+]], i{{.+}} 1 1090 // CK19-DAG: [[SEC222222]] = load i32***, i32**** [[PTR]], 1091 1092 // CK19-USE: call void [[CALL28:@.+]](i32*** {{[^,]+}}) 1093 // CK19-NOUSE: call void [[CALL28:@.+]]() 1094 #pragma omp target map(tofrom: mptr[1][2][2:4]) 1095 { 1096#ifdef USE 1097 mptr[1][2][3]++; 1098#endif 1099 } 1100 1101 // Region 29 1102 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[SIZE29]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE29]]{{.+}}, i8** null, i8** null) 1103 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1104 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1105 1106 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1107 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1108 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32**** 1109 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32**** 1110 // CK19-DAG: store i32*** [[VAR0:%.+]], i32**** [[CBP0]] 1111 // CK19-DAG: store i32*** [[SEC0:%.+]], i32**** [[CP0]] 1112 // CK19-DAG: [[VAR0]] = load i32***, i32**** [[PTR:%[^,]+]], 1113 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32*** [[SEC00:[^,]+]], i{{.+}} 1 1114 // CK19-DAG: [[SEC00]] = load i32***, i32**** [[PTR]], 1115 1116 // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 1117 // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 1118 // CK19-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32**** 1119 // CK19-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32*** 1120 // CK19-DAG: store i32*** [[SEC0]], i32**** [[CBP1]] 1121 // CK19-DAG: store i32** [[SEC1:%.+]], i32*** [[CP1]] 1122 // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32** [[SEC11:[^,]+]], i{{.+}} 2 1123 // CK19-DAG: [[SEC11]] = load i32**, i32*** [[SEC111:%[^,]+]], 1124 // CK19-DAG: [[SEC111]] = getelementptr {{.*}}i32*** [[SEC1111:[^,]+]], i{{.+}} 1 1125 // CK19-DAG: [[SEC1111]] = load i32***, i32**** [[PTR]], 1126 1127 // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1128 // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 1129 // CK19-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to i32*** 1130 // CK19-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to i32** 1131 // CK19-DAG: store i32** [[SEC1]], i32*** [[CBP2]] 1132 // CK19-DAG: store i32* [[SEC2:%.+]], i32** [[CP2]] 1133 // CK19-DAG: [[SEC2]] = getelementptr {{.*}}i32* [[SEC22:[^,]+]], i{{.+}} 3 1134 // CK19-DAG: [[SEC22]] = load i32*, i32** [[SEC222:%[^,]+]], 1135 // CK19-DAG: [[SEC222]] = getelementptr {{.*}}i32** [[SEC2222:[^,]+]], i{{.+}} 2 1136 // CK19-DAG: [[SEC2222]] = load i32**, i32*** [[SEC22222:%[^,]+]], 1137 // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}i32*** [[SEC222222:[^,]+]], i{{.+}} 1 1138 // CK19-DAG: [[SEC222222]] = load i32***, i32**** [[PTR]], 1139 1140 // CK19-USE: call void [[CALL29:@.+]](i32*** {{[^,]+}}) 1141 // CK19-NOUSE: call void [[CALL29:@.+]]() 1142 #pragma omp target map(tofrom: mptr[1][2][3]) 1143 { 1144#ifdef USE 1145 mptr[1][2][3]++; 1146#endif 1147 } 1148 1149 // Multidimensional VLA. 1150 double mva[23][ii][ii+5]; 1151 1152 // Region 30 1153 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|4}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[{{1|4}} x i{{.+}}]* [[MTYPE30]]{{.+}}, i8** null, i8** null) 1154 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1155 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1156 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 1157 // 1158 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1159 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1160 // CK19-USE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1161 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 1162 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 1163 // CK19-USE-DAG: store i[[Z]] 23, i[[Z]]* [[CBP0]] 1164 // CK19-USE-DAG: store i[[Z]] 23, i[[Z]]* [[CP0]] 1165 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S0]] 1166 // 1167 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 1168 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 1169 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 1170 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* 1171 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* 1172 // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] 1173 // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] 1174 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S1]] 1175 // CK19-64-USE-DAG: [[VAR1]] = zext i32 %{{[^,]+}} to i64 1176 // CK19-64-USE-DAG: [[VAR11]] = zext i32 %{{[^,]+}} to i64 1177 // 1178 // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1179 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 1180 // CK19-USE-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 1181 // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to i[[Z]]* 1182 // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to i[[Z]]* 1183 // CK19-USE-DAG: store i[[Z]] [[VAR2:%.+]], i[[Z]]* [[CBP2]] 1184 // CK19-USE-DAG: store i[[Z]] [[VAR22:%.+]], i[[Z]]* [[CP2]] 1185 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S2]] 1186 // CK19-64-USE-DAG: [[VAR2]] = zext i32 %{{[^,]+}} to i64 1187 // CK19-64-USE-DAG: [[VAR22]] = zext i32 %{{[^,]+}} to i64 1188 // 1189 // CK19-USE-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 3 1190 // CK19-USE-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3 1191 // CK19-USE-DAG: [[S3:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 3 1192 // CK19-USE-DAG: [[CBP3:%.+]] = bitcast i8** [[BP3]] to double** 1193 // CK19-USE-DAG: [[CP3:%.+]] = bitcast i8** [[P3]] to double** 1194 // CK19-USE-DAG: store double* [[VAR3:%.+]], double** [[CBP3]] 1195 // CK19-USE-DAG: store double* [[VAR3]], double** [[CP3]] 1196 // CK19-USE-DAG: store i64 [[CSVAL3:%[^,]+]], i64* [[S3]] 1197 // CK19-USE-DAG: [[CSVAL3]] = {{mul nuw i64 %[^,]+, 8|sext i32 .+ to i64}} 1198 1199 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1200 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1201 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1202 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to double** 1203 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to double** 1204 // CK19-NOUSE-DAG: store double* [[VAR0:%.+]], double** [[CBP0]] 1205 // CK19-NOUSE-DAG: store double* [[VAR0]], double** [[CP0]] 1206 // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] 1207 // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 8|sext i32 .+ to i64}} 1208 1209 // CK19-USE: call void [[CALL30:@.+]](i[[Z]] 23, i[[Z]] %{{[^,]+}}, i[[Z]] %{{[^,]+}}, double* %{{[^,]+}}) 1210 // CK19-NOUSE: call void [[CALL30:@.+]]() 1211 #pragma omp target map(tofrom: mva) 1212 { 1213#ifdef USE 1214 mva[1][2][3]++; 1215#endif 1216 } 1217 1218 // Region 31 1219 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|4}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[{{1|4}} x i{{.+}}]* [[SIZE31]], {{.+}}getelementptr {{.+}}[{{1|4}} x i{{.+}}]* [[MTYPE31]]{{.+}}, i8** null, i8** null) 1220 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1221 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1222 // 1223 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1224 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1225 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 1226 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 1227 // CK19-USE-DAG: store i[[Z]] 23, i[[Z]]* [[CBP0]] 1228 // CK19-USE-DAG: store i[[Z]] 23, i[[Z]]* [[CP0]] 1229 // 1230 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 1231 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 1232 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* 1233 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* 1234 // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] 1235 // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] 1236 // 1237 // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1238 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 1239 // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to i[[Z]]* 1240 // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to i[[Z]]* 1241 // CK19-USE-DAG: store i[[Z]] [[VAR2:%.+]], i[[Z]]* [[CBP2]] 1242 // CK19-USE-DAG: store i[[Z]] [[VAR22:%.+]], i[[Z]]* [[CP2]] 1243 // 1244 // CK19-USE-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 3 1245 // CK19-USE-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3 1246 // CK19-USE-DAG: [[CBP3:%.+]] = bitcast i8** [[BP3]] to double** 1247 // CK19-USE-DAG: [[CP3:%.+]] = bitcast i8** [[P3]] to double** 1248 // CK19-USE-DAG: store double* [[VAR3:%.+]], double** [[CBP3]] 1249 // CK19-USE-DAG: store double* [[SEC3:%.+]], double** [[CP3]] 1250 // CK19-USE-DAG: [[SEC3]] = getelementptr {{.*}}double* [[SEC33:%.+]], i[[Z]] 0 1251 // CK19-USE-DAG: [[SEC33]] = getelementptr {{.*}}double* [[SEC333:%.+]], i[[Z]] [[IDX3:%.+]] 1252 // CK19-USE-DAG: [[IDX3]] = mul nsw i[[Z]] %{{[^,]+}}, %{{[^,]+}} 1253 // CK19-USE-DAG: [[SEC333]] = getelementptr {{.*}}double* [[VAR3]], i[[Z]] [[IDX33:%.+]] 1254 // CK19-USE-DAG: [[IDX33]] = mul nsw i[[Z]] 1, %{{[^,]+}} 1255 1256 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1257 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1258 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to double** 1259 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to double** 1260 // CK19-NOUSE-DAG: store double* [[VAR0:%.+]], double** [[CBP0]] 1261 // CK19-NOUSE-DAG: store double* [[SEC0:%.+]], double** [[CP0]] 1262 // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}double* [[SEC00:%.+]], i[[Z:64|32]] 0 1263 // CK19-NOUSE-DAG: [[SEC00]] = getelementptr {{.*}}double* [[SEC000:%.+]], i[[Z]] [[IDX0:%.+]] 1264 // CK19-NOUSE-DAG: [[IDX0]] = mul nsw i[[Z]] %{{[^,]+}}, %{{[^,]+}} 1265 // CK19-NOUSE-DAG: [[SEC000]] = getelementptr {{.*}}double* [[VAR0]], i[[Z]] [[IDX00:%.+]] 1266 // CK19-NOUSE-DAG: [[IDX00]] = mul nsw i[[Z]] 1, %{{[^,]+}} 1267 1268 // CK19-USE: call void [[CALL31:@.+]](i[[Z]] 23, i[[Z]] %{{[^,]+}}, i[[Z]] %{{[^,]+}}, double* %{{[^,]+}}) 1269 // CK19-NOUSE: call void [[CALL31:@.+]]() 1270 #pragma omp target map(tofrom: mva[1][ii-2][:5]) 1271 { 1272#ifdef USE 1273 mva[1][2][3]++; 1274#endif 1275 } 1276 1277 // Multidimensional array sections. 1278 double marras[11][12][13]; 1279 double mvlaas[11][ii][13]; 1280 double ***mptras; 1281 1282 // Region 32 1283 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE32]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE32]]{{.+}}, i8** null, i8** null) 1284 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1285 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1286 1287 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1288 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1289 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** 1290 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [11 x [12 x [13 x double]]]** 1291 // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] 1292 // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0]], [11 x [12 x [13 x double]]]** [[CP0]] 1293 1294 // CK19-USE: call void [[CALL32:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) 1295 // CK19-NOUSE: call void [[CALL32:@.+]]() 1296 #pragma omp target map(marras) 1297 { 1298#ifdef USE 1299 marras[1][2][3]++; 1300#endif 1301 } 1302 1303 // Region 33 1304 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE33]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE33]]{{.+}}, i8** null, i8** null) 1305 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1306 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1307 1308 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1309 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1310 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** 1311 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [12 x [13 x double]]** 1312 // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] 1313 // CK19-DAG: store [12 x [13 x double]]* [[SEC0:%.+]], [12 x [13 x double]]** [[CP0]] 1314 // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 0 1315 1316 // CK19-USE: call void [[CALL33:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) 1317 // CK19-NOUSE: call void [[CALL33:@.+]]() 1318 #pragma omp target map(marras[:]) 1319 { 1320#ifdef USE 1321 marras[1][2][3]++; 1322#endif 1323 } 1324 1325 // Region 34 1326 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE34]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE34]]{{.+}}, i8** null, i8** null) 1327 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1328 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1329 1330 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1331 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1332 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** 1333 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [12 x [13 x double]]** 1334 // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] 1335 // CK19-DAG: store [12 x [13 x double]]* [[SEC0:%.+]], [12 x [13 x double]]** [[CP0]] 1336 // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 0 1337 1338 // CK19-USE: call void [[CALL34:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) 1339 // CK19-NOUSE: call void [[CALL34:@.+]]() 1340 #pragma omp target map(marras[:][:][:]) 1341 { 1342#ifdef USE 1343 marras[1][2][3]++; 1344#endif 1345 } 1346 1347 // Region 35 1348 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE35]]{{.+}}, i8** null, i8** null) 1349 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1350 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1351 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 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: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1356 1357 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** 1358 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** 1359 // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] 1360 // CK19-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] 1361 // CK19-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] 1362 // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[12 x [13 x double]]* [[SEC00:%[^,]+]], i[[Z]] 0, i[[Z]] 0 1363 // CK19-DAG: [[SEC00]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 1 1364 // CK19-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} 1365 1366 // CK19-USE: call void [[CALL35:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) 1367 // CK19-NOUSE: call void [[CALL35:@.+]]() 1368 #pragma omp target map(marras[1][:ii][:]) 1369 { 1370#ifdef USE 1371 marras[1][2][3]++; 1372#endif 1373 } 1374 1375 // Region 36 1376 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE36]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE36]]{{.+}}, i8** null, i8** null) 1377 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1378 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1379 1380 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1381 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1382 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** 1383 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** 1384 // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] 1385 // CK19-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] 1386 // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[SEC00:%[^,]+]], i{{.+}} 0 1387 // CK19-DAG: [[SEC00]] = getelementptr {{.+}}[12 x [13 x double]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 0 1388 // CK19-DAG: [[SEC000]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 0 1389 1390 // CK19-USE: call void [[CALL36:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) 1391 // CK19-NOUSE: call void [[CALL36:@.+]]() 1392 #pragma omp target map(marras[:1][:2][:13]) 1393 { 1394#ifdef USE 1395 marras[1][2][3]++; 1396#endif 1397 } 1398 1399 // Region 37 1400 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|3}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[{{1|3}} x i{{.+}}]* [[MTYPE37]]{{.+}}, i8** null, i8** null) 1401 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1402 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1403 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 1404 // 1405 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1406 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1407 // CK19-USE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1408 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 1409 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 1410 // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CBP0]] 1411 // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CP0]] 1412 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S0]] 1413 // 1414 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 1415 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 1416 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 1417 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* 1418 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* 1419 // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] 1420 // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] 1421 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S1]] 1422 // 1423 // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1424 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 1425 // CK19-USE-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 1426 // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to [13 x double]** 1427 // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to [13 x double]** 1428 // CK19-USE-DAG: store [13 x double]* [[VAR2:%.+]], [13 x double]** [[CBP2]] 1429 // CK19-USE-DAG: store [13 x double]* [[VAR2]], [13 x double]** [[CP2]] 1430 // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], i64* [[S2]] 1431 // CK19-USE-DAG: [[CSVAL2]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} 1432 1433 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1434 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1435 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1436 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [13 x double]** 1437 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** 1438 // CK19-NOUSE-DAG: store [13 x double]* [[VAR0:%.+]], [13 x double]** [[CBP0]] 1439 // CK19-NOUSE-DAG: store [13 x double]* [[VAR0]], [13 x double]** [[CP0]] 1440 // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] 1441 // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} 1442 1443 // CK19-USE: call void [[CALL37:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}}) 1444 // CK19-NOUSE: call void [[CALL37:@.+]]() 1445 #pragma omp target map(mvlaas) 1446 { 1447#ifdef USE 1448 mvlaas[1][2][3]++; 1449#endif 1450 } 1451 1452 // Region 38 1453 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|3}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[{{1|3}} x i{{.+}}]* [[MTYPE38]]{{.+}}, i8** null, i8** null) 1454 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1455 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1456 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 1457 // 1458 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1459 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1460 // CK19-USE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1461 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 1462 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 1463 // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CBP0]] 1464 // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CP0]] 1465 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S0]] 1466 // 1467 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 1468 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 1469 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 1470 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* 1471 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* 1472 // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] 1473 // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] 1474 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S1]] 1475 // 1476 // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1477 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 1478 // CK19-USE-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 1479 // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to [13 x double]** 1480 // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to [13 x double]** 1481 // CK19-USE-DAG: store [13 x double]* [[VAR2:%.+]], [13 x double]** [[CBP2]] 1482 // CK19-USE-DAG: store [13 x double]* [[SEC2:%.+]], [13 x double]** [[CP2]] 1483 // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], i64* [[S2]] 1484 // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC22:%[^,]+]] 1485 // CK19-USE-DAG: [[SEC22]] = mul nsw i[[Z]] 0, %{{[^,]+}} 1486 // CK19-USE-DAG: [[CSVAL2]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} 1487 1488 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1489 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1490 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1491 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [13 x double]** 1492 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** 1493 // CK19-NOUSE-DAG: store [13 x double]* [[VAR0:%.+]], [13 x double]** [[CBP0]] 1494 // CK19-NOUSE-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] 1495 // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] 1496 // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[VAR0]], i[[Z]] [[SEC00:%[^,]+]] 1497 // CK19-NOUSE-DAG: [[SEC00]] = mul nsw i[[Z]] 0, %{{[^,]+}} 1498 // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} 1499 1500 // CK19-USE: call void [[CALL38:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}}) 1501 // CK19-NOUSE: call void [[CALL38:@.+]]() 1502 #pragma omp target map(mvlaas[:]) 1503 { 1504#ifdef USE 1505 mvlaas[1][2][3]++; 1506#endif 1507 } 1508 1509 // Region 39 1510 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|3}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[{{1|3}} x i{{.+}}]* [[MTYPE39]]{{.+}}, i8** null, i8** null) 1511 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1512 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1513 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 1514 // 1515 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1516 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1517 // CK19-USE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1518 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 1519 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 1520 // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CBP0]] 1521 // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CP0]] 1522 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S0]] 1523 // 1524 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 1525 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 1526 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 1527 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* 1528 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* 1529 // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] 1530 // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] 1531 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S1]] 1532 // 1533 // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1534 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 1535 // CK19-USE-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 1536 // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to [13 x double]** 1537 // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to [13 x double]** 1538 // CK19-USE-DAG: store [13 x double]* [[VAR2:%.+]], [13 x double]** [[CBP2]] 1539 // CK19-USE-DAG: store [13 x double]* [[SEC2:%.+]], [13 x double]** [[CP2]] 1540 // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], i64* [[S2]] 1541 // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC22:%[^,]+]] 1542 // CK19-USE-DAG: [[SEC22]] = mul nsw i[[Z]] 0, %{{[^,]+}} 1543 // CK19-USE-DAG: [[CSVAL2]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} 1544 1545 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1546 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1547 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1548 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [13 x double]** 1549 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** 1550 // CK19-NOUSE-DAG: store [13 x double]* [[VAR0:%.+]], [13 x double]** [[CBP0]] 1551 // CK19-NOUSE-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] 1552 // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] 1553 // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[VAR0]], i[[Z]] [[SEC00:%[^,]+]] 1554 // CK19-NOUSE-DAG: [[SEC00]] = mul nsw i[[Z]] 0, %{{[^,]+}} 1555 // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} 1556 1557 // CK19-USE: call void [[CALL39:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}}) 1558 // CK19-NOUSE: call void [[CALL39:@.+]]() 1559 #pragma omp target map(mvlaas[:][:][:]) 1560 { 1561#ifdef USE 1562 mvlaas[1][2][3]++; 1563#endif 1564 } 1565 1566 // Region 40 1567 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|3}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[{{1|3}} x i{{.+}}]* [[MTYPE40]]{{.+}}, i8** null, i8** null) 1568 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1569 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1570 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 1571 // 1572 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1573 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1574 // CK19-USE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1575 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 1576 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 1577 // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CBP0]] 1578 // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CP0]] 1579 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S0]] 1580 // 1581 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 1582 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 1583 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 1584 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* 1585 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* 1586 // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] 1587 // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] 1588 // CK19-USE-DAG: store i64 {{8|4}}, i64* [[S1]] 1589 // 1590 // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1591 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 1592 // CK19-USE-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 1593 // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to [13 x double]** 1594 // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to [13 x double]** 1595 // CK19-USE-DAG: store [13 x double]* [[VAR2:%.+]], [13 x double]** [[CBP2]] 1596 // CK19-USE-DAG: store [13 x double]* [[SEC2:%.+]], [13 x double]** [[CP2]] 1597 // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], i64* [[S2]] 1598 // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[SEC22:%[^,]+]], i[[Z]] 0 1599 // CK19-USE-DAG: [[SEC22]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC222:%[^,]+]] 1600 // CK19-USE-DAG: [[SEC222]] = mul nsw i[[Z]] 1, %{{[^,]+}} 1601 1602 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1603 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1604 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1605 // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [13 x double]** 1606 // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** 1607 // CK19-NOUSE-DAG: store [13 x double]* [[VAR0:%.+]], [13 x double]** [[CBP0]] 1608 // CK19-NOUSE-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] 1609 // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] 1610 // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[SEC00:%[^,]+]], i[[Z]] 0 1611 // CK19-NOUSE-DAG: [[SEC00]] = getelementptr {{.+}}[13 x double]* [[VAR0]], i[[Z]] [[SEC000:%[^,]+]] 1612 // CK19-NOUSE-DAG: [[SEC000]] = mul nsw i[[Z]] 1, %{{[^,]+}} 1613 1614 // CK19-USE: call void [[CALL40:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}}) 1615 // CK19-NOUSE: call void [[CALL40:@.+]]() 1616 #pragma omp target map(mvlaas[1][:ii][:]) 1617 { 1618#ifdef USE 1619 mvlaas[1][2][3]++; 1620#endif 1621 } 1622 1623 // Region 41 1624 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 {{1|3}}, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[{{1|3}} x i{{.+}}]* [[SIZE41]], {{.+}}getelementptr {{.+}}[{{1|3}} x i{{.+}}]* [[MTYPE41]]{{.+}}, i8** null, i8** null) 1625 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1626 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1627 // 1628 // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1629 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1630 // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* 1631 // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* 1632 // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CBP0]] 1633 // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CP0]] 1634 // 1635 // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 1636 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 1637 // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* 1638 // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* 1639 // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] 1640 // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] 1641 // 1642 // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1643 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 1644 // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to [13 x double]** 1645 // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to [13 x double]** 1646 // CK19-USE-DAG: store [13 x double]* [[VAR2:%.+]], [13 x double]** [[CBP2]] 1647 // CK19-USE-DAG: store [13 x double]* [[SEC2:%.+]], [13 x double]** [[CP2]] 1648 // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[SEC22:%[^,]+]], i[[Z]] 0 1649 // CK19-USE-DAG: [[SEC22]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC222:%[^,]+]] 1650 // CK19-USE-DAG: [[SEC222]] = mul nsw i[[Z]] 0, %{{[^,]+}} 1651 // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1652 1653 // CK19-NO-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1654 // CK19-NO-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [13 x double]** 1655 // CK19-NO-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** 1656 // CK19-NO-USE-DAG: store [13 x double]* [[VAR0:%.+]], [13 x double]** [[CBP0]] 1657 // CK19-NO-USE-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] 1658 // CK19-NO-USE-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[SEC00:%[^,]+]], i[[Z]] 0 1659 // CK19-NO-USE-DAG: [[SEC00]] = getelementptr {{.+}}[13 x double]* [[VAR0]], i[[Z]] [[SEC000:%[^,]+]] 1660 // CK19-NO-USE-DAG: [[SEC000]] = mul nsw i[[Z]] 0, %{{[^,]+}} 1661 1662 // CK19-USE: call void [[CALL41:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}}) 1663 // CK19-NOUSE: call void [[CALL41:@.+]]() 1664 #pragma omp target map(mvlaas[:1][:2][:13]) 1665 { 1666#ifdef USE 1667 mvlaas[1][2][3]++; 1668#endif 1669 } 1670 1671 // Region 42 1672 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 3, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[SIZE42]], {{.+}}getelementptr {{.+}}[3 x i{{.+}}]* [[MTYPE42]]{{.+}}, i8** null, i8** null) 1673 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1674 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1675 1676 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1677 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1678 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to double**** 1679 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to double**** 1680 // CK19-DAG: store double*** [[VAR0:%.+]], double**** [[CBP0]] 1681 // CK19-DAG: store double*** [[SEC0:%.+]], double**** [[CP0]] 1682 // CK19-DAG: [[VAR0]] = load double***, double**** [[PTR:%[^,]+]], 1683 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}double*** [[SEC00:[^,]+]], i{{.+}} 0 1684 // CK19-DAG: [[SEC00]] = load double***, double**** [[PTR]], 1685 1686 // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 1687 // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 1688 // CK19-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to double**** 1689 // CK19-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to double*** 1690 // CK19-DAG: store double*** [[SEC0]], double**** [[CBP1]] 1691 // CK19-DAG: store double** [[SEC1:%.+]], double*** [[CP1]] 1692 // CK19-DAG: [[SEC1]] = getelementptr {{.*}}double** [[SEC11:[^,]+]], i{{.+}} 2 1693 // CK19-DAG: [[SEC11]] = load double**, double*** [[SEC111:%[^,]+]], 1694 // CK19-DAG: [[SEC111]] = getelementptr {{.*}}double*** [[SEC1111:[^,]+]], i{{.+}} 0 1695 // CK19-DAG: [[SEC1111]] = load double***, double**** [[PTR]], 1696 1697 // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 1698 // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 1699 // CK19-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to double*** 1700 // CK19-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to double** 1701 // CK19-DAG: store double** [[SEC1]], double*** [[CBP2]] 1702 // CK19-DAG: store double* [[SEC2:%.+]], double** [[CP2]] 1703 // CK19-DAG: [[SEC2]] = getelementptr {{.*}}double* [[SEC22:[^,]+]], i{{.+}} 0 1704 // CK19-DAG: [[SEC22]] = load double*, double** [[SEC222:%[^,]+]], 1705 // CK19-DAG: [[SEC222]] = getelementptr {{.*}}double** [[SEC2222:[^,]+]], i{{.+}} 2 1706 // CK19-DAG: [[SEC2222]] = load double**, double*** [[SEC22222:%[^,]+]], 1707 // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}double*** [[SEC222222:[^,]+]], i{{.+}} 0 1708 // CK19-DAG: [[SEC222222]] = load double***, double**** [[PTR]], 1709 1710 // CK19-USE: call void [[CALL42:@.+]](double*** {{[^,]+}}) 1711 // CK19-NOUSE: call void [[CALL42:@.+]]() 1712 #pragma omp target map(mptras[:1][2][:13]) 1713 { 1714#ifdef USE 1715 mptras[1][2][3]++; 1716#endif 1717 } 1718 1719 // Region 43 - the memory is not contiguous for this map - will map the whole last dimension. 1720 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], i64* [[GEPS:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE43]]{{.+}}, i8** null, i8** null) 1721 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1722 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1723 // CK19-DAG: [[GEPS]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] 1724 // 1725 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1726 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1727 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 1728 1729 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** 1730 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** 1731 // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] 1732 // CK19-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] 1733 // CK19-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] 1734 // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[12 x [13 x double]]* [[SEC00:%[^,]+]], i[[Z]] 0, i[[Z]] 0 1735 // CK19-DAG: [[SEC00]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 1 1736 // CK19-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} 1737 1738 // CK19-USE: call void [[CALL43:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) 1739 // CK19-NOUSE: call void [[CALL43:@.+]]() 1740 #pragma omp target map(marras[1][:ii][1:]) 1741 { 1742#ifdef USE 1743 marras[1][2][3]++; 1744#endif 1745 } 1746 1747 // Region 44 1748 // CK19-DAG: call i32 @__tgt_target_mapper(%struct.ident_t* @{{.+}}, i64 {{[^,]+}}, i8* {{[^,]+}}, i32 1, i8** [[GEPBP:%.+]], i8** [[GEPP:%.+]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[SIZE44]], {{.+}}getelementptr {{.+}}[1 x i{{.+}}]* [[MTYPE44]]{{.+}}, i8** null, i8** null) 1749 // CK19-DAG: [[GEPBP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] 1750 // CK19-DAG: [[GEPP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] 1751 1752 // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 1753 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 1754 // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** 1755 // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** 1756 // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] 1757 // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] 1758 // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 20 1759 1760 // CK19-USE: call void [[CALL44:@.+]]([100 x i32]* {{[^,]+}}) 1761 // CK19-NOUSE: call void [[CALL44:@.+]]() 1762 #pragma omp target map(from:arra[20:]) 1763 { 1764#ifdef USE 1765 arra[50]++; 1766#endif 1767 } 1768 1769} 1770 1771// CK19: define {{.+}}[[CALL00]] 1772// CK19: define {{.+}}[[CALL01]] 1773// CK19: define {{.+}}[[CALL02]] 1774// CK19: define {{.+}}[[CALL03]] 1775// CK19: define {{.+}}[[CALL04]] 1776// CK19: define {{.+}}[[CALL05]] 1777// CK19: define {{.+}}[[CALL06]] 1778// CK19: define {{.+}}[[CALL07]] 1779// CK19: define {{.+}}[[CALL08]] 1780// CK19: define {{.+}}[[CALL09]] 1781// CK19: define {{.+}}[[CALL10]] 1782// CK19: define {{.+}}[[CALL11]] 1783// CK19: define {{.+}}[[CALL12]] 1784// CK19: define {{.+}}[[CALL13]] 1785// CK19: define {{.+}}[[CALL14]] 1786// CK19: define {{.+}}[[CALL15]] 1787// CK19: define {{.+}}[[CALL16]] 1788// CK19: define {{.+}}[[CALL17]] 1789// CK19: define {{.+}}[[CALL18]] 1790// CK19: define {{.+}}[[CALL19]] 1791// CK19: define {{.+}}[[CALL20]] 1792// CK19: define {{.+}}[[CALL21]] 1793// CK19: define {{.+}}[[CALL22]] 1794// CK19: define {{.+}}[[CALL23]] 1795// CK19: define {{.+}}[[CALL24]] 1796// CK19: define {{.+}}[[CALL25]] 1797// CK19: define {{.+}}[[CALL26]] 1798// CK19: define {{.+}}[[CALL27]] 1799// CK19: define {{.+}}[[CALL28]] 1800// CK19: define {{.+}}[[CALL29]] 1801// CK19: define {{.+}}[[CALL30]] 1802// CK19: define {{.+}}[[CALL31]] 1803// CK19: define {{.+}}[[CALL32]] 1804// CK19: define {{.+}}[[CALL33]] 1805// CK19: define {{.+}}[[CALL34]] 1806// CK19: define {{.+}}[[CALL35]] 1807// CK19: define {{.+}}[[CALL36]] 1808// CK19: define {{.+}}[[CALL37]] 1809// CK19: define {{.+}}[[CALL38]] 1810// CK19: define {{.+}}[[CALL39]] 1811// CK19: define {{.+}}[[CALL40]] 1812// CK19: define {{.+}}[[CALL41]] 1813// CK19: define {{.+}}[[CALL42]] 1814// CK19: define {{.+}}[[CALL43]] 1815// CK19: define {{.+}}[[CALL44]] 1816 1817#endif // CK19 1818#endif // HEADER_INC 1819