diff --git a/clang/test/OpenMP/metadirective_device_kind_codegen.c b/clang/test/OpenMP/metadirective_device_kind_codegen.c --- a/clang/test/OpenMP/metadirective_device_kind_codegen.c +++ b/clang/test/OpenMP/metadirective_device_kind_codegen.c @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c -triple x86_64-unknown-linux -emit-llvm %s -o - | FileCheck %s -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c -triple aarch64-unknown-linux -emit-llvm %s -o - | FileCheck %s -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c -triple ppc64le-unknown-linux -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp -x c -triple x86_64-unknown-linux -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp -x c -triple aarch64-unknown-linux -emit-llvm %s -o - | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp -x c -triple ppc64le-unknown-linux -emit-llvm %s -o - | FileCheck %s // expected-no-diagnostics #ifndef HEADER #define HEADER @@ -36,14 +36,14 @@ } // CHECK-LABEL: define {{.+}} void @foo() -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_1:@.+]] to void +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_1:@.+]]) // CHECK-NEXT: @__kmpc_push_num_threads -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_2:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_3:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_4:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_5:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_6:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_7:@.+]] to void +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_2:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_3:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_4:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_5:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_6:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_7:@.+]]) // CHECK: ret void // CHECK: define internal void [[OUTLINED_1]]( diff --git a/clang/test/OpenMP/metadirective_device_kind_codegen.cpp b/clang/test/OpenMP/metadirective_device_kind_codegen.cpp --- a/clang/test/OpenMP/metadirective_device_kind_codegen.cpp +++ b/clang/test/OpenMP/metadirective_device_kind_codegen.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c++ -triple x86_64-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c++ -triple aarch64-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c++ -triple ppc64le-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple aarch64-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple ppc64le-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s // expected-no-diagnostics #ifndef HEADER @@ -37,14 +37,14 @@ } // CHECK-LABEL: define {{.+}} void @_Z3foov() -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_1:@.+]] to void +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_1:@.+]]) // CHECK-NEXT: @__kmpc_push_num_threads -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_2:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_3:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_4:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_5:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_6:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_7:@.+]] to void +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_2:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_3:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_4:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_5:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_6:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_7:@.+]]) // CHECK: ret void // CHECK: define internal void [[OUTLINED_1]]( diff --git a/clang/test/OpenMP/metadirective_implementation_codegen.cpp b/clang/test/OpenMP/metadirective_implementation_codegen.cpp --- a/clang/test/OpenMP/metadirective_implementation_codegen.cpp +++ b/clang/test/OpenMP/metadirective_implementation_codegen.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c++ -triple x86_64-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c++ -triple aarch64-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c++ -triple ppc64le-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple aarch64-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s +// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple ppc64le-unknown-linux -emit-llvm %s -fexceptions -fcxx-exceptions -o - -fsanitize-address-use-after-scope | FileCheck %s // expected-no-diagnostics #ifndef HEADER @@ -38,12 +38,12 @@ } // CHECK-LABEL: void @_Z3foov() -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_2:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_3:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_4:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_5:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_6:@.+]] to void -// CHECK: @__kmpc_fork_call(%struct.ident_t* {{.+}}, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* [[OUTLINED_7:@.+]] to void +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_2:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_3:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_4:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_5:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_6:@.+]]) +// CHECK: @__kmpc_fork_call(ptr {{.+}}, i32 0, ptr [[OUTLINED_7:@.+]]) // CHECK: ret void // CHECK: define internal void [[OUTLINED_2]]( diff --git a/clang/test/OpenMP/openmp_offload_codegen.cpp b/clang/test/OpenMP/openmp_offload_codegen.cpp --- a/clang/test/OpenMP/openmp_offload_codegen.cpp +++ b/clang/test/OpenMP/openmp_offload_codegen.cpp @@ -1,16 +1,16 @@ // Test device for mapping codegen. ///==========================================================================/// -// RUN: %clang_cc1 -no-opaque-pointers -DCK1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -S -emit-llvm %s -o - 2>&1 | FileCheck -check-prefix=CK1 %s +// RUN: %clang_cc1 -DCK1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -S -emit-llvm %s -o - 2>&1 | FileCheck -check-prefix=CK1 %s -// RUN: %clang_cc1 -no-opaque-pointers -DCK1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -S -emit-llvm %s -o - 2>&1 | FileCheck --check-prefix SIMD-ONLY0 %s +// RUN: %clang_cc1 -DCK1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -S -emit-llvm %s -o - 2>&1 | FileCheck --check-prefix SIMD-ONLY0 %s // SIMD-ONLY0-NOT: {{__kmpc|__tgt}} -// RUN: %clang_cc1 -no-opaque-pointers -DCK1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm-bc %s -o %t-ppc-host.bc -// RUN: %clang_cc1 -no-opaque-pointers -DCK1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o - | FileCheck %s --check-prefix CK1-DEVICE +// RUN: %clang_cc1 -DCK1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm-bc %s -o %t-ppc-host.bc +// RUN: %clang_cc1 -DCK1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o - | FileCheck %s --check-prefix CK1-DEVICE -// RUN: %clang_cc1 -no-opaque-pointers -DCK1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm-bc %s -o %t-ppc-host.bc -// RUN: %clang_cc1 -no-opaque-pointers -DCK1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s +// RUN: %clang_cc1 -DCK1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm-bc %s -o %t-ppc-host.bc +// RUN: %clang_cc1 -DCK1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=nvptx64-nvidia-cuda -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s // SIMD-ONLY1-NOT: {{__kmpc|__tgt}} // expected-no-diagnostics @@ -25,22 +25,20 @@ } } -// CK1-DEVICE: {{.*}}void @__omp_offloading_{{.*}}(i32* noundef nonnull align 4 dereferenceable(4){{.*}} +// CK1-DEVICE: {{.*}}void @__omp_offloading_{{.*}}(ptr noundef nonnull align 4 dereferenceable(4){{.*}} // CK1: {{.*}}void {{.*}}target_maps_parallel_integer{{.*}} { // CK1: [[GEPOBP:%.+]] = getelementptr inbounds {{.*}} -// CK1: [[GEPOBPBIT:%.+]] = bitcast i8** [[GEPOBP]] -// CK1: store i32* %ParamToKernel, i32** [[GEPOBPBIT]] +// CK1: store ptr %ParamToKernel, ptr [[GEPOBP]] // CK1: [[GEPOP:%.+]] = getelementptr inbounds {{.*}} -// CK1: [[GEPOPBIT:%.+]] = bitcast i8** [[GEPOP]] -// CK1: store i32* %ParamToKernel, i32** [[GEPOPBIT]] +// CK1: store ptr %ParamToKernel, ptr [[GEPOP]] // CK1: [[GEPOBPARG:%.+]] = getelementptr inbounds {{.*}} %.offload_baseptrs, i32 0, i32 0 // CK1: [[GEPOPARG:%.+]] = getelementptr inbounds {{.*}} %.offload_ptrs, i32 0, i32 0 -// CK1: [[ARGBP:%.+]] = getelementptr inbounds %struct.__tgt_kernel_arguments, %struct.__tgt_kernel_arguments* %kernel_args, i32 0, i32 2 -// CK1: store i8** [[GEPOBPARG]], i8*** [[ARGBP]], align 8 -// CK1: [[ARGP:%.+]] = getelementptr inbounds %struct.__tgt_kernel_arguments, %struct.__tgt_kernel_arguments* %kernel_args, i32 0, i32 3 -// CK1: store i8** [[GEPOPARG]], i8*** [[ARGP]], align 8 +// CK1: [[ARGBP:%.+]] = getelementptr inbounds %struct.__tgt_kernel_arguments, ptr %kernel_args, i32 0, i32 2 +// CK1: store ptr [[GEPOBPARG]], ptr [[ARGBP]], align 8 +// CK1: [[ARGP:%.+]] = getelementptr inbounds %struct.__tgt_kernel_arguments, ptr %kernel_args, i32 0, i32 3 +// CK1: store ptr [[GEPOPARG]], ptr [[ARGP]], align 8 // CK1: call {{.*}}tgt_target_kernel({{.*}}) #endif diff --git a/clang/test/OpenMP/ordered_doacross_codegen.c b/clang/test/OpenMP/ordered_doacross_codegen.c --- a/clang/test/OpenMP/ordered_doacross_codegen.c +++ b/clang/test/OpenMP/ordered_doacross_codegen.c @@ -1,14 +1,14 @@ -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NORMAL -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -triple x86_64-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -triple x86_64-unknown-unknown -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NORMAL +// RUN: %clang_cc1 -verify -fopenmp -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NORMAL +// RUN: %clang_cc1 -fopenmp -triple x86_64-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -triple x86_64-unknown-unknown -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NORMAL -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -fopenmp-enable-irbuilder -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-IRBUILDER -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-enable-irbuilder -triple x86_64-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-enable-irbuilder -triple x86_64-unknown-unknown -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-IRBUILDER +// RUN: %clang_cc1 -verify -fopenmp -fopenmp-enable-irbuilder -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-IRBUILDER +// RUN: %clang_cc1 -fopenmp -fopenmp-enable-irbuilder -triple x86_64-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -fopenmp-enable-irbuilder -triple x86_64-unknown-unknown -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-IRBUILDER -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp-simd -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -triple x86_64-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -triple x86_64-unknown-unknown -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s +// RUN: %clang_cc1 -verify -fopenmp-simd -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY0 %s +// RUN: %clang_cc1 -fopenmp-simd -triple x86_64-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp-simd -triple x86_64-unknown-unknown -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s // SIMD-ONLY0-NOT: {{__kmpc|__tgt}} // expected-no-diagnostics @@ -24,55 +24,53 @@ int main(void) { int i; // CHECK: [[DIMS:%.+]] = alloca [1 x [[KMP_DIM]]], -// CHECK-NORMAL: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) +// CHECK-NORMAL: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) // CHECK: icmp // CHECK-NEXT: br i1 % -// CHECK: [[CAST:%.+]] = bitcast [1 x [[KMP_DIM]]]* [[DIMS]] to i8* -// CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 [[CAST]], i8 0, i64 24, i1 false) -// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], [1 x [[KMP_DIM]]]* [[DIMS]], i64 0, i64 0 -// CHECK: getelementptr inbounds [[KMP_DIM]], [[KMP_DIM]]* [[DIM]], i32 0, i32 1 -// CHECK: store i64 %{{.+}}, i64* % -// CHECK: getelementptr inbounds [[KMP_DIM]], [[KMP_DIM]]* [[DIM]], i32 0, i32 2 -// CHECK: store i64 1, i64* % -// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], [1 x [[KMP_DIM]]]* [[DIMS]], i64 0, i64 0 -// CHECK: [[CAST:%.+]] = bitcast [[KMP_DIM]]* [[DIM]] to i8* -// CHECK-NORMAL: call void @__kmpc_doacross_init([[IDENT]], i32 [[GTID]], i32 1, i8* [[CAST]]) -// CHECK-NORMAL: call void @__kmpc_for_static_init_4(%struct.ident_t* @{{.+}}, i32 [[GTID]], i32 33, i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1) +// CHECK: call void @llvm.memset.p0.i64(ptr align 8 [[DIMS]], i8 0, i64 24, i1 false) +// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], ptr [[DIMS]], i64 0, i64 0 +// CHECK: getelementptr inbounds [[KMP_DIM]], ptr [[DIM]], i32 0, i32 1 +// CHECK: store i64 %{{.+}}, ptr % +// CHECK: getelementptr inbounds [[KMP_DIM]], ptr [[DIM]], i32 0, i32 2 +// CHECK: store i64 1, ptr % +// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], ptr [[DIMS]], i64 0, i64 0 +// CHECK-NORMAL: call void @__kmpc_doacross_init(ptr [[IDENT]], i32 [[GTID]], i32 1, ptr [[DIM]]) +// CHECK-NORMAL: call void @__kmpc_for_static_init_4(ptr @{{.+}}, i32 [[GTID]], i32 33, ptr %{{.+}}, ptr %{{.+}}, ptr %{{.+}}, ptr %{{.+}}, i32 1, i32 1) #pragma omp for ordered(1) for (i = 0; i < n; ++i) { a[i] = b[i] + 1; foo(); // CHECK: call void @foo() -// CHECK: load i32, i32* [[I:%.+]], +// CHECK: load i32, ptr [[I:%.+]], // CHECK-NEXT: sub nsw i32 %{{.+}}, 0 // CHECK-NEXT: sdiv i32 %{{.+}}, 1 // CHECK-NEXT: sext i32 %{{.+}} to i64 -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_post([[IDENT]], i32 [[GTID]], i64* [[TMP]]) -// CHECK-IRBUILDER-NEXT: [[GTID1:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) -// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_post([[IDENT]], i32 [[GTID1]], i64* [[TMP]]) +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_post(ptr [[IDENT]], i32 [[GTID]], ptr [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[GTID1:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) +// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_post(ptr [[IDENT]], i32 [[GTID1]], ptr [[TMP]]) #pragma omp ordered depend(source) c[i] = c[i] + 1; foo(); // CHECK: call void @foo() -// CHECK: load i32, i32* [[I]], +// CHECK: load i32, ptr [[I]], // CHECK-NEXT: sub nsw i32 %{{.+}}, 2 // CHECK-NEXT: sub nsw i32 %{{.+}}, 0 // CHECK-NEXT: sdiv i32 %{{.+}}, 1 // CHECK-NEXT: sext i32 %{{.+}} to i64 -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_wait([[IDENT]], i32 [[GTID]], i64* [[TMP]]) -// CHECK-IRBUILDER-NEXT: [[GTID2:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) -// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_wait([[IDENT]], i32 [[GTID2]], i64* [[TMP]]) +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_wait(ptr [[IDENT]], i32 [[GTID]], ptr [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[GTID2:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) +// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_wait(ptr [[IDENT]], i32 [[GTID2]], ptr [[TMP]]) #pragma omp ordered depend(sink : i - 2) d[i] = a[i - 2]; } // CHECK: call void @__kmpc_for_static_fini( - // CHECK-NORMAL: call void @__kmpc_doacross_fini([[IDENT]], i32 [[GTID]]) + // CHECK-NORMAL: call void @__kmpc_doacross_fini(ptr [[IDENT]], i32 [[GTID]]) // CHECK: ret i32 0 return 0; } diff --git a/clang/test/OpenMP/ordered_doacross_codegen.cpp b/clang/test/OpenMP/ordered_doacross_codegen.cpp --- a/clang/test/OpenMP/ordered_doacross_codegen.cpp +++ b/clang/test/OpenMP/ordered_doacross_codegen.cpp @@ -1,14 +1,14 @@ -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NORMAL -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NORMAL +// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NORMAL +// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NORMAL -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -fopenmp-enable-irbuilder -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s --check-prefixes=CHECK,CHECK-IRBUILDER -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-enable-irbuilder -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-enable-irbuilder -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-IRBUILDER +// RUN: %clang_cc1 -verify -fopenmp -fopenmp-enable-irbuilder -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s --check-prefixes=CHECK,CHECK-IRBUILDER +// RUN: %clang_cc1 -fopenmp -fopenmp-enable-irbuilder -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -fopenmp-enable-irbuilder -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-IRBUILDER -// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck --check-prefix SIMD-ONLY0 %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s +// RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck --check-prefix SIMD-ONLY0 %s +// RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s // SIMD-ONLY0-NOT: {{__kmpc|__tgt}} // expected-no-diagnostics @@ -41,56 +41,54 @@ int main() { int i; // CHECK: [[DIMS:%.+]] = alloca [1 x [[KMP_DIM]]], -// CHECK-NORMAL: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) +// CHECK-NORMAL: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) // CHECK: icmp // CHECK-NEXT: br i1 % -// CHECK: [[CAST:%.+]] = bitcast [1 x [[KMP_DIM]]]* [[DIMS]] to i8* -// CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 [[CAST]], i8 0, i64 24, i1 false) -// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], [1 x [[KMP_DIM]]]* [[DIMS]], i64 0, i64 0 -// CHECK: getelementptr inbounds [[KMP_DIM]], [[KMP_DIM]]* [[DIM]], i32 0, i32 1 -// CHECK: store i64 %{{.+}}, i64* % -// CHECK: getelementptr inbounds [[KMP_DIM]], [[KMP_DIM]]* [[DIM]], i32 0, i32 2 -// CHECK: store i64 1, i64* % -// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], [1 x [[KMP_DIM]]]* [[DIMS]], i64 0, i64 0 -// CHECK: [[CAST:%.+]] = bitcast [[KMP_DIM]]* [[DIM]] to i8* -// CHECK-NORMAL: call void @__kmpc_doacross_init([[IDENT]], i32 [[GTID]], i32 1, i8* [[CAST]]) -// CHECK-NORMAL: call void @__kmpc_for_static_init_4(%struct.ident_t* @{{.+}}, i32 [[GTID]], i32 33, i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1) +// CHECK: call void @llvm.memset.p0.i64(ptr align 8 [[DIMS]], i8 0, i64 24, i1 false) +// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], ptr [[DIMS]], i64 0, i64 0 +// CHECK: getelementptr inbounds [[KMP_DIM]], ptr [[DIM]], i32 0, i32 1 +// CHECK: store i64 %{{.+}}, ptr % +// CHECK: getelementptr inbounds [[KMP_DIM]], ptr [[DIM]], i32 0, i32 2 +// CHECK: store i64 1, ptr % +// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], ptr [[DIMS]], i64 0, i64 0 +// CHECK-NORMAL: call void @__kmpc_doacross_init(ptr [[IDENT]], i32 [[GTID]], i32 1, ptr [[DIM]]) +// CHECK-NORMAL: call void @__kmpc_for_static_init_4(ptr @{{.+}}, i32 [[GTID]], i32 33, ptr %{{.+}}, ptr %{{.+}}, ptr %{{.+}}, ptr %{{.+}}, i32 1, i32 1) #pragma omp for ordered(1) for (int i = 0; i < n; ++i) { a[i] = b[i] + 1; foo(); // CHECK: invoke void [[FOO:.+]]( -// CHECK: load i32, i32* [[I:%.+]], +// CHECK: load i32, ptr [[I:%.+]], // CHECK-NEXT: sub nsw i32 %{{.+}}, 0 // CHECK-NEXT: sdiv i32 %{{.+}}, 1 // CHECK-NEXT: sext i32 %{{.+}} to i64 -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_post([[IDENT]], i32 [[GTID]], i64* [[TMP]]) -// CHECK-IRBUILDER-NEXT: [[GTID18:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) -// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_post([[IDENT]], i32 [[GTID18]], i64* [[TMP]]) +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_post(ptr [[IDENT]], i32 [[GTID]], ptr [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[GTID18:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) +// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_post(ptr [[IDENT]], i32 [[GTID18]], ptr [[TMP]]) #pragma omp ordered depend(source) c[i] = c[i] + 1; foo(); // CHECK: invoke void [[FOO]] -// CHECK: load i32, i32* [[I]], +// CHECK: load i32, ptr [[I]], // CHECK-NEXT: sub nsw i32 %{{.+}}, 2 // CHECK-NEXT: sub nsw i32 %{{.+}}, 0 // CHECK-NEXT: sdiv i32 %{{.+}}, 1 // CHECK-NEXT: sext i32 %{{.+}} to i64 -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_wait([[IDENT]], i32 [[GTID]], i64* [[TMP]]) -// CHECK-IRBUILDER-NEXT: [[GTID30:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) -// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_wait([[IDENT]], i32 [[GTID30]], i64* [[TMP]]) +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_wait(ptr [[IDENT]], i32 [[GTID]], ptr [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[GTID30:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) +// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_wait(ptr [[IDENT]], i32 [[GTID30]], ptr [[TMP]]) #pragma omp ordered depend(sink : i - 2) d[i] = a[i - 2]; } // CHECK: call void @__kmpc_for_static_fini( - // CHECK-NORMAL: call void @__kmpc_doacross_fini([[IDENT]], i32 [[GTID]]) + // CHECK-NORMAL: call void @__kmpc_doacross_fini(ptr [[IDENT]], i32 [[GTID]]) // CHECK: ret i32 0 return 0; } @@ -98,57 +96,55 @@ // CHECK-LABEL: main1 int main1() { // CHECK: [[DIMS:%.+]] = alloca [1 x [[KMP_DIM]]], -// CHECK-NORMAL: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) +// CHECK-NORMAL: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) // CHECK: icmp // CHECK-NEXT: br i1 % -// CHECK: [[CAST:%.+]] = bitcast [1 x [[KMP_DIM]]]* [[DIMS]] to i8* -// CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 [[CAST]], i8 0, i64 24, i1 false) -// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], [1 x [[KMP_DIM]]]* [[DIMS]], i64 0, i64 0 -// CHECK: getelementptr inbounds [[KMP_DIM]], [[KMP_DIM]]* [[DIM]], i32 0, i32 1 -// CHECK: store i64 %{{.+}}, i64* % -// CHECK: getelementptr inbounds [[KMP_DIM]], [[KMP_DIM]]* [[DIM]], i32 0, i32 2 -// CHECK: store i64 1, i64* % -// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], [1 x [[KMP_DIM]]]* [[DIMS]], i64 0, i64 0 -// CHECK: [[CAST:%.+]] = bitcast [[KMP_DIM]]* [[DIM]] to i8* -// CHECK-NORMAL: call void @__kmpc_doacross_init([[IDENT]], i32 [[GTID]], i32 1, i8* [[CAST]]) -// CHECK-NORMAL: call void @__kmpc_for_static_init_4(%struct.ident_t* @{{.+}}, i32 [[GTID]], i32 33, i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1) +// CHECK: call void @llvm.memset.p0.i64(ptr align 8 [[DIMS]], i8 0, i64 24, i1 false) +// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], ptr [[DIMS]], i64 0, i64 0 +// CHECK: getelementptr inbounds [[KMP_DIM]], ptr [[DIM]], i32 0, i32 1 +// CHECK: store i64 %{{.+}}, ptr % +// CHECK: getelementptr inbounds [[KMP_DIM]], ptr [[DIM]], i32 0, i32 2 +// CHECK: store i64 1, ptr % +// CHECK: [[DIM:%.+]] = getelementptr inbounds [1 x [[KMP_DIM]]], ptr [[DIMS]], i64 0, i64 0 +// CHECK-NORMAL: call void @__kmpc_doacross_init(ptr [[IDENT]], i32 [[GTID]], i32 1, ptr [[DIM]]) +// CHECK-NORMAL: call void @__kmpc_for_static_init_4(ptr @{{.+}}, i32 [[GTID]], i32 33, ptr %{{.+}}, ptr %{{.+}}, ptr %{{.+}}, ptr %{{.+}}, i32 1, i32 1) #pragma omp for ordered(1) for (int i = n; i > 0; --i) { a[i] = b[i] + 1; foo(); // CHECK: invoke void [[FOO:.+]]( -// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB:%.+]], -// CHECK-NEXT: [[I_VAL:%.+]] = load i32, i32* [[I:%.+]], +// CHECK: [[UB_VAL:%.+]] = load i32, ptr [[UB:%.+]], +// CHECK-NEXT: [[I_VAL:%.+]] = load i32, ptr [[I:%.+]], // CHECK-NEXT: sub i32 [[UB_VAL]], [[I_VAL]] // CHECK-NEXT: udiv i32 %{{.+}}, 1 // CHECK-NEXT: zext i32 %{{.+}} to i64 -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_post([[IDENT]], i32 [[GTID]], i64* [[TMP]]) -// CHECK-IRBUILDER-NEXT: [[GTID17:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) -// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_post([[IDENT]], i32 [[GTID17]], i64* [[TMP]]) +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_post(ptr [[IDENT]], i32 [[GTID]], ptr [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[GTID17:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) +// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_post(ptr [[IDENT]], i32 [[GTID17]], ptr [[TMP]]) #pragma omp ordered depend(source) c[i] = c[i] + 1; foo(); // CHECK: invoke void [[FOO]] -// CHECK: [[UB_VAL:%.+]] = load i32, i32* [[UB]], -// CHECK-NEXT: [[I_VAL:%.+]] = load i32, i32* [[I]], +// CHECK: [[UB_VAL:%.+]] = load i32, ptr [[UB]], +// CHECK-NEXT: [[I_VAL:%.+]] = load i32, ptr [[I]], // CHECK-NEXT: [[SUB:%.+]] = sub nsw i32 [[I_VAL]], 2 // CHECK-NEXT: sub i32 [[UB_VAL]], [[SUB]] // CHECK-NEXT: udiv i32 %{{.+}}, 1 // CHECK-NEXT: zext i32 %{{.+}} to i64 -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], [1 x i64]* [[CNT]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_wait([[IDENT]], i32 [[GTID]], i64* [[TMP]]) -// CHECK-IRBUILDER-NEXT: [[GTID29:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) -// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_wait([[IDENT]], i32 [[GTID29]], i64* [[TMP]]) +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [1 x i64], ptr [[CNT]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_wait(ptr [[IDENT]], i32 [[GTID]], ptr [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[GTID29:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) +// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_wait(ptr [[IDENT]], i32 [[GTID29]], ptr [[TMP]]) #pragma omp ordered depend(sink : i - 2) d[i] = a[i - 2]; } // CHECK: call void @__kmpc_for_static_fini( - // CHECK-NORMAL: call void @__kmpc_doacross_fini([[IDENT]], i32 [[GTID]]) + // CHECK-NORMAL: call void @__kmpc_doacross_fini(ptr [[IDENT]], i32 [[GTID]]) // CHECK: ret i32 0 return 0; } @@ -166,102 +162,100 @@ void baz(T, T); TestStruct() { // CHECK: [[DIMS:%.+]] = alloca [2 x [[KMP_DIM]]], -// CHECK-NORMAL: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) -// CHECK: [[CAST:%.+]] = bitcast [2 x [[KMP_DIM]]]* [[DIMS]] to i8* -// CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 [[CAST]], i8 0, i64 48, i1 false) -// CHECK: [[DIM:%.+]] = getelementptr inbounds [2 x [[KMP_DIM]]], [2 x [[KMP_DIM]]]* [[DIMS]], i64 0, i64 0 -// CHECK: getelementptr inbounds [[KMP_DIM]], [[KMP_DIM]]* [[DIM]], i32 0, i32 1 -// CHECK: store i64 10, i64* % -// CHECK: getelementptr inbounds [[KMP_DIM]], [[KMP_DIM]]* [[DIM]], i32 0, i32 2 -// CHECK: store i64 1, i64* % -// CHECK: [[DIM:%.+]] = getelementptr inbounds [2 x [[KMP_DIM]]], [2 x [[KMP_DIM]]]* [[DIMS]], i64 0, i64 1 -// CHECK: getelementptr inbounds [[KMP_DIM]], [[KMP_DIM]]* [[DIM]], i32 0, i32 1 -// CHECK: store i64 %{{.+}}, i64* % -// CHECK: getelementptr inbounds [[KMP_DIM]], [[KMP_DIM]]* [[DIM]], i32 0, i32 2 -// CHECK: store i64 1, i64* % -// CHECK: [[DIM:%.+]] = getelementptr inbounds [2 x [[KMP_DIM]]], [2 x [[KMP_DIM]]]* [[DIMS]], i64 0, i64 0 -// CHECK: [[CAST:%.+]] = bitcast [[KMP_DIM]]* [[DIM]] to i8* -// CHECK-NORMAL: call void @__kmpc_doacross_init([[IDENT]], i32 [[GTID]], i32 2, i8* [[CAST]]) -// CHECK-NORMAL: call void @__kmpc_for_static_init_4(%struct.ident_t* @{{.+}}, i32 [[GTID]], i32 33, i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1) +// CHECK-NORMAL: [[GTID:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) +// CHECK: call void @llvm.memset.p0.i64(ptr align 8 [[DIMS]], i8 0, i64 48, i1 false) +// CHECK: [[DIM:%.+]] = getelementptr inbounds [2 x [[KMP_DIM]]], ptr [[DIMS]], i64 0, i64 0 +// CHECK: getelementptr inbounds [[KMP_DIM]], ptr [[DIM]], i32 0, i32 1 +// CHECK: store i64 10, ptr % +// CHECK: getelementptr inbounds [[KMP_DIM]], ptr [[DIM]], i32 0, i32 2 +// CHECK: store i64 1, ptr % +// CHECK: [[DIM:%.+]] = getelementptr inbounds [2 x [[KMP_DIM]]], ptr [[DIMS]], i64 0, i64 1 +// CHECK: getelementptr inbounds [[KMP_DIM]], ptr [[DIM]], i32 0, i32 1 +// CHECK: store i64 %{{.+}}, ptr % +// CHECK: getelementptr inbounds [[KMP_DIM]], ptr [[DIM]], i32 0, i32 2 +// CHECK: store i64 1, ptr % +// CHECK: [[DIM:%.+]] = getelementptr inbounds [2 x [[KMP_DIM]]], ptr [[DIMS]], i64 0, i64 0 +// CHECK-NORMAL: call void @__kmpc_doacross_init(ptr [[IDENT]], i32 [[GTID]], i32 2, ptr [[DIM]]) +// CHECK-NORMAL: call void @__kmpc_for_static_init_4(ptr @{{.+}}, i32 [[GTID]], i32 33, ptr %{{.+}}, ptr %{{.+}}, ptr %{{.+}}, ptr %{{.+}}, i32 1, i32 1) #pragma omp for ordered(2) for (T j = 0; j < M; j++) for (i = 0; i < n; i += 2) { a[i][j] = foo(i, j); // CHECK: invoke {{.+TestStruct.+foo}} -// CHECK: load i32*, i32** % -// CHECK: load i32, i32* % -// CHECK: load i32, i32* % -// CHECK: load i32, i32* [[J:%.+]], +// CHECK: load ptr, ptr % +// CHECK: load i32, ptr % +// CHECK: load i32, ptr % +// CHECK: load i32, ptr [[J:%.+]], // CHECK-NEXT: sub nsw i32 %{{.+}}, 0 // CHECK-NEXT: sdiv i32 %{{.+}}, 1 // CHECK-NEXT: sext i32 %{{.+}} to i64 -// CHECK-NORMAL-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: store i64 %{{.+}}, i64* [[TMP:%.+]], -// CHECK-NEXT: [[I:%.+]] = load i32*, i32** [[I_REF:%.+]], -// CHECK-NEXT: load i32, i32* [[I]], +// CHECK-NORMAL-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: store i64 %{{.+}}, ptr [[TMP:%.+]], +// CHECK-NEXT: [[I:%.+]] = load ptr, ptr [[I_REF:%.+]], +// CHECK-NEXT: load i32, ptr [[I]], // CHECK-NEXT: sub nsw i32 %{{.+}}, 2 // CHECK-NEXT: sub nsw i32 %{{.+}}, 0 // CHECK-NEXT: sdiv i32 %{{.+}}, 2 // CHECK-NEXT: sext i32 %{{.+}} to i64 -// CHECK-IRBUILDER-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-IRBUILDER-NEXT: store i64 %{{.+}}, i64* [[TMP:%.+]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT]], i64 0, i64 1 -// CHECK-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_wait([[IDENT]], i32 [[GTID]], i64* [[TMP]]) -// CHECK-IRBUILDER-NEXT: [[GTID18:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) -// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_wait([[IDENT]], i32 [[GTID18]], i64* [[TMP]]) -// CHECK-NEXT: load i32, i32* [[J:%.+]], +// CHECK-IRBUILDER-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-IRBUILDER-NEXT: store i64 %{{.+}}, ptr [[TMP:%.+]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT]], i64 0, i64 1 +// CHECK-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_wait(ptr [[IDENT]], i32 [[GTID]], ptr [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[GTID18:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) +// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_wait(ptr [[IDENT]], i32 [[GTID18]], ptr [[TMP]]) +// CHECK-NEXT: load i32, ptr [[J:%.+]], // CHECK-NEXT: sub nsw i32 %{{.+}}, 1 // CHECK-NEXT: sub nsw i32 %{{.+}}, 0 // CHECK-NEXT: sdiv i32 %{{.+}}, 1 // CHECK-NEXT: sext i32 %{{.+}} to i64 -// CHECK-NORMAL-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[I:%.+]] = load i32*, i32** [[I_REF]], -// CHECK-NEXT: load i32, i32* [[I]], +// CHECK-NORMAL-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[I:%.+]] = load ptr, ptr [[I_REF]], +// CHECK-NEXT: load i32, ptr [[I]], // CHECK-NEXT: sub nsw i32 %{{.+}}, 0 // CHECK-NEXT: sdiv i32 %{{.+}}, 2 // CHECK-NEXT: sext i32 %{{.+}} to i64 -// CHECK-IRBUILDER-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-IRBUILDER-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT]], i64 0, i64 1 -// CHECK-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_wait([[IDENT]], i32 [[GTID]], i64* [[TMP]]) -// CHECK-IRBUILDER-NEXT: [[GTID27:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) -// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_wait([[IDENT]], i32 [[GTID27]], i64* [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-IRBUILDER-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT]], i64 0, i64 1 +// CHECK-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_wait(ptr [[IDENT]], i32 [[GTID]], ptr [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[GTID27:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) +// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_wait(ptr [[IDENT]], i32 [[GTID27]], ptr [[TMP]]) #pragma omp ordered depend(sink : j, i - 2) depend(sink : j - 1, i) b[i][j] = bar(a[i][j], b[i - 1][j], b[i][j - 1]); // CHECK: invoke {{.+TestStruct.+bar}} -// CHECK: load i32*, i32** % -// CHECK: load i32, i32* % -// CHECK: load i32, i32* % -// CHECK: load i32, i32* [[J]], +// CHECK: load ptr, ptr % +// CHECK: load i32, ptr % +// CHECK: load i32, ptr % +// CHECK: load i32, ptr [[J]], // CHECK-NEXT: sub nsw i32 %{{.+}}, 0 // CHECK-NEXT: sdiv i32 %{{.+}}, 1 // CHECK-NEXT: sext i32 %{{.+}} to i64 -// CHECK-NORMAL-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[I:%.+]] = load i32*, i32** [[I_REF]], -// CHECK-NEXT: load i32, i32* [[I]], +// CHECK-NORMAL-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[I:%.+]] = load ptr, ptr [[I_REF]], +// CHECK-NEXT: load i32, ptr [[I]], // CHECK-NEXT: sub nsw i32 %{{.+}}, 0 // CHECK-NEXT: sdiv i32 %{{.+}}, 2 // CHECK-NEXT: sext i32 %{{.+}} to i64 -// CHECK-IRBUILDER-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT:%.+]], i64 0, i64 0 -// CHECK-IRBUILDER-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT]], i64 0, i64 1 -// CHECK-NEXT: store i64 %{{.+}}, i64* [[TMP]], -// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], [2 x i64]* [[CNT]], i64 0, i64 0 -// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_post([[IDENT]], i32 [[GTID]], i64* [[TMP]]) -// CHECK-IRBUILDER-NEXT: [[GTID58:%.+]] = call i32 @__kmpc_global_thread_num([[IDENT:%.+]]) -// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_post([[IDENT]], i32 [[GTID58]], i64* [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT:%.+]], i64 0, i64 0 +// CHECK-IRBUILDER-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT]], i64 0, i64 1 +// CHECK-NEXT: store i64 %{{.+}}, ptr [[TMP]], +// CHECK-NEXT: [[TMP:%.+]] = getelementptr inbounds [2 x i64], ptr [[CNT]], i64 0, i64 0 +// CHECK-NORMAL-NEXT: call void @__kmpc_doacross_post(ptr [[IDENT]], i32 [[GTID]], ptr [[TMP]]) +// CHECK-IRBUILDER-NEXT: [[GTID58:%.+]] = call i32 @__kmpc_global_thread_num(ptr [[IDENT:@.+]]) +// CHECK-IRBUILDER-NEXT: call void @__kmpc_doacross_post(ptr [[IDENT]], i32 [[GTID58]], ptr [[TMP]]) #pragma omp ordered depend(source) baz(a[i][j], b[i][j]); } } // CHECK: call void @__kmpc_for_static_fini( - // CHECK-NORMAL: call void @__kmpc_doacross_fini([[IDENT]], i32 [[GTID]]) + // CHECK-NORMAL: call void @__kmpc_doacross_fini(ptr [[IDENT]], i32 [[GTID]]) // CHECK: ret }; diff --git a/clang/test/OpenMP/target_map_codegen_18.inc b/clang/test/OpenMP/target_map_codegen_18.inc --- a/clang/test/OpenMP/target_map_codegen_18.inc +++ b/clang/test/OpenMP/target_map_codegen_18.inc @@ -245,22 +245,20 @@ int a = ii; // Region 00 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 -1, i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] - // CK19-DAG: store i32* [[VAR0]], i32** [[CP0]] + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[VAR0]], ptr [[P0]] - // CK19-USE: call void [[CALL00:@.+]](i32* {{[^,]+}}) + // CK19-USE: call void [[CALL00:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL00:@.+]]() #pragma omp target map(alloc:a) { @@ -273,22 +271,20 @@ int b = a; // Region 00n - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 -1, i32 1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] - // CK19-DAG: store i32* [[VAR0]], i32** [[CP0]] + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[VAR0]], ptr [[P0]] - // CK19-USE: call void [[CALL00n:@.+]](i32* {{[^,]+}}) + // CK19-USE: call void [[CALL00n:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL00n:@.+]]() #pragma omp target map(alloc:b) #pragma omp parallel @@ -302,22 +298,20 @@ int arra[100]; // Region 01 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [100 x i32]** - // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] - // CK19-DAG: store [100 x i32]* [[VAR0]], [100 x i32]** [[CP0]] + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[VAR0]], ptr [[P0]] - // CK19-USE: call void [[CALL01:@.+]]([100 x i32]* {{[^,]+}}) + // CK19-USE: call void [[CALL01:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL01:@.+]]() #pragma omp target map(to:arra) { @@ -327,23 +321,21 @@ } // Region 02 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 20 + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 20 - // CK19-USE: call void [[CALL02:@.+]]([100 x i32]* {{[^,]+}}) + // CK19-USE: call void [[CALL02:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL02:@.+]]() #pragma omp target map(from:arra[20:60]) { @@ -353,23 +345,21 @@ } // Region 03 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 0 + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE: call void [[CALL03:@.+]]([100 x i32]* {{[^,]+}}) + // CK19-USE: call void [[CALL03:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL03:@.+]]() #pragma omp target map(tofrom:arra[:60]) { @@ -379,23 +369,21 @@ } // Region 04 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 0 + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE: call void [[CALL04:@.+]]([100 x i32]* {{[^,]+}}) + // CK19-USE: call void [[CALL04:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL04:@.+]]() #pragma omp target map(alloc:arra[:]) { @@ -405,23 +393,21 @@ } // Region 05 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 15 + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 15 - // CK19-USE: call void [[CALL05:@.+]]([100 x i32]* {{[^,]+}}) + // CK19-USE: call void [[CALL05:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL05:@.+]]() #pragma omp target map(to:arra[15]) { @@ -431,13 +417,13 @@ } // Region 06 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] @@ -445,15 +431,13 @@ // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] - // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] + // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], ptr [[S0]] // CK19-DAG: [[CSVAL0]] = {{mul nuw i.+ %.*, 4|sext i32 .+ to i64}} - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} %{{.*}} + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} %{{.*}} - // CK19-USE: call void [[CALL06:@.+]]([100 x i32]* {{[^,]+}}) + // CK19-USE: call void [[CALL06:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL06:@.+]]() #pragma omp target map(tofrom:arra[ii:ii+23]) { @@ -463,13 +447,13 @@ } // Region 07 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] @@ -477,15 +461,13 @@ // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] - // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] + // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], ptr [[S0]] // CK19-DAG: [[CSVAL0]] = {{mul nuw i.+ %.*, 4|sext i32 .+ to i64}} - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 0 + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE: call void [[CALL07:@.+]]([100 x i32]* {{[^,]+}}) + // CK19-USE: call void [[CALL07:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL07:@.+]]() #pragma omp target map(alloc:arra[:ii]) { @@ -495,23 +477,21 @@ } // Region 08 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} %{{.*}} + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} %{{.*}} - // CK19-USE: call void [[CALL08:@.+]]([100 x i32]* {{[^,]+}}) + // CK19-USE: call void [[CALL08:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL08:@.+]]() #pragma omp target map(tofrom:arra[ii]) { @@ -524,22 +504,20 @@ int *pa; // Region 09 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32*** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32*** - // CK19-DAG: store i32** [[VAR0:%.+]], i32*** [[CBP0]] - // CK19-DAG: store i32** [[VAR0]], i32*** [[CP0]] + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[VAR0]], ptr [[P0]] - // CK19-USE: call void [[CALL09:@.+]](i32** {{[^,]+}}) + // CK19-USE: call void [[CALL09:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL09:@.+]]() #pragma omp target map(from:pa) { @@ -549,25 +527,23 @@ } // Region 10 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 20 - // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] - - // CK19-USE: call void [[CALL10:@.+]](i32* {{[^,]+}}) + // CK19-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 20 + // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] + + // CK19-USE: call void [[CALL10:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL10:@.+]]() #pragma omp target map(tofrom:pa[20:60]) { @@ -577,25 +553,23 @@ } // Region 11 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 0 - // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] - - // CK19-USE: call void [[CALL11:@.+]](i32* {{[^,]+}}) + // CK19-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 0 + // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] + + // CK19-USE: call void [[CALL11:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL11:@.+]]() #pragma omp target map(alloc:pa[:60]) { @@ -605,25 +579,23 @@ } // Region 12 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 15 - // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] - - // CK19-USE: call void [[CALL12:@.+]](i32* {{[^,]+}}) + // CK19-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 15 + // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] + + // CK19-USE: call void [[CALL12:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL12:@.+]]() #pragma omp target map(to:pa[15]) { @@ -633,13 +605,13 @@ } // Region 13 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] @@ -647,17 +619,15 @@ // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] + // CK19-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], ptr [[S0]] // CK19-DAG: [[CSVAL0]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} - // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} %{{.*}} - // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} %{{.*}} + // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] - // CK19-USE: call void [[CALL13:@.+]](i32* {{[^,]+}}) + // CK19-USE: call void [[CALL13:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL13:@.+]]() #pragma omp target map(alloc:pa[ii-23:ii]) { @@ -667,13 +637,13 @@ } // Region 14 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] @@ -681,17 +651,15 @@ // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] + // CK19-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], ptr [[S0]] // CK19-DAG: [[CSVAL0]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} - // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} 0 - // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} 0 + // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] - // CK19-USE: call void [[CALL14:@.+]](i32* {{[^,]+}}) + // CK19-USE: call void [[CALL14:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL14:@.+]]() #pragma omp target map(to:pa[:ii]) { @@ -701,25 +669,23 @@ } // Region 15 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store i32* [[RVAR0:%.+]], i32** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-DAG: [[RVAR0]] = load i32*, i32** [[VAR0:%[^,]+]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[RVAR00:%.+]], i{{.+}} %{{.*}} - // CK19-DAG: [[RVAR00]] = load i32*, i32** [[VAR0]] - - // CK19-USE: call void [[CALL15:@.+]](i32* {{[^,]+}}) + // CK19-DAG: store ptr [[RVAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[RVAR0]] = load ptr, ptr [[VAR0:%[^,]+]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[RVAR00:%.+]], i{{.+}} %{{.*}} + // CK19-DAG: [[RVAR00]] = load ptr, ptr [[VAR0]] + + // CK19-USE: call void [[CALL15:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL15:@.+]]() #pragma omp target map(from:pa[ii+12]) { @@ -732,45 +698,39 @@ int va[ii]; // Region 16 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z:64|32]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z:64|32]] {{%.+}}, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[P0]] // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** - // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] - // CK19-USE-DAG: store i32* [[VAR1]], i32** [[CP1]] - // CK19-USE-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], i{{.+}}* [[S1]] + // CK19-USE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store ptr [[VAR1]], ptr [[P1]] + // CK19-USE-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], ptr [[S1]] // CK19-USE-DAG: [[CSVAL1]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] - // CK19-NOUSE-DAG: store i32* [[VAR0]], i32** [[CP0]] - // CK19-NOUSE-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[VAR0]], ptr [[P0]] + // CK19-NOUSE-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], ptr [[S0]] // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} - // CK19-USE: call void [[CALL16:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) + // CK19-USE: call void [[CALL16:@.+]](i{{.+}} {{[^,]+}}, ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL16:@.+]]() #pragma omp target map(to:va) { @@ -780,38 +740,32 @@ } // Region 17 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[P0]] // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** - // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] - // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] - // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 20 + // CK19-USE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[VAR1]], i{{.+}} 20 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] - // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} 20 + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 20 - // CK19-USE: call void [[CALL17:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) + // CK19-USE: call void [[CALL17:@.+]](i{{.+}} {{[^,]+}}, ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL17:@.+]]() #pragma omp target map(from:va[20:60]) { @@ -821,38 +775,32 @@ } // Region 18 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[P0]] // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** - // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] - // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] - // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 0 + // CK19-USE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[VAR1]], i{{.+}} 0 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] - // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} 0 + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0 - // CK19-USE: call void [[CALL18:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) + // CK19-USE: call void [[CALL18:@.+]](i{{.+}} {{[^,]+}}, ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL18:@.+]]() #pragma omp target map(tofrom:va[:60]) { @@ -862,47 +810,41 @@ } // Region 19 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[P0]] // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** - // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] - // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] - // CK19-USE-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], i{{.+}}* [[S1]] + // CK19-USE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-USE-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], ptr [[S1]] // CK19-USE-DAG: [[CSVAL1]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} - // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 0 + // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[VAR1]], i{{.+}} 0 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] - // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-NOUSE-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NOUSE-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], ptr [[S0]] // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} - // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} 0 + // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0 - // CK19-USE: call void [[CALL19:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) + // CK19-USE: call void [[CALL19:@.+]](i{{.+}} {{[^,]+}}, ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL19:@.+]]() #pragma omp target map(alloc:va[:]) { @@ -912,38 +854,32 @@ } // Region 20 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[P0]] // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** - // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] - // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] - // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} 15 + // CK19-USE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[VAR1]], i{{.+}} 15 // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] - // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} 15 + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 15 - // CK19-USE: call void [[CALL20:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) + // CK19-USE: call void [[CALL20:@.+]](i{{.+}} {{[^,]+}}, ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL20:@.+]]() #pragma omp target map(to:va[15]) { @@ -953,47 +889,41 @@ } // Region 21 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[P0]] // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** - // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] - // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] - // CK19-USE-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], i{{.+}}* [[S1]] + // CK19-USE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-USE-DAG: store i{{.+}} [[CSVAL1:%[^,]+]], ptr [[S1]] // CK19-USE-DAG: [[CSVAL1]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} - // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} %{{.+}} + // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[VAR1]], i{{.+}} %{{.+}} // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] - // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-NOUSE-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], i{{.+}}* [[S0]] + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NOUSE-DAG: store i{{.+}} [[CSVAL0:%[^,]+]], ptr [[S0]] // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %.*, 4|sext i32 .+ to i64}} - // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} %{{.+}} + // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} %{{.+}} - // CK19-USE: call void [[CALL21:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) + // CK19-USE: call void [[CALL21:@.+]](i{{.+}} {{[^,]+}}, ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL21:@.+]]() #pragma omp target map(tofrom:va[ii:ii+23]) { @@ -1003,38 +933,32 @@ } // Region 22 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] {{%.+}}, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] {{%.+}}, ptr [[P0]] // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32** - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32** - // CK19-USE-DAG: store i32* [[VAR1:%.+]], i32** [[CBP1]] - // CK19-USE-DAG: store i32* [[SEC1:%.+]], i32** [[CP1]] - // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}i32* [[VAR1]], i{{.+}} %{{.+}} + // CK19-USE-DAG: store ptr [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-USE-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[VAR1]], i{{.+}} %{{.+}} // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-NOUSE-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] - // CK19-NOUSE-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}i32* [[VAR0]], i{{.+}} %{{.+}} + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} %{{.+}} - // CK19-USE: call void [[CALL22:@.+]](i{{.+}} {{[^,]+}}, i32* {{[^,]+}}) + // CK19-USE: call void [[CALL22:@.+]](i{{.+}} {{[^,]+}}, ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL22:@.+]]() #pragma omp target map(tofrom:va[ii]) { @@ -1045,22 +969,20 @@ // Always. // Region 23 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store i32* [[VAR0:%.+]], i32** [[CBP0]] - // CK19-DAG: store i32* [[VAR0]], i32** [[CP0]] + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[VAR0]], ptr [[P0]] - // CK19-USE: call void [[CALL23:@.+]](i32* {{[^,]+}}) + // CK19-USE: call void [[CALL23:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL23:@.+]]() #pragma omp target map(always, tofrom: a) { @@ -1074,22 +996,20 @@ int ***mptr; // Region 24 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [4 x [5 x [6 x i32]]]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [4 x [5 x [6 x i32]]]** - // CK19-DAG: store [4 x [5 x [6 x i32]]]* [[VAR0:%.+]], [4 x [5 x [6 x i32]]]** [[CBP0]] - // CK19-DAG: store [4 x [5 x [6 x i32]]]* [[VAR0]], [4 x [5 x [6 x i32]]]** [[CP0]] + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[VAR0]], ptr [[P0]] - // CK19-USE: call void [[CALL24:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}}) + // CK19-USE: call void [[CALL24:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL24:@.+]]() #pragma omp target map(tofrom: marr) { @@ -1099,25 +1019,23 @@ } // Region 25 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [4 x [5 x [6 x i32]]]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [4 x [5 x [6 x i32]]]* [[VAR0:%.+]], [4 x [5 x [6 x i32]]]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[6 x i32]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: [[SEC00]] = getelementptr {{.*}}[5 x [6 x i32]]* [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: [[SEC000]] = getelementptr {{.*}}[4 x [5 x [6 x i32]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1 - - // CK19-USE: call void [[CALL25:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}}) + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 2 + // CK19-DAG: [[SEC00]] = getelementptr {{.*}}ptr [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2 + // CK19-DAG: [[SEC000]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 1 + + // CK19-USE: call void [[CALL25:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL25:@.+]]() #pragma omp target map(tofrom: marr[1][2][2:4]) { @@ -1127,25 +1045,23 @@ } // Region 26 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [4 x [5 x [6 x i32]]]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [4 x [5 x [6 x i32]]]* [[VAR0:%.+]], [4 x [5 x [6 x i32]]]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[6 x i32]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[SEC00]] = getelementptr {{.*}}[5 x [6 x i32]]* [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: [[SEC000]] = getelementptr {{.*}}[4 x [5 x [6 x i32]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1 - - // CK19-USE: call void [[CALL26:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}}) + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 0 + // CK19-DAG: [[SEC00]] = getelementptr {{.*}}ptr [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2 + // CK19-DAG: [[SEC000]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 1 + + // CK19-USE: call void [[CALL26:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL26:@.+]]() #pragma omp target map(tofrom: marr[1][2][:]) { @@ -1155,25 +1071,23 @@ } // Region 27 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [4 x [5 x [6 x i32]]]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [4 x [5 x [6 x i32]]]* [[VAR0:%.+]], [4 x [5 x [6 x i32]]]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%.+]], i32** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[6 x i32]* [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 3 - // CK19-DAG: [[SEC00]] = getelementptr {{.*}}[5 x [6 x i32]]* [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: [[SEC000]] = getelementptr {{.*}}[4 x [5 x [6 x i32]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 1 - - // CK19-USE: call void [[CALL27:@.+]]([4 x [5 x [6 x i32]]]* {{[^,]+}}) + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:[^,]+]], i{{.+}} 0, i{{.+}} 3 + // CK19-DAG: [[SEC00]] = getelementptr {{.*}}ptr [[SEC000:[^,]+]], i{{.+}} 0, i{{.+}} 2 + // CK19-DAG: [[SEC000]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 1 + + // CK19-USE: call void [[CALL27:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL27:@.+]]() #pragma omp target map(tofrom: marr[1][2][3]) { @@ -1183,49 +1097,43 @@ } // Region 28 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32**** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32**** - // CK19-DAG: store i32*** [[VAR0:%.+]], i32**** [[CBP0]] - // CK19-DAG: store i32*** [[SEC0:%.+]], i32**** [[CP0]] - // CK19-DAG: [[VAR0]] = load i32***, i32**** [[PTR:%[^,]+]], - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32*** [[SEC00:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC00]] = load i32***, i32**** [[PTR]], + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[VAR0]] = load ptr, ptr [[PTR:%[^,]+]], + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:[^,]+]], i{{.+}} 1 + // CK19-DAG: [[SEC00]] = load ptr, ptr [[PTR]], // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32**** - // CK19-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32*** - // CK19-DAG: store i32*** [[SEC0]], i32**** [[CBP1]] - // CK19-DAG: store i32** [[SEC1:%.+]], i32*** [[CP1]] - // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32** [[SEC11:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC11]] = load i32**, i32*** [[SEC111:%[^,]+]], - // CK19-DAG: [[SEC111]] = getelementptr {{.*}}i32*** [[SEC1111:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC1111]] = load i32***, i32**** [[PTR]], + // CK19-DAG: store ptr [[SEC0]], ptr [[BP1]] + // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], + // CK19-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:[^,]+]], i{{.+}} 1 + // CK19-DAG: [[SEC1111]] = load ptr, ptr [[PTR]], // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to i32*** - // CK19-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to i32** - // CK19-DAG: store i32** [[SEC1]], i32*** [[CBP2]] - // CK19-DAG: store i32* [[SEC2:%.+]], i32** [[CP2]] - // CK19-DAG: [[SEC2]] = getelementptr {{.*}}i32* [[SEC22:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC22]] = load i32*, i32** [[SEC222:%[^,]+]], - // CK19-DAG: [[SEC222]] = getelementptr {{.*}}i32** [[SEC2222:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC2222]] = load i32**, i32*** [[SEC22222:%[^,]+]], - // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}i32*** [[SEC222222:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC222222]] = load i32***, i32**** [[PTR]], - - // CK19-USE: call void [[CALL28:@.+]](i32*** {{[^,]+}}) + // CK19-DAG: store ptr [[SEC1]], ptr [[BP2]] + // CK19-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] + // CK19-DAG: [[SEC2]] = getelementptr {{.*}}ptr [[SEC22:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[SEC22]] = load ptr, ptr [[SEC222:%[^,]+]], + // CK19-DAG: [[SEC222]] = getelementptr {{.*}}ptr [[SEC2222:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[SEC2222]] = load ptr, ptr [[SEC22222:%[^,]+]], + // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}ptr [[SEC222222:[^,]+]], i{{.+}} 1 + // CK19-DAG: [[SEC222222]] = load ptr, ptr [[PTR]], + + // CK19-USE: call void [[CALL28:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL28:@.+]]() #pragma omp target map(tofrom: mptr[1][2][2:4]) { @@ -1235,49 +1143,43 @@ } // Region 29 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i32**** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32**** - // CK19-DAG: store i32*** [[VAR0:%.+]], i32**** [[CBP0]] - // CK19-DAG: store i32*** [[SEC0:%.+]], i32**** [[CP0]] - // CK19-DAG: [[VAR0]] = load i32***, i32**** [[PTR:%[^,]+]], - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}i32*** [[SEC00:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC00]] = load i32***, i32**** [[PTR]], + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[VAR0]] = load ptr, ptr [[PTR:%[^,]+]], + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:[^,]+]], i{{.+}} 1 + // CK19-DAG: [[SEC00]] = load ptr, ptr [[PTR]], // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i32**** - // CK19-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i32*** - // CK19-DAG: store i32*** [[SEC0]], i32**** [[CBP1]] - // CK19-DAG: store i32** [[SEC1:%.+]], i32*** [[CP1]] - // CK19-DAG: [[SEC1]] = getelementptr {{.*}}i32** [[SEC11:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC11]] = load i32**, i32*** [[SEC111:%[^,]+]], - // CK19-DAG: [[SEC111]] = getelementptr {{.*}}i32*** [[SEC1111:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC1111]] = load i32***, i32**** [[PTR]], + // CK19-DAG: store ptr [[SEC0]], ptr [[BP1]] + // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], + // CK19-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:[^,]+]], i{{.+}} 1 + // CK19-DAG: [[SEC1111]] = load ptr, ptr [[PTR]], // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to i32*** - // CK19-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to i32** - // CK19-DAG: store i32** [[SEC1]], i32*** [[CBP2]] - // CK19-DAG: store i32* [[SEC2:%.+]], i32** [[CP2]] - // CK19-DAG: [[SEC2]] = getelementptr {{.*}}i32* [[SEC22:[^,]+]], i{{.+}} 3 - // CK19-DAG: [[SEC22]] = load i32*, i32** [[SEC222:%[^,]+]], - // CK19-DAG: [[SEC222]] = getelementptr {{.*}}i32** [[SEC2222:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC2222]] = load i32**, i32*** [[SEC22222:%[^,]+]], - // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}i32*** [[SEC222222:[^,]+]], i{{.+}} 1 - // CK19-DAG: [[SEC222222]] = load i32***, i32**** [[PTR]], - - // CK19-USE: call void [[CALL29:@.+]](i32*** {{[^,]+}}) + // CK19-DAG: store ptr [[SEC1]], ptr [[BP2]] + // CK19-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] + // CK19-DAG: [[SEC2]] = getelementptr {{.*}}ptr [[SEC22:[^,]+]], i{{.+}} 3 + // CK19-DAG: [[SEC22]] = load ptr, ptr [[SEC222:%[^,]+]], + // CK19-DAG: [[SEC222]] = getelementptr {{.*}}ptr [[SEC2222:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[SEC2222]] = load ptr, ptr [[SEC22222:%[^,]+]], + // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}ptr [[SEC222222:[^,]+]], i{{.+}} 1 + // CK19-DAG: [[SEC222222]] = load ptr, ptr [[PTR]], + + // CK19-USE: call void [[CALL29:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL29:@.+]]() #pragma omp target map(tofrom: mptr[1][2][3]) { @@ -1290,63 +1192,53 @@ double mva[23][ii][ii+5]; // Region 30 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] 23, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] 23, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] 23, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] 23, ptr [[P0]] // // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] - // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], ptr [[P1]] // CK19-64-USE-DAG: [[VAR1]] = zext i32 %{{[^,]+}} to i64 // CK19-64-USE-DAG: [[VAR11]] = zext i32 %{{[^,]+}} to i64 // // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 - // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to i[[Z]]* - // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] [[VAR2:%.+]], i[[Z]]* [[CBP2]] - // CK19-USE-DAG: store i[[Z]] [[VAR22:%.+]], i[[Z]]* [[CP2]] + // CK19-USE-DAG: store i[[Z]] [[VAR2:%.+]], ptr [[BP2]] + // CK19-USE-DAG: store i[[Z]] [[VAR22:%.+]], ptr [[P2]] // CK19-64-USE-DAG: [[VAR2]] = zext i32 %{{[^,]+}} to i64 // CK19-64-USE-DAG: [[VAR22]] = zext i32 %{{[^,]+}} to i64 // // CK19-USE-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 3 // CK19-USE-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3 // CK19-USE-DAG: [[S3:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 3 - // CK19-USE-DAG: [[CBP3:%.+]] = bitcast i8** [[BP3]] to double** - // CK19-USE-DAG: [[CP3:%.+]] = bitcast i8** [[P3]] to double** - // CK19-USE-DAG: store double* [[VAR3:%.+]], double** [[CBP3]] - // CK19-USE-DAG: store double* [[VAR3]], double** [[CP3]] - // CK19-USE-DAG: store i64 [[CSVAL3:%[^,]+]], i64* [[S3]] + // CK19-USE-DAG: store ptr [[VAR3:%.+]], ptr [[BP3]] + // CK19-USE-DAG: store ptr [[VAR3]], ptr [[P3]] + // CK19-USE-DAG: store i64 [[CSVAL3:%[^,]+]], ptr [[S3]] // CK19-USE-DAG: [[CSVAL3]] = {{mul nuw i64 %[^,]+, 8|sext i32 .+ to i64}} // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to double** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to double** - // CK19-NOUSE-DAG: store double* [[VAR0:%.+]], double** [[CBP0]] - // CK19-NOUSE-DAG: store double* [[VAR0]], double** [[CP0]] - // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[VAR0]], ptr [[P0]] + // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], ptr [[S0]] // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 8|sext i32 .+ to i64}} - // CK19-USE: call void [[CALL30:@.+]](i[[Z]] 23, i[[Z]] %{{[^,]+}}, i[[Z]] %{{[^,]+}}, double* %{{[^,]+}}) + // CK19-USE: call void [[CALL30:@.+]](i[[Z]] 23, i[[Z]] %{{[^,]+}}, i[[Z]] %{{[^,]+}}, ptr %{{[^,]+}}) // CK19-NOUSE: call void [[CALL30:@.+]]() #pragma omp target map(tofrom: mva) { @@ -1356,60 +1248,50 @@ } // Region 31 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] 23, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] 23, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] 23, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] 23, ptr [[P0]] // // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] - // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], ptr [[P1]] // // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 - // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to i[[Z]]* - // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] [[VAR2:%.+]], i[[Z]]* [[CBP2]] - // CK19-USE-DAG: store i[[Z]] [[VAR22:%.+]], i[[Z]]* [[CP2]] + // CK19-USE-DAG: store i[[Z]] [[VAR2:%.+]], ptr [[BP2]] + // CK19-USE-DAG: store i[[Z]] [[VAR22:%.+]], ptr [[P2]] // // CK19-USE-DAG: [[BP3:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 3 // CK19-USE-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3 - // CK19-USE-DAG: [[CBP3:%.+]] = bitcast i8** [[BP3]] to double** - // CK19-USE-DAG: [[CP3:%.+]] = bitcast i8** [[P3]] to double** - // CK19-USE-DAG: store double* [[VAR3:%.+]], double** [[CBP3]] - // CK19-USE-DAG: store double* [[SEC3:%.+]], double** [[CP3]] - // CK19-USE-DAG: [[SEC3]] = getelementptr {{.*}}double* [[SEC33:%.+]], i[[Z]] 0 - // CK19-USE-DAG: [[SEC33]] = getelementptr {{.*}}double* [[SEC333:%.+]], i[[Z]] [[IDX3:%.+]] + // CK19-USE-DAG: store ptr [[VAR3:%.+]], ptr [[BP3]] + // CK19-USE-DAG: store ptr [[SEC3:%.+]], ptr [[P3]] + // CK19-USE-DAG: [[SEC3]] = getelementptr {{.*}}ptr [[SEC33:%.+]], i[[Z]] 0 + // CK19-USE-DAG: [[SEC33]] = getelementptr {{.*}}ptr [[SEC333:%.+]], i[[Z]] [[IDX3:%.+]] // CK19-USE-DAG: [[IDX3]] = mul nsw i[[Z]] %{{[^,]+}}, %{{[^,]+}} - // CK19-USE-DAG: [[SEC333]] = getelementptr {{.*}}double* [[VAR3]], i[[Z]] [[IDX33:%.+]] + // CK19-USE-DAG: [[SEC333]] = getelementptr {{.*}}ptr [[VAR3]], i[[Z]] [[IDX33:%.+]] // CK19-USE-DAG: [[IDX33]] = mul nsw i[[Z]] 1, %{{[^,]+}} // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to double** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to double** - // CK19-NOUSE-DAG: store double* [[VAR0:%.+]], double** [[CBP0]] - // CK19-NOUSE-DAG: store double* [[SEC0:%.+]], double** [[CP0]] - // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}double* [[SEC00:%.+]], i[[Z:64|32]] 0 - // CK19-NOUSE-DAG: [[SEC00]] = getelementptr {{.*}}double* [[SEC000:%.+]], i[[Z]] [[IDX0:%.+]] + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:%.+]], i[[Z:64|32]] 0 + // CK19-NOUSE-DAG: [[SEC00]] = getelementptr {{.*}}ptr [[SEC000:%.+]], i[[Z]] [[IDX0:%.+]] // CK19-NOUSE-DAG: [[IDX0]] = mul nsw i[[Z]] %{{[^,]+}}, %{{[^,]+}} - // CK19-NOUSE-DAG: [[SEC000]] = getelementptr {{.*}}double* [[VAR0]], i[[Z]] [[IDX00:%.+]] + // CK19-NOUSE-DAG: [[SEC000]] = getelementptr {{.*}}ptr [[VAR0]], i[[Z]] [[IDX00:%.+]] // CK19-NOUSE-DAG: [[IDX00]] = mul nsw i[[Z]] 1, %{{[^,]+}} - // CK19-USE: call void [[CALL31:@.+]](i[[Z]] 23, i[[Z]] %{{[^,]+}}, i[[Z]] %{{[^,]+}}, double* %{{[^,]+}}) + // CK19-USE: call void [[CALL31:@.+]](i[[Z]] 23, i[[Z]] %{{[^,]+}}, i[[Z]] %{{[^,]+}}, ptr %{{[^,]+}}) // CK19-NOUSE: call void [[CALL31:@.+]]() #pragma omp target map(tofrom: mva[1][ii-2][:5]) { @@ -1424,22 +1306,20 @@ double ***mptras; // Region 32 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [11 x [12 x [13 x double]]]** - // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] - // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0]], [11 x [12 x [13 x double]]]** [[CP0]] + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[VAR0]], ptr [[P0]] - // CK19-USE: call void [[CALL32:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) + // CK19-USE: call void [[CALL32:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL32:@.+]]() #pragma omp target map(marras) { @@ -1449,23 +1329,21 @@ } // Region 33 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [12 x [13 x double]]** - // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] - // CK19-DAG: store [12 x [13 x double]]* [[SEC0:%.+]], [12 x [13 x double]]** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 0 + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.+}}ptr [[VAR0]], i[[Z]] 0, i[[Z]] 0 - // CK19-USE: call void [[CALL33:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) + // CK19-USE: call void [[CALL33:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL33:@.+]]() #pragma omp target map(marras[:]) { @@ -1475,23 +1353,21 @@ } // Region 34 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [12 x [13 x double]]** - // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] - // CK19-DAG: store [12 x [13 x double]]* [[SEC0:%.+]], [12 x [13 x double]]** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 0 + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.+}}ptr [[VAR0]], i[[Z]] 0, i[[Z]] 0 - // CK19-USE: call void [[CALL34:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) + // CK19-USE: call void [[CALL34:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL34:@.+]]() #pragma omp target map(marras[:][:][:]) { @@ -1501,13 +1377,13 @@ } // Region 35 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] @@ -1516,16 +1392,14 @@ // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** - // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] - // CK19-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] - // CK19-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[12 x [13 x double]]* [[SEC00:%[^,]+]], i[[Z]] 0, i[[Z]] 0 - // CK19-DAG: [[SEC00]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 1 + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: store i64 [[CSVAL0:%[^,]+]], ptr [[S0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.+}}ptr [[SEC00:%[^,]+]], i[[Z]] 0, i[[Z]] 0 + // CK19-DAG: [[SEC00]] = getelementptr {{.+}}ptr [[VAR0]], i[[Z]] 0, i[[Z]] 1 // CK19-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} - // CK19-USE: call void [[CALL35:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) + // CK19-USE: call void [[CALL35:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL35:@.+]]() #pragma omp target map(marras[1][:ii][:]) { @@ -1535,25 +1409,23 @@ } // Region 36 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** - // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] - // CK19-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[SEC00:%[^,]+]], i{{.+}} 0 - // CK19-DAG: [[SEC00]] = getelementptr {{.+}}[12 x [13 x double]]* [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[SEC000]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i{{.+}} 0, i{{.+}} 0 - - // CK19-USE: call void [[CALL36:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.+}}ptr [[SEC00:%[^,]+]], i{{.+}} 0 + // CK19-DAG: [[SEC00]] = getelementptr {{.+}}ptr [[SEC000:%[^,]+]], i{{.+}} 0, i{{.+}} 0 + // CK19-DAG: [[SEC000]] = getelementptr {{.+}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 0 + + // CK19-USE: call void [[CALL36:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL36:@.+]]() #pragma omp target map(marras[:1][:2][:13]) { @@ -1563,52 +1435,44 @@ } // Region 37 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] 11, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] 11, ptr [[P0]] // // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] - // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], ptr [[P1]] // // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 - // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to [13 x double]** - // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to [13 x double]** - // CK19-USE-DAG: store [13 x double]* [[VAR2:%.+]], [13 x double]** [[CBP2]] - // CK19-USE-DAG: store [13 x double]* [[VAR2]], [13 x double]** [[CP2]] - // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], i64* [[S2]] + // CK19-USE-DAG: store ptr [[VAR2:%.+]], ptr [[BP2]] + // CK19-USE-DAG: store ptr [[VAR2]], ptr [[P2]] + // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], ptr [[S2]] // CK19-USE-DAG: [[CSVAL2]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [13 x double]** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** - // CK19-NOUSE-DAG: store [13 x double]* [[VAR0:%.+]], [13 x double]** [[CBP0]] - // CK19-NOUSE-DAG: store [13 x double]* [[VAR0]], [13 x double]** [[CP0]] - // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[VAR0]], ptr [[P0]] + // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], ptr [[S0]] // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} - // CK19-USE: call void [[CALL37:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}}) + // CK19-USE: call void [[CALL37:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, ptr %{{[^,]+}}) // CK19-NOUSE: call void [[CALL37:@.+]]() #pragma omp target map(mvlaas) { @@ -1618,56 +1482,48 @@ } // Region 38 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] 11, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] 11, ptr [[P0]] // // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] - // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], ptr [[P1]] // // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 - // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to [13 x double]** - // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to [13 x double]** - // CK19-USE-DAG: store [13 x double]* [[VAR2:%.+]], [13 x double]** [[CBP2]] - // CK19-USE-DAG: store [13 x double]* [[SEC2:%.+]], [13 x double]** [[CP2]] - // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], i64* [[S2]] - // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC22:%[^,]+]] + // CK19-USE-DAG: store ptr [[VAR2:%.+]], ptr [[BP2]] + // CK19-USE-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] + // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], ptr [[S2]] + // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}ptr [[VAR2]], i[[Z]] [[SEC22:%[^,]+]] // CK19-USE-DAG: [[SEC22]] = mul nsw i[[Z]] 0, %{{[^,]+}} // CK19-USE-DAG: [[CSVAL2]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [13 x double]** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** - // CK19-NOUSE-DAG: store [13 x double]* [[VAR0:%.+]], [13 x double]** [[CBP0]] - // CK19-NOUSE-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] - // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] - // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[VAR0]], i[[Z]] [[SEC00:%[^,]+]] + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], ptr [[S0]] + // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.+}}ptr [[VAR0]], i[[Z]] [[SEC00:%[^,]+]] // CK19-NOUSE-DAG: [[SEC00]] = mul nsw i[[Z]] 0, %{{[^,]+}} // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} - // CK19-USE: call void [[CALL38:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}}) + // CK19-USE: call void [[CALL38:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, ptr %{{[^,]+}}) // CK19-NOUSE: call void [[CALL38:@.+]]() #pragma omp target map(mvlaas[:]) { @@ -1677,56 +1533,48 @@ } // Region 39 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] 11, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] 11, ptr [[P0]] // // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] - // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], ptr [[P1]] // // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 - // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to [13 x double]** - // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to [13 x double]** - // CK19-USE-DAG: store [13 x double]* [[VAR2:%.+]], [13 x double]** [[CBP2]] - // CK19-USE-DAG: store [13 x double]* [[SEC2:%.+]], [13 x double]** [[CP2]] - // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], i64* [[S2]] - // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC22:%[^,]+]] + // CK19-USE-DAG: store ptr [[VAR2:%.+]], ptr [[BP2]] + // CK19-USE-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] + // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], ptr [[S2]] + // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}ptr [[VAR2]], i[[Z]] [[SEC22:%[^,]+]] // CK19-USE-DAG: [[SEC22]] = mul nsw i[[Z]] 0, %{{[^,]+}} // CK19-USE-DAG: [[CSVAL2]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [13 x double]** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** - // CK19-NOUSE-DAG: store [13 x double]* [[VAR0:%.+]], [13 x double]** [[CBP0]] - // CK19-NOUSE-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] - // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] - // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[VAR0]], i[[Z]] [[SEC00:%[^,]+]] + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], ptr [[S0]] + // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.+}}ptr [[VAR0]], i[[Z]] [[SEC00:%[^,]+]] // CK19-NOUSE-DAG: [[SEC00]] = mul nsw i[[Z]] 0, %{{[^,]+}} // CK19-NOUSE-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} - // CK19-USE: call void [[CALL39:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}}) + // CK19-USE: call void [[CALL39:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, ptr %{{[^,]+}}) // CK19-NOUSE: call void [[CALL39:@.+]]() #pragma omp target map(mvlaas[:][:][:]) { @@ -1736,57 +1584,49 @@ } // Region 40 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] 11, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] 11, ptr [[P0]] // // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] - // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], ptr [[P1]] // // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 - // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to [13 x double]** - // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to [13 x double]** - // CK19-USE-DAG: store [13 x double]* [[VAR2:%.+]], [13 x double]** [[CBP2]] - // CK19-USE-DAG: store [13 x double]* [[SEC2:%.+]], [13 x double]** [[CP2]] - // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], i64* [[S2]] - // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[SEC22:%[^,]+]], i[[Z]] 0 - // CK19-USE-DAG: [[SEC22]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC222:%[^,]+]] + // CK19-USE-DAG: store ptr [[VAR2:%.+]], ptr [[BP2]] + // CK19-USE-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] + // CK19-USE-DAG: store i64 [[CSVAL2:%[^,]+]], ptr [[S2]] + // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}ptr [[SEC22:%[^,]+]], i[[Z]] 0 + // CK19-USE-DAG: [[SEC22]] = getelementptr {{.+}}ptr [[VAR2]], i[[Z]] [[SEC222:%[^,]+]] // CK19-USE-DAG: [[SEC222]] = mul nsw i[[Z]] 1, %{{[^,]+}} // CK19-NOUSE-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] // CK19-NOUSE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-NOUSE-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-NOUSE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [13 x double]** - // CK19-NOUSE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** - // CK19-NOUSE-DAG: store [13 x double]* [[VAR0:%.+]], [13 x double]** [[CBP0]] - // CK19-NOUSE-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] - // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] - // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[SEC00:%[^,]+]], i[[Z]] 0 - // CK19-NOUSE-DAG: [[SEC00]] = getelementptr {{.+}}[13 x double]* [[VAR0]], i[[Z]] [[SEC000:%[^,]+]] + // CK19-NOUSE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NOUSE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NOUSE-DAG: store i64 [[CSVAL0:%[^,]+]], ptr [[S0]] + // CK19-NOUSE-DAG: [[SEC0]] = getelementptr {{.+}}ptr [[SEC00:%[^,]+]], i[[Z]] 0 + // CK19-NOUSE-DAG: [[SEC00]] = getelementptr {{.+}}ptr [[VAR0]], i[[Z]] [[SEC000:%[^,]+]] // CK19-NOUSE-DAG: [[SEC000]] = mul nsw i[[Z]] 1, %{{[^,]+}} - // CK19-USE: call void [[CALL40:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}}) + // CK19-USE: call void [[CALL40:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, ptr %{{[^,]+}}) // CK19-NOUSE: call void [[CALL40:@.+]]() #pragma omp target map(mvlaas[1][:ii][:]) { @@ -1796,49 +1636,41 @@ } // Region 41 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // // CK19-USE-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to i[[Z]]* - // CK19-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CBP0]] - // CK19-USE-DAG: store i[[Z]] 11, i[[Z]]* [[CP0]] + // CK19-USE-DAG: store i[[Z]] 11, ptr [[BP0]] + // CK19-USE-DAG: store i[[Z]] 11, ptr [[P0]] // // CK19-USE-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-USE-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-USE-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to i[[Z]]* - // CK19-USE-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to i[[Z]]* - // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], i[[Z]]* [[CBP1]] - // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], i[[Z]]* [[CP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR1:%.+]], ptr [[BP1]] + // CK19-USE-DAG: store i[[Z]] [[VAR11:%.+]], ptr [[P1]] // // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-USE-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 - // CK19-USE-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to [13 x double]** - // CK19-USE-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to [13 x double]** - // CK19-USE-DAG: store [13 x double]* [[VAR2:%.+]], [13 x double]** [[CBP2]] - // CK19-USE-DAG: store [13 x double]* [[SEC2:%.+]], [13 x double]** [[CP2]] - // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}[13 x double]* [[SEC22:%[^,]+]], i[[Z]] 0 - // CK19-USE-DAG: [[SEC22]] = getelementptr {{.+}}[13 x double]* [[VAR2]], i[[Z]] [[SEC222:%[^,]+]] + // CK19-USE-DAG: store ptr [[VAR2:%.+]], ptr [[BP2]] + // CK19-USE-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] + // CK19-USE-DAG: [[SEC2]] = getelementptr {{.+}}ptr [[SEC22:%[^,]+]], i[[Z]] 0 + // CK19-USE-DAG: [[SEC22]] = getelementptr {{.+}}ptr [[VAR2]], i[[Z]] [[SEC222:%[^,]+]] // CK19-USE-DAG: [[SEC222]] = mul nsw i[[Z]] 0, %{{[^,]+}} // CK19-USE-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-NO-USE-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-NO-USE-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [13 x double]** - // CK19-NO-USE-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** - // CK19-NO-USE-DAG: store [13 x double]* [[VAR0:%.+]], [13 x double]** [[CBP0]] - // CK19-NO-USE-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] - // CK19-NO-USE-DAG: [[SEC0]] = getelementptr {{.+}}[13 x double]* [[SEC00:%[^,]+]], i[[Z]] 0 - // CK19-NO-USE-DAG: [[SEC00]] = getelementptr {{.+}}[13 x double]* [[VAR0]], i[[Z]] [[SEC000:%[^,]+]] + // CK19-NO-USE-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-NO-USE-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-NO-USE-DAG: [[SEC0]] = getelementptr {{.+}}ptr [[SEC00:%[^,]+]], i[[Z]] 0 + // CK19-NO-USE-DAG: [[SEC00]] = getelementptr {{.+}}ptr [[VAR0]], i[[Z]] [[SEC000:%[^,]+]] // CK19-NO-USE-DAG: [[SEC000]] = mul nsw i[[Z]] 0, %{{[^,]+}} - // CK19-USE: call void [[CALL41:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, [13 x double]* %{{[^,]+}}) + // CK19-USE: call void [[CALL41:@.+]](i[[Z]] 11, i[[Z]] %{{[^,]+}}, ptr %{{[^,]+}}) // CK19-NOUSE: call void [[CALL41:@.+]]() #pragma omp target map(mvlaas[:1][:2][:13]) { @@ -1848,49 +1680,43 @@ } // Region 42 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to double**** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to double**** - // CK19-DAG: store double*** [[VAR0:%.+]], double**** [[CBP0]] - // CK19-DAG: store double*** [[SEC0:%.+]], double**** [[CP0]] - // CK19-DAG: [[VAR0]] = load double***, double**** [[PTR:%[^,]+]], - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}double*** [[SEC00:[^,]+]], i{{.+}} 0 - // CK19-DAG: [[SEC00]] = load double***, double**** [[PTR]], + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: [[VAR0]] = load ptr, ptr [[PTR:%[^,]+]], + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[SEC00:[^,]+]], i{{.+}} 0 + // CK19-DAG: [[SEC00]] = load ptr, ptr [[PTR]], // CK19-DAG: [[BP1:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 1 // CK19-DAG: [[P1:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 1 - // CK19-DAG: [[CBP1:%.+]] = bitcast i8** [[BP1]] to double**** - // CK19-DAG: [[CP1:%.+]] = bitcast i8** [[P1]] to double*** - // CK19-DAG: store double*** [[SEC0]], double**** [[CBP1]] - // CK19-DAG: store double** [[SEC1:%.+]], double*** [[CP1]] - // CK19-DAG: [[SEC1]] = getelementptr {{.*}}double** [[SEC11:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC11]] = load double**, double*** [[SEC111:%[^,]+]], - // CK19-DAG: [[SEC111]] = getelementptr {{.*}}double*** [[SEC1111:[^,]+]], i{{.+}} 0 - // CK19-DAG: [[SEC1111]] = load double***, double**** [[PTR]], + // CK19-DAG: store ptr [[SEC0]], ptr [[BP1]] + // CK19-DAG: store ptr [[SEC1:%.+]], ptr [[P1]] + // CK19-DAG: [[SEC1]] = getelementptr {{.*}}ptr [[SEC11:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[SEC11]] = load ptr, ptr [[SEC111:%[^,]+]], + // CK19-DAG: [[SEC111]] = getelementptr {{.*}}ptr [[SEC1111:[^,]+]], i{{.+}} 0 + // CK19-DAG: [[SEC1111]] = load ptr, ptr [[PTR]], // CK19-DAG: [[BP2:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 2 // CK19-DAG: [[P2:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 2 - // CK19-DAG: [[CBP2:%.+]] = bitcast i8** [[BP2]] to double*** - // CK19-DAG: [[CP2:%.+]] = bitcast i8** [[P2]] to double** - // CK19-DAG: store double** [[SEC1]], double*** [[CBP2]] - // CK19-DAG: store double* [[SEC2:%.+]], double** [[CP2]] - // CK19-DAG: [[SEC2]] = getelementptr {{.*}}double* [[SEC22:[^,]+]], i{{.+}} 0 - // CK19-DAG: [[SEC22]] = load double*, double** [[SEC222:%[^,]+]], - // CK19-DAG: [[SEC222]] = getelementptr {{.*}}double** [[SEC2222:[^,]+]], i{{.+}} 2 - // CK19-DAG: [[SEC2222]] = load double**, double*** [[SEC22222:%[^,]+]], - // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}double*** [[SEC222222:[^,]+]], i{{.+}} 0 - // CK19-DAG: [[SEC222222]] = load double***, double**** [[PTR]], - - // CK19-USE: call void [[CALL42:@.+]](double*** {{[^,]+}}) + // CK19-DAG: store ptr [[SEC1]], ptr [[BP2]] + // CK19-DAG: store ptr [[SEC2:%.+]], ptr [[P2]] + // CK19-DAG: [[SEC2]] = getelementptr {{.*}}ptr [[SEC22:[^,]+]], i{{.+}} 0 + // CK19-DAG: [[SEC22]] = load ptr, ptr [[SEC222:%[^,]+]], + // CK19-DAG: [[SEC222]] = getelementptr {{.*}}ptr [[SEC2222:[^,]+]], i{{.+}} 2 + // CK19-DAG: [[SEC2222]] = load ptr, ptr [[SEC22222:%[^,]+]], + // CK19-DAG: [[SEC22222]] = getelementptr {{.*}}ptr [[SEC222222:[^,]+]], i{{.+}} 0 + // CK19-DAG: [[SEC222222]] = load ptr, ptr [[PTR]], + + // CK19-USE: call void [[CALL42:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL42:@.+]]() #pragma omp target map(mptras[:1][2][:13]) { @@ -1900,13 +1726,13 @@ } // Region 43 - the memory is not contiguous for this map - will map the whole last dimension. - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK19-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK19-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] @@ -1915,16 +1741,14 @@ // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [11 x [12 x [13 x double]]]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to [13 x double]** - // CK19-DAG: store [11 x [12 x [13 x double]]]* [[VAR0:%.+]], [11 x [12 x [13 x double]]]** [[CBP0]] - // CK19-DAG: store [13 x double]* [[SEC0:%.+]], [13 x double]** [[CP0]] - // CK19-DAG: store i64 [[CSVAL0:%[^,]+]], i64* [[S0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.+}}[12 x [13 x double]]* [[SEC00:%[^,]+]], i[[Z]] 0, i[[Z]] 0 - // CK19-DAG: [[SEC00]] = getelementptr {{.+}}[11 x [12 x [13 x double]]]* [[VAR0]], i[[Z]] 0, i[[Z]] 1 + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%.+]], ptr [[P0]] + // CK19-DAG: store i64 [[CSVAL0:%[^,]+]], ptr [[S0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.+}}ptr [[SEC00:%[^,]+]], i[[Z]] 0, i[[Z]] 0 + // CK19-DAG: [[SEC00]] = getelementptr {{.+}}ptr [[VAR0]], i[[Z]] 0, i[[Z]] 1 // CK19-DAG: [[CSVAL0]] = {{mul nuw i64 %[^,]+, 104|sext i32 .+ to i64}} - // CK19-USE: call void [[CALL43:@.+]]([11 x [12 x [13 x double]]]* {{[^,]+}}) + // CK19-USE: call void [[CALL43:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL43:@.+]]() #pragma omp target map(marras[1][:ii][1:]) { @@ -1934,23 +1758,21 @@ } // Region 44 - // CK19-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK19-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 [[DEVICE:.+]], i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK19-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK19-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK19-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK19-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK19-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK19-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK19-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK19-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK19-DAG: [[BP0:%.+]] = getelementptr inbounds {{.+}}[[BP]], i{{.+}} 0, i{{.+}} 0 // CK19-DAG: [[P0:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 0 - // CK19-DAG: [[CBP0:%.+]] = bitcast i8** [[BP0]] to [100 x i32]** - // CK19-DAG: [[CP0:%.+]] = bitcast i8** [[P0]] to i32** - // CK19-DAG: store [100 x i32]* [[VAR0:%.+]], [100 x i32]** [[CBP0]] - // CK19-DAG: store i32* [[SEC0:%[^,]+]], i32** [[CP0]] - // CK19-DAG: [[SEC0]] = getelementptr {{.*}}[100 x i32]* [[VAR0]], i{{.+}} 0, i{{.+}} 20 + // CK19-DAG: store ptr [[VAR0:%.+]], ptr [[BP0]] + // CK19-DAG: store ptr [[SEC0:%[^,]+]], ptr [[P0]] + // CK19-DAG: [[SEC0]] = getelementptr {{.*}}ptr [[VAR0]], i{{.+}} 0, i{{.+}} 20 - // CK19-USE: call void [[CALL44:@.+]]([100 x i32]* {{[^,]+}}) + // CK19-USE: call void [[CALL44:@.+]](ptr {{[^,]+}}) // CK19-NOUSE: call void [[CALL44:@.+]]() #pragma omp target map(from:arra[20:]) { diff --git a/clang/test/OpenMP/target_map_codegen_18a.cpp b/clang/test/OpenMP/target_map_codegen_18a.cpp --- a/clang/test/OpenMP/target_map_codegen_18a.cpp +++ b/clang/test/OpenMP/target_map_codegen_18a.cpp @@ -8,15 +8,15 @@ // RUN: cp %S/target_map_codegen_18.inc %t.inc ///==========================================================================/// -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -DUSE -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -DUSE -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -verify -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -verify -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -DUSE -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc #endif diff --git a/clang/test/OpenMP/target_map_codegen_18b.cpp b/clang/test/OpenMP/target_map_codegen_18b.cpp --- a/clang/test/OpenMP/target_map_codegen_18b.cpp +++ b/clang/test/OpenMP/target_map_codegen_18b.cpp @@ -7,15 +7,15 @@ // its full name in every FileCheck command. // RUN: cp %S/target_map_codegen_18.inc %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -verify -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -verify -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -DUSE -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -DUSE -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -DUSE -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-USE %t.inc #endif diff --git a/clang/test/OpenMP/target_map_codegen_18c.cpp b/clang/test/OpenMP/target_map_codegen_18c.cpp --- a/clang/test/OpenMP/target_map_codegen_18c.cpp +++ b/clang/test/OpenMP/target_map_codegen_18c.cpp @@ -7,22 +7,22 @@ // its full name in every FileCheck command. // RUN: cp %S/target_map_codegen_18.inc %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -verify -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -verify -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -DCK19 -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -verify -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -DUSE -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -verify -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc +// RUN: %clang_cc1 -DUSE -DCK19 -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -DUSE -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -verify -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -verify -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -verify -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -verify -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -fopenmp-version=45 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc #endif diff --git a/clang/test/OpenMP/target_map_codegen_18d.cpp b/clang/test/OpenMP/target_map_codegen_18d.cpp --- a/clang/test/OpenMP/target_map_codegen_18d.cpp +++ b/clang/test/OpenMP/target_map_codegen_18d.cpp @@ -7,22 +7,22 @@ // its full name in every FileCheck command. // RUN: cp %S/target_map_codegen_18.inc %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -verify -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -verify -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -fopenmp-version=45 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-64,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc +// RUN: %clang_cc1 -DCK19 -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefixes=CK19,CK19-32,CK19-NOUSE %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -verify -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -verify -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc -// RUN: %clang_cc1 -no-opaque-pointers -DCK19 -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc +// RUN: %clang_cc1 -DCK19 -verify -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc +// RUN: %clang_cc1 -DCK19 -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp-simd -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc +// RUN: %clang_cc1 -DCK19 -verify -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc +// RUN: %clang_cc1 -DCK19 -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp-simd -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix SIMD-ONLY18 %t.inc #endif diff --git a/clang/test/OpenMP/target_map_codegen_34.cpp b/clang/test/OpenMP/target_map_codegen_34.cpp --- a/clang/test/OpenMP/target_map_codegen_34.cpp +++ b/clang/test/OpenMP/target_map_codegen_34.cpp @@ -3,19 +3,19 @@ #define HEADER ///==========================================================================/// -// RUN: %clang_cc1 -no-opaque-pointers -DCK34 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK34 --check-prefix CK34-64 -// RUN: %clang_cc1 -no-opaque-pointers -DCK34 -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CK34 --check-prefix CK34-64 -// RUN: %clang_cc1 -no-opaque-pointers -DCK34 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK34 --check-prefix CK34-32 -// RUN: %clang_cc1 -no-opaque-pointers -DCK34 -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CK34 --check-prefix CK34-32 - -// RUN: %clang_cc1 -no-opaque-pointers -DCK34 -verify -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY32 %s -// RUN: %clang_cc1 -no-opaque-pointers -DCK34 -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY32 %s -// RUN: %clang_cc1 -no-opaque-pointers -DCK34 -verify -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY32 %s -// RUN: %clang_cc1 -no-opaque-pointers -DCK34 -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s -// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY32 %s +// RUN: %clang_cc1 -DCK34 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK34 --check-prefix CK34-64 +// RUN: %clang_cc1 -DCK34 -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CK34 --check-prefix CK34-64 +// RUN: %clang_cc1 -DCK34 -verify -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s --check-prefix CK34 --check-prefix CK34-32 +// RUN: %clang_cc1 -DCK34 -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CK34 --check-prefix CK34-32 + +// RUN: %clang_cc1 -DCK34 -verify -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY32 %s +// RUN: %clang_cc1 -DCK34 -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY32 %s +// RUN: %clang_cc1 -DCK34 -verify -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY32 %s +// RUN: %clang_cc1 -DCK34 -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 -triple i386-unknown-unknown -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -fopenmp-targets=i386-pc-linux-gnu -x c++ -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY32 %s // SIMD-ONLY32-NOT: {{__kmpc|__tgt}} #ifdef CK34 @@ -49,19 +49,18 @@ void default_mapper() { S s; - // CK34-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 -1, i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK34-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK34-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK34-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK34-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK34-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK34-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK34-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK34-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK34-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK34-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK34-DAG: [[MARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 7 - // CK34-DAG: store i8** [[MFGEP:%.+]], i8*** [[MARG]] + // CK34-DAG: store ptr [[MF:%.+]], ptr [[MARG]] // CK34-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK34-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK34-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] - // CK34-DAG: [[MFGEP]] = bitcast [4 x i8*]* [[MF:%.+]] to i8** // pass TARGET_PARAM {&s, &s, ((void*)(&s+1)-(void*)&s)} @@ -70,21 +69,16 @@ // CK34-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 // CK34-DAG: [[MF0:%.+]] = getelementptr inbounds {{.+}}[[MF]], i{{.+}} 0, i{{.+}} 0 - // CK34-DAG: [[BPC0:%.+]] = bitcast i8** [[BP0]] to %class.S** - // CK34-DAG: [[PC0:%.+]] = bitcast i8** [[P0]] to %class.S** + // CK34-DAG: store ptr [[S_ADDR:%.+]], ptr [[BP0]], + // CK34-DAG: store ptr [[S_ADDR]], ptr [[P0]], + // CK34-DAG: store i64 [[S_SIZE:%.+]], ptr [[S0]], + // CK34-DAG: store ptr null, ptr [[MF0]], - // CK34-DAG: store %class.S* [[S_ADDR:%.+]], %class.S** [[BPC0]], - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[PC0]], - // CK34-DAG: store i64 [[S_SIZE:%.+]], i64* [[S0]], - // CK34-DAG: store i8* null, i8** [[MF0]], - - // CK34-DAG: [[S_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64) + // CK34-DAG: [[S_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) // CK34-DAG: [[SZ]] = sub i64 [[S_1_INTPTR:%.+]], [[S_INTPTR:%.+]] - // CK34-DAG: [[S_1_INTPTR]] = ptrtoint i8* [[S_1_VOID:%.+]] to i64 - // CK34-DAG: [[S_INTPTR]] = ptrtoint i8* [[S_VOID:%.+]] to i64 - // CK34-DAG: [[S_1_VOID]] = bitcast %class.S* [[S_1:%.+]] to i8* - // CK34-DAG: [[S_VOID]] = bitcast %class.S* [[S_ADDR]] to i8* - // CK34-DAG: [[S_1]] = getelementptr %class.S, %class.S* [[S_ADDR]], i32 1 + // CK34-DAG: [[S_1_INTPTR]] = ptrtoint ptr [[S_1:%.+]] to i64 + // CK34-DAG: [[S_INTPTR]] = ptrtoint ptr [[S_ADDR]] to i64 + // CK34-DAG: [[S_1]] = getelementptr %class.S, ptr [[S_ADDR]], i32 1 // pass MEMBER_OF_1 | TO {&s, &s, ((void*)(&s.a+1)-(void*)&s)} to copy the data of s.a. @@ -93,22 +87,17 @@ // CK34-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 // CK34-DAG: [[MF1:%.+]] = getelementptr inbounds {{.+}}[[MF]], i{{.+}} 0, i{{.+}} 1 - // CK34-DAG: [[BPC1:%.+]] = bitcast i8** [[BP1]] to %class.S** - // CK34-DAG: [[PC1:%.+]] = bitcast i8** [[P1]] to %class.S** - - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[BPC1]], - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[PC1]], - // CK34-DAG: store i64 [[A_SIZE:%.+]], i64* [[S1]], - // CK34-DAG: store i8* null, i8** [[MF1]], + // CK34-DAG: store ptr [[S_ADDR]], ptr [[BP1]], + // CK34-DAG: store ptr [[S_ADDR]], ptr [[P1]], + // CK34-DAG: store i64 [[A_SIZE:%.+]], ptr [[S1]], + // CK34-DAG: store ptr null, ptr [[MF1]], - // CK34-DAG: [[A_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64) + // CK34-DAG: [[A_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) // CK34-DAG: [[SZ]] = sub i64 [[C_BEGIN_INTPTR:%.+]], [[S_INTPTR:%.+]] - // CK34-DAG: [[S_INTPTR]] = ptrtoint i8* [[S_VOID:%.+]] to i64 - // CK34-DAG: [[C_BEGIN_INTPTR]] = ptrtoint i8* [[C_BEGIN_VOID:%.+]] to i64 - // CK34-DAG: [[S_VOID]] = bitcast %class.S* [[S_ADDR]] to i8* - // CK34-DAG: [[C_BEGIN_VOID]] = bitcast %class.C* [[C_ADDR:%.+]] to i8* - // CK34-64-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, %class.S* [[S_ADDR]], i32 0, i32 2 - // CK34-32-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, %class.S* [[S_ADDR]], i32 0, i32 1 + // CK34-DAG: [[S_INTPTR]] = ptrtoint ptr [[S_ADDR]] to i64 + // CK34-DAG: [[C_BEGIN_INTPTR]] = ptrtoint ptr [[C_ADDR:%.+]] to i64 + // CK34-64-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, ptr [[S_ADDR]], i32 0, i32 2 + // CK34-32-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, ptr [[S_ADDR]], i32 0, i32 1 // pass MEMBER_OF_1 | TO {&s, &s.c+1, ((void*)(&s)+31+1-(void*)(&s.c+1))} to copy the data of s.b. @@ -117,25 +106,20 @@ // CK34-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 // CK34-DAG: [[MF2:%.+]] = getelementptr inbounds {{.+}}[[MF]], i{{.+}} 0, i{{.+}} 2 - // CK34-DAG: [[BPC2:%.+]] = bitcast i8** [[BP2]] to %class.S** - // CK34-DAG: [[PC2:%.+]] = bitcast i8** [[P2]] to %class.C** + // CK34-DAG: store ptr [[S_ADDR]], ptr [[BP2]], + // CK34-DAG: store ptr [[C_END:%.+]], ptr [[P2]], + // CK34-DAG: store i64 [[B_SIZE:%.+]], ptr [[S2]], + // CK34-DAG: store ptr null, ptr [[MF2]], - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[BPC2]], - // CK34-DAG: store %class.C* [[C_END:%.+]], %class.C** [[PC2]], - // CK34-DAG: store i64 [[B_SIZE:%.+]], i64* [[S2]], - // CK34-DAG: store i8* null, i8** [[MF2]], + // CK34-DAG: [[C_END]] = getelementptr %class.C, ptr [[C_ADDR]], i{{.+}} 1 - // CK34-DAG: [[C_END]] = getelementptr %class.C, %class.C* [[C_ADDR]], i{{.+}} 1 - - // CK34-DAG: [[B_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64) + // CK34-DAG: [[B_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) // CK34-DAG: [[SZ]] = sub i64 [[S_END_INTPTR:%.+]], [[C_END_INTPTR:%.+]] - // CK34-DAG: [[C_END_INTPTR]] = ptrtoint i8* [[C_END_VOID:%.+]] to i64 - // CK34-DAG: [[S_END_INTPTR]] = ptrtoint i8* [[S_END_VOID:%.+]] to i64 - // CK34-DAG: [[C_END_VOID]] = bitcast %class.C* [[C_END]] to i8* - // CK34-DAG: [[S_END_VOID]] = getelementptr i8, i8* [[S_LAST:%.+]], i{{.+}} 1 - // CK34-64-DAG: [[S_LAST]] = getelementptr i8, i8* [[S_VOID:%.+]], i64 31 - // CK34-32-DAG: [[S_LAST]] = getelementptr i8, i8* [[S_VOID:%.+]], i32 15 - // CK34-DAG: [[S_VOID]] = bitcast %class.S* [[S_ADDR]] to i8* + // CK34-DAG: [[C_END_INTPTR]] = ptrtoint ptr [[C_END]] to i64 + // CK34-DAG: [[S_END_INTPTR]] = ptrtoint ptr [[S_END_VOID:%.+]] to i64 + // CK34-DAG: [[S_END_VOID]] = getelementptr i8, ptr [[S_LAST:%.+]], i{{.+}} 1 + // CK34-64-DAG: [[S_LAST]] = getelementptr i8, ptr [[S_ADDR]], i64 31 + // CK34-32-DAG: [[S_LAST]] = getelementptr i8, ptr [[S_ADDR]], i32 15 // pass MEMBER_OF_1 | TO | IMPLICIT | MAPPER {&s, &s.c, 16} to copy the data of s.c. @@ -143,34 +127,30 @@ // CK34-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3 // CK34-DAG: [[MF3:%.+]] = getelementptr inbounds {{.+}}[[MF]], i{{.+}} 0, i{{.+}} 3 - // CK34-DAG: [[BPC3:%.+]] = bitcast i8** [[BP3]] to %class.S** - // CK34-DAG: [[PC3:%.+]] = bitcast i8** [[P3]] to %class.C** - - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[BPC3]], - // CK34-DAG: store %class.C* [[C_ADDR:%.+]], %class.C** [[PC3]], - // CK34-DAG: store i8* bitcast (void (i8*, i8*, i8*, i64, i64, i8*)* [[C_DEFAULT_MAPPER:@.+]] to i8*), i8** [[MF3]], + // CK34-DAG: store ptr [[S_ADDR]], ptr [[BP3]], + // CK34-DAG: store ptr [[C_ADDR:%.+]], ptr [[P3]], + // CK34-DAG: store ptr [[C_DEFAULT_MAPPER:@.+]], ptr [[MF3]], - // CK34-64-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, %class.S* [[S_ADDR]], i32 0, i32 2 - // CK34-32-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, %class.S* [[S_ADDR]], i32 0, i32 1 + // CK34-64-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, ptr [[S_ADDR]], i32 0, i32 2 + // CK34-32-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, ptr [[S_ADDR]], i32 0, i32 1 #pragma omp target map(to: s) s.foo(); // CK34 : call void - // CK34-DAG: call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 -1, i32 -1, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* [[ARGS:%.+]]) + // CK34-DAG: call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 -1, i32 0, ptr @.{{.+}}.region_id, ptr [[ARGS:%.+]]) // CK34-DAG: [[BPARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 2 - // CK34-DAG: store i8** [[BPGEP:%.+]], i8*** [[BPARG]] + // CK34-DAG: store ptr [[BPGEP:%.+]], ptr [[BPARG]] // CK34-DAG: [[PARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 3 - // CK34-DAG: store i8** [[PGEP:%.+]], i8*** [[PARG]] + // CK34-DAG: store ptr [[PGEP:%.+]], ptr [[PARG]] // CK34-DAG: [[SARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 4 - // CK34-DAG: store i64* [[SIZES:%.+]], i64** [[SARG]] + // CK34-DAG: store ptr [[SIZES:%.+]], ptr [[SARG]] // CK34-DAG: [[MARG:%.+]] = getelementptr inbounds {{.+}}[[ARGS]], i32 0, i32 7 - // CK34-DAG: store i8** [[MFGEP:%.+]], i8*** [[MARG]] + // CK34-DAG: store ptr [[MF:%.+]], ptr [[MARG]] // CK34-DAG: [[BPGEP]] = getelementptr inbounds {{.+}}[[BP:%[^,]+]] // CK34-DAG: [[PGEP]] = getelementptr inbounds {{.+}}[[P:%[^,]+]] // CK34-DAG: [[SIZES]] = getelementptr inbounds {{.+}}[[S:%[^,]+]] - // CK34-DAG: [[MFGEP]] = bitcast [4 x i8*]* [[MF:%.+]] to i8** // pass TARGET_PARAM {&s, &s, ((void*)(&s+1)-(void*)&s)} @@ -179,21 +159,16 @@ // CK34-DAG: [[S0:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 0 // CK34-DAG: [[MF0:%.+]] = getelementptr inbounds {{.+}}[[MF]], i{{.+}} 0, i{{.+}} 0 - // CK34-DAG: [[BPC0:%.+]] = bitcast i8** [[BP0]] to %class.S** - // CK34-DAG: [[PC0:%.+]] = bitcast i8** [[P0]] to %class.S** + // CK34-DAG: store ptr [[S_ADDR]], ptr [[BP0]], + // CK34-DAG: store ptr [[S_ADDR]], ptr [[P0]], + // CK34-DAG: store i64 [[S_SIZE:%.+]], ptr [[S0]], + // CK34-DAG: store ptr null, ptr [[MF0]], - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[BPC0]], - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[PC0]], - // CK34-DAG: store i64 [[S_SIZE:%.+]], i64* [[S0]], - // CK34-DAG: store i8* null, i8** [[MF0]], - - // CK34-DAG: [[S_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64) + // CK34-DAG: [[S_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) // CK34-DAG: [[SZ]] = sub i64 [[S_1_INTPTR:%.+]], [[S_INTPTR:%.+]] - // CK34-DAG: [[S_1_INTPTR]] = ptrtoint i8* [[S_1_VOID:%.+]] to i64 - // CK34-DAG: [[S_INTPTR]] = ptrtoint i8* [[S_VOID:%.+]] to i64 - // CK34-DAG: [[S_1_VOID]] = bitcast %class.S* [[S_1:%.+]] to i8* - // CK34-DAG: [[S_VOID]] = bitcast %class.S* [[S_ADDR]] to i8* - // CK34-DAG: [[S_1]] = getelementptr %class.S, %class.S* [[S_ADDR]], i32 1 + // CK34-DAG: [[S_1_INTPTR]] = ptrtoint ptr [[S_1:%.+]] to i64 + // CK34-DAG: [[S_INTPTR]] = ptrtoint ptr [[S_ADDR]] to i64 + // CK34-DAG: [[S_1]] = getelementptr %class.S, ptr [[S_ADDR]], i32 1 // pass MEMBER_OF_1 | FROM {&s, &s, ((void*)(&s.a+1)-(void*)&s)} to copy the data of s.a. @@ -202,22 +177,17 @@ // CK34-DAG: [[S1:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 1 // CK34-DAG: [[MF1:%.+]] = getelementptr inbounds {{.+}}[[MF]], i{{.+}} 0, i{{.+}} 1 - // CK34-DAG: [[BPC1:%.+]] = bitcast i8** [[BP1]] to %class.S** - // CK34-DAG: [[PC1:%.+]] = bitcast i8** [[P1]] to %class.S** - - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[BPC1]], - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[PC1]], - // CK34-DAG: store i64 [[A_SIZE:%.+]], i64* [[S1]], - // CK34-DAG: store i8* null, i8** [[MF1]], + // CK34-DAG: store ptr [[S_ADDR]], ptr [[BP1]], + // CK34-DAG: store ptr [[S_ADDR]], ptr [[P1]], + // CK34-DAG: store i64 [[A_SIZE:%.+]], ptr [[S1]], + // CK34-DAG: store ptr null, ptr [[MF1]], - // CK34-DAG: [[A_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64) + // CK34-DAG: [[A_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) // CK34-DAG: [[SZ]] = sub i64 [[C_BEGIN_INTPTR:%.+]], [[S_INTPTR:%.+]] - // CK34-DAG: [[S_INTPTR]] = ptrtoint i8* [[S_VOID:%.+]] to i64 - // CK34-DAG: [[C_BEGIN_INTPTR]] = ptrtoint i8* [[C_BEGIN_VOID:%.+]] to i64 - // CK34-DAG: [[S_VOID]] = bitcast %class.S* [[S_ADDR]] to i8* - // CK34-DAG: [[C_BEGIN_VOID]] = bitcast %class.C* [[C_ADDR:%.+]] to i8* - // CK34-64-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, %class.S* [[S_ADDR]], i32 0, i32 2 - // CK34-32-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, %class.S* [[S_ADDR]], i32 0, i32 1 + // CK34-DAG: [[S_INTPTR]] = ptrtoint ptr [[S_ADDR]] to i64 + // CK34-DAG: [[C_BEGIN_INTPTR]] = ptrtoint ptr [[C_ADDR:%.+]] to i64 + // CK34-64-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, ptr [[S_ADDR]], i32 0, i32 2 + // CK34-32-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, ptr [[S_ADDR]], i32 0, i32 1 // pass MEMBER_OF_1 | FROM {&s, &s.c+1, ((void*)(&s)+31+1-(void*)(&s.c+1))} to copy the data of s.b. @@ -226,25 +196,20 @@ // CK34-DAG: [[S2:%.+]] = getelementptr inbounds {{.+}}[[S]], i{{.+}} 0, i{{.+}} 2 // CK34-DAG: [[MF2:%.+]] = getelementptr inbounds {{.+}}[[MF]], i{{.+}} 0, i{{.+}} 2 - // CK34-DAG: [[BPC2:%.+]] = bitcast i8** [[BP2]] to %class.S** - // CK34-DAG: [[PC2:%.+]] = bitcast i8** [[P2]] to %class.C** + // CK34-DAG: store ptr [[S_ADDR]], ptr [[BP2]], + // CK34-DAG: store ptr [[C_END:%.+]], ptr [[P2]], + // CK34-DAG: store i64 [[B_SIZE:%.+]], ptr [[S2]], + // CK34-DAG: store ptr null, ptr [[MF2]], - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[BPC2]], - // CK34-DAG: store %class.C* [[C_END:%.+]], %class.C** [[PC2]], - // CK34-DAG: store i64 [[B_SIZE:%.+]], i64* [[S2]], - // CK34-DAG: store i8* null, i8** [[MF2]], + // CK34-DAG: [[C_END]] = getelementptr %class.C, ptr [[C_ADDR]], i{{.+}} 1 - // CK34-DAG: [[C_END]] = getelementptr %class.C, %class.C* [[C_ADDR]], i{{.+}} 1 - - // CK34-DAG: [[B_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64) + // CK34-DAG: [[B_SIZE]] = sdiv exact i64 [[SZ:%.+]], ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64) // CK34-DAG: [[SZ]] = sub i64 [[S_END_INTPTR:%.+]], [[C_END_INTPTR:%.+]] - // CK34-DAG: [[C_END_INTPTR]] = ptrtoint i8* [[C_END_VOID:%.+]] to i64 - // CK34-DAG: [[S_END_INTPTR]] = ptrtoint i8* [[S_END_VOID:%.+]] to i64 - // CK34-DAG: [[C_END_VOID]] = bitcast %class.C* [[C_END]] to i8* - // CK34-DAG: [[S_END_VOID]] = getelementptr i8, i8* [[S_LAST:%.+]], i{{.+}} 1 - // CK34-64-DAG: [[S_LAST]] = getelementptr i8, i8* [[S_VOID:%.+]], i64 31 - // CK34-32-DAG: [[S_LAST]] = getelementptr i8, i8* [[S_VOID:%.+]], i32 15 - // CK34-DAG: [[S_VOID]] = bitcast %class.S* [[S_ADDR]] to i8* + // CK34-DAG: [[C_END_INTPTR]] = ptrtoint ptr [[C_END]] to i64 + // CK34-DAG: [[S_END_INTPTR]] = ptrtoint ptr [[S_END_VOID:%.+]] to i64 + // CK34-DAG: [[S_END_VOID]] = getelementptr i8, ptr [[S_LAST:%.+]], i{{.+}} 1 + // CK34-64-DAG: [[S_LAST]] = getelementptr i8, ptr [[S_ADDR]], i64 31 + // CK34-32-DAG: [[S_LAST]] = getelementptr i8, ptr [[S_ADDR]], i32 15 // pass MEMBER_OF_1 | FROM | IMPLICIT | MAPPER {&s, &s.c, 16} to copy the data of s.c. @@ -252,15 +217,12 @@ // CK34-DAG: [[P3:%.+]] = getelementptr inbounds {{.+}}[[P]], i{{.+}} 0, i{{.+}} 3 // CK34-DAG: [[MF3:%.+]] = getelementptr inbounds {{.+}}[[MF]], i{{.+}} 0, i{{.+}} 3 - // CK34-DAG: [[BPC3:%.+]] = bitcast i8** [[BP3]] to %class.S** - // CK34-DAG: [[PC3:%.+]] = bitcast i8** [[P3]] to %class.C** - - // CK34-DAG: store %class.S* [[S_ADDR]], %class.S** [[BPC3]], - // CK34-DAG: store %class.C* [[C_ADDR:%.+]], %class.C** [[PC3]], - // CK34-DAG: store i8* bitcast (void (i8*, i8*, i8*, i64, i64, i8*)* [[C_DEFAULT_MAPPER]] to i8*), i8** [[MF3]], + // CK34-DAG: store ptr [[S_ADDR]], ptr [[BP3]], + // CK34-DAG: store ptr [[C_ADDR:%.+]], ptr [[P3]], + // CK34-DAG: store ptr [[C_DEFAULT_MAPPER]], ptr [[MF3]], - // CK34-64-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, %class.S* [[S_ADDR]], i32 0, i32 2 - // CK34-32-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, %class.S* [[S_ADDR]], i32 0, i32 1 + // CK34-64-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, ptr [[S_ADDR]], i32 0, i32 2 + // CK34-32-DAG: [[C_ADDR]] = getelementptr inbounds %class.S, ptr [[S_ADDR]], i32 0, i32 1 #pragma omp target map(from: s) s.foo();