mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-26 13:06:06 +00:00
16a385ba21
We already created a versioned `__tgt_kernel_arguments` struct but it
was only briefly used and its content was passed in isolation anyway.
This makes it hard to add more information in the future. With this
patch we fully embrace the struct as means to pass information from the
compiler to the plugin as part of a kernel launch.
The patch also extends and renames the struct, bumping the version
number to 2. Version 1 entries are auto-upgraded. This is in preparation
for "bare" kernel launches, per kernel dynamic shared memory, CUDA/HIP
lowering, etc.
The `__tgt_target_kernel_nowait` interface was deprecated as it was
unused. Once we actually implement support for something like that, we
can add an appropriate API.
Note: Only plugins with the `launch_kernel` interface are now supported.
That means that a new clang won't be able to use an old runtime.
An old clang can still use the new runtime since the libomptarget
interface did not change.
Differential Revision: https://reviews.llvm.org/D141232
1425 lines
127 KiB
C++
1425 lines
127 KiB
C++
// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --check-globals --include-generated-funcs --replace-value-regex "__omp_offloading_[0-9a-z]+_[0-9a-z]+" --prefix-filecheck-ir-name _ --global-value-regex ".offload_maptypes.*" ".offload_sizes.*" --global-hex-value-regex ".offload_maptypes.*"
|
|
// expected-no-diagnostics
|
|
#ifndef HEADER
|
|
#define HEADER
|
|
|
|
//--------------------------------------------------
|
|
// With -DUSE.
|
|
//--------------------------------------------------
|
|
|
|
// powerpc64le-ibm-linux-gnu
|
|
|
|
// RUN: %clang_cc1 -no-opaque-pointers -DUSE -verify -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ \
|
|
// RUN: -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | \
|
|
// RUN: FileCheck %s --check-prefixes=CHECK-USE-PPC64LE
|
|
// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 \
|
|
// RUN: -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
|
|
// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ \
|
|
// RUN: -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t \
|
|
// RUN: -verify %s -emit-llvm -o - | \
|
|
// RUN: FileCheck %s --check-prefixes=CHECK-USE-PPC64LE
|
|
|
|
// i386-pc-linux-gnu
|
|
|
|
// RUN: %clang_cc1 -no-opaque-pointers -DUSE -verify -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=i386-pc-linux-gnu -x c++ \
|
|
// RUN: -triple i386-unknown-unknown -emit-llvm %s -o - | \
|
|
// RUN: FileCheck %s --check-prefixes=CHECK-USE-I386
|
|
// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 \
|
|
// RUN: -triple i386-unknown-unknown -emit-pch -o %t %s
|
|
// RUN: %clang_cc1 -no-opaque-pointers -DUSE -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=i386-pc-linux-gnu -x c++ \
|
|
// RUN: -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s \
|
|
// RUN: -emit-llvm -o - | \
|
|
// RUN: FileCheck %s --check-prefixes=CHECK-USE-I386
|
|
|
|
//--------------------------------------------------
|
|
// Without -DUSE.
|
|
//--------------------------------------------------
|
|
|
|
// powerpc64le-ibm-linux-gnu
|
|
|
|
// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ \
|
|
// RUN: -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | \
|
|
// RUN: FileCheck %s --check-prefixes=CHECK-NOUSE-PPC64LE
|
|
// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ -std=c++11 \
|
|
// RUN: -triple powerpc64le-unknown-unknown -emit-pch -o %t %s
|
|
// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=powerpc64le-ibm-linux-gnu -x c++ \
|
|
// RUN: -triple powerpc64le-unknown-unknown -std=c++11 -include-pch %t \
|
|
// RUN: -verify %s -emit-llvm -o - | \
|
|
// RUN: FileCheck %s --check-prefixes=CHECK-NOUSE-PPC64LE
|
|
|
|
// i386-pc-linux-gnu
|
|
|
|
// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=i386-pc-linux-gnu -x c++ \
|
|
// RUN: -triple i386-unknown-unknown -emit-llvm %s -o - | \
|
|
// RUN: FileCheck %s --check-prefixes=CHECK-NOUSE-I386
|
|
// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=i386-pc-linux-gnu -x c++ -std=c++11 \
|
|
// RUN: -triple i386-unknown-unknown -emit-pch -o %t %s
|
|
// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -fopenmp-extensions \
|
|
// RUN: -fopenmp-targets=i386-pc-linux-gnu -x c++ \
|
|
// RUN: -triple i386-unknown-unknown -std=c++11 -include-pch %t -verify %s \
|
|
// RUN: -emit-llvm -o - | \
|
|
// RUN: FileCheck %s --check-prefixes=CHECK-NOUSE-I386
|
|
|
|
// Map flags used in @.offload_maptypes* below:
|
|
// TO = 0x1
|
|
// FROM = 0x2
|
|
// ALWAYS = 0x4
|
|
// TARGET_PARAM = 0x20
|
|
// CLOSE = 0x400
|
|
// OMPX_HOLD = 0x2000
|
|
// MEMBER_OF_1 = 0x1000000000000
|
|
// MEMBER_OF_5 = 0x5000000000000
|
|
|
|
//.
|
|
// CHECK-USE-PPC64LE: @.offload_sizes = private unnamed_addr constant [7 x i64] [i64 0, i64 4, i64 4, i64 4, i64 0, i64 4, i64 4]
|
|
// CHECK-USE-PPC64LE: @.offload_maptypes = private unnamed_addr constant [7 x i64] [i64 [[#0x2020]], i64 [[#0x1000000002003]], i64 [[#0x1000000002003]], i64 [[#0x2023]], i64 [[#0x2020]], i64 [[#0x5000000002003]], i64 [[#0x5000000002003]]]
|
|
// CHECK-USE-PPC64LE: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 4]
|
|
// CHECK-USE-PPC64LE: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x2427]]]
|
|
// CHECK-USE-PPC64LE: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 4]
|
|
// CHECK-USE-PPC64LE: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x2020]], i64 [[#0x1000000002003]], i64 [[#0x1000000002003]]]
|
|
//.
|
|
// CHECK-USE-I386: @.offload_sizes = private unnamed_addr constant [7 x i64] [i64 0, i64 4, i64 4, i64 4, i64 0, i64 4, i64 4]
|
|
// CHECK-USE-I386: @.offload_maptypes = private unnamed_addr constant [7 x i64] [i64 [[#0x2020]], i64 [[#0x1000000002003]], i64 [[#0x1000000002003]], i64 [[#0x2023]], i64 [[#0x2020]], i64 [[#0x5000000002003]], i64 [[#0x5000000002003]]]
|
|
// CHECK-USE-I386: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 4]
|
|
// CHECK-USE-I386: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x2427]]]
|
|
// CHECK-USE-I386: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 4]
|
|
// CHECK-USE-I386: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x2020]], i64 [[#0x1000000002003]], i64 [[#0x1000000002003]]]
|
|
//.
|
|
// CHECK-NOUSE-PPC64LE: @.offload_sizes = private unnamed_addr constant [7 x i64] [i64 0, i64 4, i64 4, i64 4, i64 0, i64 4, i64 4]
|
|
// CHECK-NOUSE-PPC64LE: @.offload_maptypes = private unnamed_addr constant [7 x i64] [i64 [[#0x2000]], i64 [[#0x1000000002003]], i64 [[#0x1000000002003]], i64 [[#0x2003]], i64 [[#0x2000]], i64 [[#0x5000000002003]], i64 [[#0x5000000002003]]]
|
|
// CHECK-NOUSE-PPC64LE: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 4]
|
|
// CHECK-NOUSE-PPC64LE: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x2407]]]
|
|
// CHECK-NOUSE-PPC64LE: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 4]
|
|
// CHECK-NOUSE-PPC64LE: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x2000]], i64 [[#0x1000000002003]], i64 [[#0x1000000002003]]]
|
|
//.
|
|
// CHECK-NOUSE-I386: @.offload_sizes = private unnamed_addr constant [7 x i64] [i64 0, i64 4, i64 4, i64 4, i64 0, i64 4, i64 4]
|
|
// CHECK-NOUSE-I386: @.offload_maptypes = private unnamed_addr constant [7 x i64] [i64 [[#0x2000]], i64 [[#0x1000000002003]], i64 [[#0x1000000002003]], i64 [[#0x2003]], i64 [[#0x2000]], i64 [[#0x5000000002003]], i64 [[#0x5000000002003]]]
|
|
// CHECK-NOUSE-I386: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 4]
|
|
// CHECK-NOUSE-I386: @.offload_maptypes.2 = private unnamed_addr constant [1 x i64] [i64 [[#0x2407]]]
|
|
// CHECK-NOUSE-I386: @.offload_sizes.3 = private unnamed_addr constant [3 x i64] [i64 0, i64 4, i64 4]
|
|
// CHECK-NOUSE-I386: @.offload_maptypes.4 = private unnamed_addr constant [3 x i64] [i64 [[#0x2000]], i64 [[#0x1000000002003]], i64 [[#0x1000000002003]]]
|
|
//.
|
|
struct ST {
|
|
int i;
|
|
int j;
|
|
void test_present_members();
|
|
};
|
|
|
|
void explicit_maps_single(int ii) {
|
|
|
|
// Map of a scalar.
|
|
int a = ii;
|
|
|
|
struct ST st1;
|
|
struct ST st2;
|
|
|
|
// Make sure the struct picks up ompx_hold even if another element of the
|
|
// struct doesn't have ompx_hold.
|
|
#pragma omp target map(tofrom : st1.i) \
|
|
map(ompx_hold, tofrom : a, st1.j, st2.i) \
|
|
map(tofrom : st2.j)
|
|
{
|
|
#ifdef USE
|
|
st1.i++;
|
|
a++;
|
|
st1.j++;
|
|
st2.i++;
|
|
st2.j++;
|
|
#endif
|
|
}
|
|
|
|
// Always Close Hold.
|
|
#pragma omp target map(always close ompx_hold tofrom: a)
|
|
{
|
|
#ifdef USE
|
|
a++;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void ST::test_present_members() {
|
|
// Make sure the struct picks up ompx_hold even if another element of the
|
|
// struct doesn't have ompx_hold.
|
|
#pragma omp target map(tofrom : i) map(ompx_hold, tofrom : j)
|
|
{
|
|
#ifdef USE
|
|
i++;
|
|
j++;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#endif
|
|
//.
|
|
// CHECK-USE-PPC64LE-LABEL: define {{[^@]+}}@_Z20explicit_maps_singlei
|
|
// CHECK-USE-PPC64LE-SAME: (i32 noundef signext [[II:%.*]]) #[[ATTR0:[0-9]+]] {
|
|
// CHECK-USE-PPC64LE-NEXT: entry:
|
|
// CHECK-USE-PPC64LE-NEXT: [[II_ADDR:%.*]] = alloca i32, align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[ST1:%.*]] = alloca [[STRUCT_ST:%.*]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[ST2:%.*]] = alloca [[STRUCT_ST]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [7 x i8*], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [7 x i8*], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [7 x i8*], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [7 x i64], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_BASEPTRS3:%.*]] = alloca [1 x i8*], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_PTRS4:%.*]] = alloca [1 x i8*], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_MAPPERS5:%.*]] = alloca [1 x i8*], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 [[II]], i32* [[II_ADDR]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP0:%.*]] = load i32, i32* [[II_ADDR]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 [[TMP0]], i32* [[A]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST1]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST1]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP1:%.*]] = getelementptr i32, i32* [[J]], i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP2:%.*]] = bitcast i32* [[I]] to i8*
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP1]] to i8*
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP4:%.*]] = ptrtoint i8* [[TMP3]] to i64
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP5:%.*]] = ptrtoint i8* [[TMP2]] to i64
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP6:%.*]] = sub i64 [[TMP4]], [[TMP5]]
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP7:%.*]] = sdiv exact i64 [[TMP6]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-USE-PPC64LE-NEXT: [[I1:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST2]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[J2:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST2]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP8:%.*]] = getelementptr i32, i32* [[J2]], i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP9:%.*]] = bitcast i32* [[I1]] to i8*
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP10:%.*]] = bitcast i32* [[TMP8]] to i8*
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP11:%.*]] = ptrtoint i8* [[TMP10]] to i64
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP12:%.*]] = ptrtoint i8* [[TMP9]] to i64
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP13:%.*]] = sub i64 [[TMP11]], [[TMP12]]
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP14:%.*]] = sdiv exact i64 [[TMP13]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP15:%.*]] = bitcast [7 x i64]* [[DOTOFFLOAD_SIZES]] to i8*
|
|
// CHECK-USE-PPC64LE-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 [[TMP15]], i8* align 8 bitcast ([7 x i64]* @.offload_sizes to i8*), i64 56, i1 false)
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP16:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP17:%.*]] = bitcast i8** [[TMP16]] to %struct.ST**
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP17]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP18:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP19:%.*]] = bitcast i8** [[TMP18]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[I]], i32** [[TMP19]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP20:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: store i64 [[TMP7]], i64* [[TMP20]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP21:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP21]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP22:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP23:%.*]] = bitcast i8** [[TMP22]] to %struct.ST**
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP23]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP24:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP25:%.*]] = bitcast i8** [[TMP24]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[I]], i32** [[TMP25]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP26:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP26]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP27:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP28:%.*]] = bitcast i8** [[TMP27]] to %struct.ST**
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP28]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP29:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 2
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP30:%.*]] = bitcast i8** [[TMP29]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[J]], i32** [[TMP30]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP31:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP31]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP32:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP33:%.*]] = bitcast i8** [[TMP32]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[A]], i32** [[TMP33]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP34:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 3
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP35:%.*]] = bitcast i8** [[TMP34]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[A]], i32** [[TMP35]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP36:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP36]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP37:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP38:%.*]] = bitcast i8** [[TMP37]] to %struct.ST**
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP38]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP39:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP40:%.*]] = bitcast i8** [[TMP39]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[I1]], i32** [[TMP40]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP41:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 4
|
|
// CHECK-USE-PPC64LE-NEXT: store i64 [[TMP14]], i64* [[TMP41]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP42:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP42]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP43:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP44:%.*]] = bitcast i8** [[TMP43]] to %struct.ST**
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP44]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP45:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 5
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP46:%.*]] = bitcast i8** [[TMP45]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[I1]], i32** [[TMP46]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP47:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 5
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP47]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP48:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 6
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP49:%.*]] = bitcast i8** [[TMP48]] to %struct.ST**
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP49]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP50:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 6
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP51:%.*]] = bitcast i8** [[TMP50]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[J2]], i32** [[TMP51]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP52:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 6
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP52]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP53:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP54:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP55:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP56:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 2, i32* [[TMP56]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP57:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 7, i32* [[TMP57]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP58:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 2
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** [[TMP53]], i8*** [[TMP58]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP59:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 3
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** [[TMP54]], i8*** [[TMP59]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP60:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 4
|
|
// CHECK-USE-PPC64LE-NEXT: store i64* [[TMP55]], i64** [[TMP60]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP61:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 5
|
|
// CHECK-USE-PPC64LE-NEXT: store i64* getelementptr inbounds ([7 x i64], [7 x i64]* @.offload_maptypes, i32 0, i32 0), i64** [[TMP61]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP62:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 6
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** null, i8*** [[TMP62]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP63:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 7
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** null, i8*** [[TMP63]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP64:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 8
|
|
// CHECK-USE-PPC64LE-NEXT: store i64 0, i64* [[TMP64]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP65:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 9
|
|
// CHECK-USE-PPC64LE-NEXT: store i64 0, i64* [[TMP65]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP66:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 10
|
|
// CHECK-USE-PPC64LE-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP66]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP67:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 11
|
|
// CHECK-USE-PPC64LE-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP67]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP68:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 12
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 0, i32* [[TMP68]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP69:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]])
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP70:%.*]] = icmp ne i32 [[TMP69]], 0
|
|
// CHECK-USE-PPC64LE-NEXT: br i1 [[TMP70]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]]
|
|
// CHECK-USE-PPC64LE: omp_offload.failed:
|
|
// CHECK-USE-PPC64LE-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}(%struct.ST* [[ST1]], i32* [[A]], %struct.ST* [[ST2]]) #[[ATTR3:[0-9]+]]
|
|
// CHECK-USE-PPC64LE-NEXT: br label [[OMP_OFFLOAD_CONT]]
|
|
// CHECK-USE-PPC64LE: omp_offload.cont:
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP71:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_BASEPTRS3]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP72:%.*]] = bitcast i8** [[TMP71]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[A]], i32** [[TMP72]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP73:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_PTRS4]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP74:%.*]] = bitcast i8** [[TMP73]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[A]], i32** [[TMP74]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP75:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_MAPPERS5]], i64 0, i64 0
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP75]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP76:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_BASEPTRS3]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP77:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_PTRS4]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[KERNEL_ARGS6:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP78:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 2, i32* [[TMP78]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP79:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 1, i32* [[TMP79]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP80:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 2
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** [[TMP76]], i8*** [[TMP80]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP81:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 3
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** [[TMP77]], i8*** [[TMP81]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP82:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 4
|
|
// CHECK-USE-PPC64LE-NEXT: store i64* getelementptr inbounds ([1 x i64], [1 x i64]* @.offload_sizes.1, i32 0, i32 0), i64** [[TMP82]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP83:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 5
|
|
// CHECK-USE-PPC64LE-NEXT: store i64* getelementptr inbounds ([1 x i64], [1 x i64]* @.offload_maptypes.2, i32 0, i32 0), i64** [[TMP83]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP84:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 6
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** null, i8*** [[TMP84]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP85:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 7
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** null, i8*** [[TMP85]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP86:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 8
|
|
// CHECK-USE-PPC64LE-NEXT: store i64 0, i64* [[TMP86]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP87:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 9
|
|
// CHECK-USE-PPC64LE-NEXT: store i64 0, i64* [[TMP87]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP88:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 10
|
|
// CHECK-USE-PPC64LE-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP88]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP89:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 11
|
|
// CHECK-USE-PPC64LE-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP89]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP90:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 12
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 0, i32* [[TMP90]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP91:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]])
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP92:%.*]] = icmp ne i32 [[TMP91]], 0
|
|
// CHECK-USE-PPC64LE-NEXT: br i1 [[TMP92]], label [[OMP_OFFLOAD_FAILED7:%.*]], label [[OMP_OFFLOAD_CONT8:%.*]]
|
|
// CHECK-USE-PPC64LE: omp_offload.failed7:
|
|
// CHECK-USE-PPC64LE-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}(i32* [[A]]) #[[ATTR3]]
|
|
// CHECK-USE-PPC64LE-NEXT: br label [[OMP_OFFLOAD_CONT8]]
|
|
// CHECK-USE-PPC64LE: omp_offload.cont8:
|
|
// CHECK-USE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-PPC64LE-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}
|
|
// CHECK-USE-PPC64LE-SAME: (%struct.ST* noundef nonnull align 4 dereferenceable(8) [[ST1:%.*]], i32* noundef nonnull align 4 dereferenceable(4) [[A:%.*]], %struct.ST* noundef nonnull align 4 dereferenceable(8) [[ST2:%.*]]) #[[ATTR1:[0-9]+]] {
|
|
// CHECK-USE-PPC64LE-NEXT: entry:
|
|
// CHECK-USE-PPC64LE-NEXT: [[ST1_ADDR:%.*]] = alloca %struct.ST*, align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[A_ADDR:%.*]] = alloca i32*, align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[ST2_ADDR:%.*]] = alloca %struct.ST*, align 8
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[ST1_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[A]], i32** [[A_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[ST2_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP0:%.*]] = load %struct.ST*, %struct.ST** [[ST1_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP1:%.*]] = load i32*, i32** [[A_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP2:%.*]] = load %struct.ST*, %struct.ST** [[ST2_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[TMP0]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP3:%.*]] = load i32, i32* [[I]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[INC:%.*]] = add nsw i32 [[TMP3]], 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 [[INC]], i32* [[I]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP4:%.*]] = load i32, i32* [[TMP1]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[INC1:%.*]] = add nsw i32 [[TMP4]], 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 [[INC1]], i32* [[TMP1]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[TMP0]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP5:%.*]] = load i32, i32* [[J]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[INC2:%.*]] = add nsw i32 [[TMP5]], 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 [[INC2]], i32* [[J]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[I3:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[TMP2]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP6:%.*]] = load i32, i32* [[I3]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[INC4:%.*]] = add nsw i32 [[TMP6]], 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 [[INC4]], i32* [[I3]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[J5:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[TMP2]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP7:%.*]] = load i32, i32* [[J5]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[INC6:%.*]] = add nsw i32 [[TMP7]], 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 [[INC6]], i32* [[J5]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-PPC64LE-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}
|
|
// CHECK-USE-PPC64LE-SAME: (i32* noundef nonnull align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR1]] {
|
|
// CHECK-USE-PPC64LE-NEXT: entry:
|
|
// CHECK-USE-PPC64LE-NEXT: [[A_ADDR:%.*]] = alloca i32*, align 8
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[A]], i32** [[A_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP0:%.*]] = load i32*, i32** [[A_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[INC:%.*]] = add nsw i32 [[TMP1]], 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 [[INC]], i32* [[TMP0]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-PPC64LE-LABEL: define {{[^@]+}}@_ZN2ST20test_present_membersEv
|
|
// CHECK-USE-PPC64LE-SAME: (%struct.ST* noundef nonnull align 4 dereferenceable(8) [[THIS:%.*]]) #[[ATTR0]] align 2 {
|
|
// CHECK-USE-PPC64LE-NEXT: entry:
|
|
// CHECK-USE-PPC64LE-NEXT: [[THIS_ADDR:%.*]] = alloca %struct.ST*, align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [3 x i8*], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [3 x i8*], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [3 x i8*], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [3 x i64], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[THIS]], %struct.ST** [[THIS_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[THIS1:%.*]] = load %struct.ST*, %struct.ST** [[THIS_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[THIS1]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[THIS1]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP0:%.*]] = getelementptr i32, i32* [[J]], i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP1:%.*]] = bitcast i32* [[I]] to i8*
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP2:%.*]] = bitcast i32* [[TMP0]] to i8*
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP3:%.*]] = ptrtoint i8* [[TMP2]] to i64
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP4:%.*]] = ptrtoint i8* [[TMP1]] to i64
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP5:%.*]] = sub i64 [[TMP3]], [[TMP4]]
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP6:%.*]] = sdiv exact i64 [[TMP5]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP7:%.*]] = bitcast [3 x i64]* [[DOTOFFLOAD_SIZES]] to i8*
|
|
// CHECK-USE-PPC64LE-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 [[TMP7]], i8* align 8 bitcast ([3 x i64]* @.offload_sizes.3 to i8*), i64 24, i1 false)
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP8:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP9:%.*]] = bitcast i8** [[TMP8]] to %struct.ST**
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP9]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP10:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP11:%.*]] = bitcast i8** [[TMP10]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[I]], i32** [[TMP11]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP12:%.*]] = getelementptr inbounds [3 x i64], [3 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: store i64 [[TMP6]], i64* [[TMP12]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP13:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP13]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP14:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP15:%.*]] = bitcast i8** [[TMP14]] to %struct.ST**
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP15]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP16:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP17:%.*]] = bitcast i8** [[TMP16]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[I]], i32** [[TMP17]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP18:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP18]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP19:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP20:%.*]] = bitcast i8** [[TMP19]] to %struct.ST**
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP20]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP21:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 2
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP22:%.*]] = bitcast i8** [[TMP21]] to i32**
|
|
// CHECK-USE-PPC64LE-NEXT: store i32* [[J]], i32** [[TMP22]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP23:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2
|
|
// CHECK-USE-PPC64LE-NEXT: store i8* null, i8** [[TMP23]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP24:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP25:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP26:%.*]] = getelementptr inbounds [3 x i64], [3 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP27:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 2, i32* [[TMP27]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP28:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 3, i32* [[TMP28]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP29:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 2
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** [[TMP24]], i8*** [[TMP29]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP30:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 3
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** [[TMP25]], i8*** [[TMP30]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP31:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 4
|
|
// CHECK-USE-PPC64LE-NEXT: store i64* [[TMP26]], i64** [[TMP31]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP32:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 5
|
|
// CHECK-USE-PPC64LE-NEXT: store i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.4, i32 0, i32 0), i64** [[TMP32]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP33:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 6
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** null, i8*** [[TMP33]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP34:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 7
|
|
// CHECK-USE-PPC64LE-NEXT: store i8** null, i8*** [[TMP34]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP35:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 8
|
|
// CHECK-USE-PPC64LE-NEXT: store i64 0, i64* [[TMP35]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP36:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 9
|
|
// CHECK-USE-PPC64LE-NEXT: store i64 0, i64* [[TMP36]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP37:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 10
|
|
// CHECK-USE-PPC64LE-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP37]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP38:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 11
|
|
// CHECK-USE-PPC64LE-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP38]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP39:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 12
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 0, i32* [[TMP39]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP40:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]])
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP41:%.*]] = icmp ne i32 [[TMP40]], 0
|
|
// CHECK-USE-PPC64LE-NEXT: br i1 [[TMP41]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]]
|
|
// CHECK-USE-PPC64LE: omp_offload.failed:
|
|
// CHECK-USE-PPC64LE-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}(%struct.ST* [[THIS1]]) #[[ATTR3]]
|
|
// CHECK-USE-PPC64LE-NEXT: br label [[OMP_OFFLOAD_CONT]]
|
|
// CHECK-USE-PPC64LE: omp_offload.cont:
|
|
// CHECK-USE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-PPC64LE-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}
|
|
// CHECK-USE-PPC64LE-SAME: (%struct.ST* noundef [[THIS:%.*]]) #[[ATTR1]] {
|
|
// CHECK-USE-PPC64LE-NEXT: entry:
|
|
// CHECK-USE-PPC64LE-NEXT: [[THIS_ADDR:%.*]] = alloca %struct.ST*, align 8
|
|
// CHECK-USE-PPC64LE-NEXT: store %struct.ST* [[THIS]], %struct.ST** [[THIS_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP0:%.*]] = load %struct.ST*, %struct.ST** [[THIS_ADDR]], align 8
|
|
// CHECK-USE-PPC64LE-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[TMP0]], i32 0, i32 0
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP1:%.*]] = load i32, i32* [[I]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[INC:%.*]] = add nsw i32 [[TMP1]], 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 [[INC]], i32* [[I]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[TMP0]], i32 0, i32 1
|
|
// CHECK-USE-PPC64LE-NEXT: [[TMP2:%.*]] = load i32, i32* [[J]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: [[INC1:%.*]] = add nsw i32 [[TMP2]], 1
|
|
// CHECK-USE-PPC64LE-NEXT: store i32 [[INC1]], i32* [[J]], align 4
|
|
// CHECK-USE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-PPC64LE-LABEL: define {{[^@]+}}@.omp_offloading.requires_reg
|
|
// CHECK-USE-PPC64LE-SAME: () #[[ATTR4:[0-9]+]] {
|
|
// CHECK-USE-PPC64LE-NEXT: entry:
|
|
// CHECK-USE-PPC64LE-NEXT: call void @__tgt_register_requires(i64 1)
|
|
// CHECK-USE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-I386-LABEL: define {{[^@]+}}@_Z20explicit_maps_singlei
|
|
// CHECK-USE-I386-SAME: (i32 noundef [[II:%.*]]) #[[ATTR0:[0-9]+]] {
|
|
// CHECK-USE-I386-NEXT: entry:
|
|
// CHECK-USE-I386-NEXT: [[II_ADDR:%.*]] = alloca i32, align 4
|
|
// CHECK-USE-I386-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
// CHECK-USE-I386-NEXT: [[ST1:%.*]] = alloca [[STRUCT_ST:%.*]], align 4
|
|
// CHECK-USE-I386-NEXT: [[ST2:%.*]] = alloca [[STRUCT_ST]], align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [7 x i8*], align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [7 x i8*], align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [7 x i8*], align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [7 x i64], align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_BASEPTRS3:%.*]] = alloca [1 x i8*], align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_PTRS4:%.*]] = alloca [1 x i8*], align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_MAPPERS5:%.*]] = alloca [1 x i8*], align 4
|
|
// CHECK-USE-I386-NEXT: store i32 [[II]], i32* [[II_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP0:%.*]] = load i32, i32* [[II_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: store i32 [[TMP0]], i32* [[A]], align 4
|
|
// CHECK-USE-I386-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST1]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST1]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP1:%.*]] = getelementptr i32, i32* [[J]], i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP2:%.*]] = bitcast i32* [[I]] to i8*
|
|
// CHECK-USE-I386-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP1]] to i8*
|
|
// CHECK-USE-I386-NEXT: [[TMP4:%.*]] = ptrtoint i8* [[TMP3]] to i64
|
|
// CHECK-USE-I386-NEXT: [[TMP5:%.*]] = ptrtoint i8* [[TMP2]] to i64
|
|
// CHECK-USE-I386-NEXT: [[TMP6:%.*]] = sub i64 [[TMP4]], [[TMP5]]
|
|
// CHECK-USE-I386-NEXT: [[TMP7:%.*]] = sdiv exact i64 [[TMP6]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-USE-I386-NEXT: [[I1:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST2]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[J2:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST2]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP8:%.*]] = getelementptr i32, i32* [[J2]], i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP9:%.*]] = bitcast i32* [[I1]] to i8*
|
|
// CHECK-USE-I386-NEXT: [[TMP10:%.*]] = bitcast i32* [[TMP8]] to i8*
|
|
// CHECK-USE-I386-NEXT: [[TMP11:%.*]] = ptrtoint i8* [[TMP10]] to i64
|
|
// CHECK-USE-I386-NEXT: [[TMP12:%.*]] = ptrtoint i8* [[TMP9]] to i64
|
|
// CHECK-USE-I386-NEXT: [[TMP13:%.*]] = sub i64 [[TMP11]], [[TMP12]]
|
|
// CHECK-USE-I386-NEXT: [[TMP14:%.*]] = sdiv exact i64 [[TMP13]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-USE-I386-NEXT: [[TMP15:%.*]] = bitcast [7 x i64]* [[DOTOFFLOAD_SIZES]] to i8*
|
|
// CHECK-USE-I386-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 [[TMP15]], i8* align 4 bitcast ([7 x i64]* @.offload_sizes to i8*), i32 56, i1 false)
|
|
// CHECK-USE-I386-NEXT: [[TMP16:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP17:%.*]] = bitcast i8** [[TMP16]] to %struct.ST**
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP17]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP18:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP19:%.*]] = bitcast i8** [[TMP18]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[I]], i32** [[TMP19]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP20:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: store i64 [[TMP7]], i64* [[TMP20]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP21:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP21]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP22:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP23:%.*]] = bitcast i8** [[TMP22]] to %struct.ST**
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP23]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP24:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP25:%.*]] = bitcast i8** [[TMP24]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[I]], i32** [[TMP25]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP26:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP26]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP27:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2
|
|
// CHECK-USE-I386-NEXT: [[TMP28:%.*]] = bitcast i8** [[TMP27]] to %struct.ST**
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP28]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP29:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 2
|
|
// CHECK-USE-I386-NEXT: [[TMP30:%.*]] = bitcast i8** [[TMP29]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[J]], i32** [[TMP30]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP31:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 2
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP31]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP32:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3
|
|
// CHECK-USE-I386-NEXT: [[TMP33:%.*]] = bitcast i8** [[TMP32]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[A]], i32** [[TMP33]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP34:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 3
|
|
// CHECK-USE-I386-NEXT: [[TMP35:%.*]] = bitcast i8** [[TMP34]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[A]], i32** [[TMP35]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP36:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 3
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP36]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP37:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4
|
|
// CHECK-USE-I386-NEXT: [[TMP38:%.*]] = bitcast i8** [[TMP37]] to %struct.ST**
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP38]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP39:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 4
|
|
// CHECK-USE-I386-NEXT: [[TMP40:%.*]] = bitcast i8** [[TMP39]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[I1]], i32** [[TMP40]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP41:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 4
|
|
// CHECK-USE-I386-NEXT: store i64 [[TMP14]], i64* [[TMP41]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP42:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 4
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP42]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP43:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5
|
|
// CHECK-USE-I386-NEXT: [[TMP44:%.*]] = bitcast i8** [[TMP43]] to %struct.ST**
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP44]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP45:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 5
|
|
// CHECK-USE-I386-NEXT: [[TMP46:%.*]] = bitcast i8** [[TMP45]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[I1]], i32** [[TMP46]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP47:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 5
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP47]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP48:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 6
|
|
// CHECK-USE-I386-NEXT: [[TMP49:%.*]] = bitcast i8** [[TMP48]] to %struct.ST**
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP49]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP50:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 6
|
|
// CHECK-USE-I386-NEXT: [[TMP51:%.*]] = bitcast i8** [[TMP50]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[J2]], i32** [[TMP51]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP52:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 6
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP52]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP53:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP54:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP55:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8
|
|
// CHECK-USE-I386-NEXT: [[TMP56:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: store i32 2, i32* [[TMP56]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP57:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: store i32 7, i32* [[TMP57]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP58:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 2
|
|
// CHECK-USE-I386-NEXT: store i8** [[TMP53]], i8*** [[TMP58]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP59:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 3
|
|
// CHECK-USE-I386-NEXT: store i8** [[TMP54]], i8*** [[TMP59]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP60:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 4
|
|
// CHECK-USE-I386-NEXT: store i64* [[TMP55]], i64** [[TMP60]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP61:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 5
|
|
// CHECK-USE-I386-NEXT: store i64* getelementptr inbounds ([7 x i64], [7 x i64]* @.offload_maptypes, i32 0, i32 0), i64** [[TMP61]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP62:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 6
|
|
// CHECK-USE-I386-NEXT: store i8** null, i8*** [[TMP62]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP63:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 7
|
|
// CHECK-USE-I386-NEXT: store i8** null, i8*** [[TMP63]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP64:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 8
|
|
// CHECK-USE-I386-NEXT: store i64 0, i64* [[TMP64]], align 8
|
|
// CHECK-USE-I386-NEXT: [[TMP65:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 9
|
|
// CHECK-USE-I386-NEXT: store i64 0, i64* [[TMP65]], align 8
|
|
// CHECK-USE-I386-NEXT: [[TMP66:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 10
|
|
// CHECK-USE-I386-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP66]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP67:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 11
|
|
// CHECK-USE-I386-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP67]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP68:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 12
|
|
// CHECK-USE-I386-NEXT: store i32 0, i32* [[TMP68]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP69:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]])
|
|
// CHECK-USE-I386-NEXT: [[TMP70:%.*]] = icmp ne i32 [[TMP69]], 0
|
|
// CHECK-USE-I386-NEXT: br i1 [[TMP70]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]]
|
|
// CHECK-USE-I386: omp_offload.failed:
|
|
// CHECK-USE-I386-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}(%struct.ST* [[ST1]], i32* [[A]], %struct.ST* [[ST2]]) #[[ATTR3:[0-9]+]]
|
|
// CHECK-USE-I386-NEXT: br label [[OMP_OFFLOAD_CONT]]
|
|
// CHECK-USE-I386: omp_offload.cont:
|
|
// CHECK-USE-I386-NEXT: [[TMP71:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_BASEPTRS3]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP72:%.*]] = bitcast i8** [[TMP71]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[A]], i32** [[TMP72]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP73:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_PTRS4]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP74:%.*]] = bitcast i8** [[TMP73]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[A]], i32** [[TMP74]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP75:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_MAPPERS5]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP75]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP76:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_BASEPTRS3]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP77:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_PTRS4]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[KERNEL_ARGS6:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8
|
|
// CHECK-USE-I386-NEXT: [[TMP78:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: store i32 2, i32* [[TMP78]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP79:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: store i32 1, i32* [[TMP79]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP80:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 2
|
|
// CHECK-USE-I386-NEXT: store i8** [[TMP76]], i8*** [[TMP80]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP81:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 3
|
|
// CHECK-USE-I386-NEXT: store i8** [[TMP77]], i8*** [[TMP81]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP82:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 4
|
|
// CHECK-USE-I386-NEXT: store i64* getelementptr inbounds ([1 x i64], [1 x i64]* @.offload_sizes.1, i32 0, i32 0), i64** [[TMP82]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP83:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 5
|
|
// CHECK-USE-I386-NEXT: store i64* getelementptr inbounds ([1 x i64], [1 x i64]* @.offload_maptypes.2, i32 0, i32 0), i64** [[TMP83]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP84:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 6
|
|
// CHECK-USE-I386-NEXT: store i8** null, i8*** [[TMP84]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP85:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 7
|
|
// CHECK-USE-I386-NEXT: store i8** null, i8*** [[TMP85]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP86:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 8
|
|
// CHECK-USE-I386-NEXT: store i64 0, i64* [[TMP86]], align 8
|
|
// CHECK-USE-I386-NEXT: [[TMP87:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 9
|
|
// CHECK-USE-I386-NEXT: store i64 0, i64* [[TMP87]], align 8
|
|
// CHECK-USE-I386-NEXT: [[TMP88:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 10
|
|
// CHECK-USE-I386-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP88]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP89:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 11
|
|
// CHECK-USE-I386-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP89]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP90:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 12
|
|
// CHECK-USE-I386-NEXT: store i32 0, i32* [[TMP90]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP91:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]])
|
|
// CHECK-USE-I386-NEXT: [[TMP92:%.*]] = icmp ne i32 [[TMP91]], 0
|
|
// CHECK-USE-I386-NEXT: br i1 [[TMP92]], label [[OMP_OFFLOAD_FAILED7:%.*]], label [[OMP_OFFLOAD_CONT8:%.*]]
|
|
// CHECK-USE-I386: omp_offload.failed7:
|
|
// CHECK-USE-I386-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}(i32* [[A]]) #[[ATTR3]]
|
|
// CHECK-USE-I386-NEXT: br label [[OMP_OFFLOAD_CONT8]]
|
|
// CHECK-USE-I386: omp_offload.cont8:
|
|
// CHECK-USE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-I386-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}
|
|
// CHECK-USE-I386-SAME: (%struct.ST* noundef nonnull align 4 dereferenceable(8) [[ST1:%.*]], i32* noundef nonnull align 4 dereferenceable(4) [[A:%.*]], %struct.ST* noundef nonnull align 4 dereferenceable(8) [[ST2:%.*]]) #[[ATTR1:[0-9]+]] {
|
|
// CHECK-USE-I386-NEXT: entry:
|
|
// CHECK-USE-I386-NEXT: [[ST1_ADDR:%.*]] = alloca %struct.ST*, align 4
|
|
// CHECK-USE-I386-NEXT: [[A_ADDR:%.*]] = alloca i32*, align 4
|
|
// CHECK-USE-I386-NEXT: [[ST2_ADDR:%.*]] = alloca %struct.ST*, align 4
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[ST1_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: store i32* [[A]], i32** [[A_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[ST2_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP0:%.*]] = load %struct.ST*, %struct.ST** [[ST1_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP1:%.*]] = load i32*, i32** [[A_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP2:%.*]] = load %struct.ST*, %struct.ST** [[ST2_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[TMP0]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP3:%.*]] = load i32, i32* [[I]], align 4
|
|
// CHECK-USE-I386-NEXT: [[INC:%.*]] = add nsw i32 [[TMP3]], 1
|
|
// CHECK-USE-I386-NEXT: store i32 [[INC]], i32* [[I]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP4:%.*]] = load i32, i32* [[TMP1]], align 4
|
|
// CHECK-USE-I386-NEXT: [[INC1:%.*]] = add nsw i32 [[TMP4]], 1
|
|
// CHECK-USE-I386-NEXT: store i32 [[INC1]], i32* [[TMP1]], align 4
|
|
// CHECK-USE-I386-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[TMP0]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP5:%.*]] = load i32, i32* [[J]], align 4
|
|
// CHECK-USE-I386-NEXT: [[INC2:%.*]] = add nsw i32 [[TMP5]], 1
|
|
// CHECK-USE-I386-NEXT: store i32 [[INC2]], i32* [[J]], align 4
|
|
// CHECK-USE-I386-NEXT: [[I3:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[TMP2]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP6:%.*]] = load i32, i32* [[I3]], align 4
|
|
// CHECK-USE-I386-NEXT: [[INC4:%.*]] = add nsw i32 [[TMP6]], 1
|
|
// CHECK-USE-I386-NEXT: store i32 [[INC4]], i32* [[I3]], align 4
|
|
// CHECK-USE-I386-NEXT: [[J5:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[TMP2]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP7:%.*]] = load i32, i32* [[J5]], align 4
|
|
// CHECK-USE-I386-NEXT: [[INC6:%.*]] = add nsw i32 [[TMP7]], 1
|
|
// CHECK-USE-I386-NEXT: store i32 [[INC6]], i32* [[J5]], align 4
|
|
// CHECK-USE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-I386-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}
|
|
// CHECK-USE-I386-SAME: (i32* noundef nonnull align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR1]] {
|
|
// CHECK-USE-I386-NEXT: entry:
|
|
// CHECK-USE-I386-NEXT: [[A_ADDR:%.*]] = alloca i32*, align 4
|
|
// CHECK-USE-I386-NEXT: store i32* [[A]], i32** [[A_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP0:%.*]] = load i32*, i32** [[A_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
|
|
// CHECK-USE-I386-NEXT: [[INC:%.*]] = add nsw i32 [[TMP1]], 1
|
|
// CHECK-USE-I386-NEXT: store i32 [[INC]], i32* [[TMP0]], align 4
|
|
// CHECK-USE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-I386-LABEL: define {{[^@]+}}@_ZN2ST20test_present_membersEv
|
|
// CHECK-USE-I386-SAME: (%struct.ST* noundef nonnull align 4 dereferenceable(8) [[THIS:%.*]]) #[[ATTR0]] align 2 {
|
|
// CHECK-USE-I386-NEXT: entry:
|
|
// CHECK-USE-I386-NEXT: [[THIS_ADDR:%.*]] = alloca %struct.ST*, align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [3 x i8*], align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [3 x i8*], align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [3 x i8*], align 4
|
|
// CHECK-USE-I386-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [3 x i64], align 4
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[THIS]], %struct.ST** [[THIS_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[THIS1:%.*]] = load %struct.ST*, %struct.ST** [[THIS_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[THIS1]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[THIS1]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP0:%.*]] = getelementptr i32, i32* [[J]], i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP1:%.*]] = bitcast i32* [[I]] to i8*
|
|
// CHECK-USE-I386-NEXT: [[TMP2:%.*]] = bitcast i32* [[TMP0]] to i8*
|
|
// CHECK-USE-I386-NEXT: [[TMP3:%.*]] = ptrtoint i8* [[TMP2]] to i64
|
|
// CHECK-USE-I386-NEXT: [[TMP4:%.*]] = ptrtoint i8* [[TMP1]] to i64
|
|
// CHECK-USE-I386-NEXT: [[TMP5:%.*]] = sub i64 [[TMP3]], [[TMP4]]
|
|
// CHECK-USE-I386-NEXT: [[TMP6:%.*]] = sdiv exact i64 [[TMP5]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-USE-I386-NEXT: [[TMP7:%.*]] = bitcast [3 x i64]* [[DOTOFFLOAD_SIZES]] to i8*
|
|
// CHECK-USE-I386-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 [[TMP7]], i8* align 4 bitcast ([3 x i64]* @.offload_sizes.3 to i8*), i32 24, i1 false)
|
|
// CHECK-USE-I386-NEXT: [[TMP8:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP9:%.*]] = bitcast i8** [[TMP8]] to %struct.ST**
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP9]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP10:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP11:%.*]] = bitcast i8** [[TMP10]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[I]], i32** [[TMP11]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP12:%.*]] = getelementptr inbounds [3 x i64], [3 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: store i64 [[TMP6]], i64* [[TMP12]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP13:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP13]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP14:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP15:%.*]] = bitcast i8** [[TMP14]] to %struct.ST**
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP15]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP16:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP17:%.*]] = bitcast i8** [[TMP16]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[I]], i32** [[TMP17]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP18:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP18]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP19:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2
|
|
// CHECK-USE-I386-NEXT: [[TMP20:%.*]] = bitcast i8** [[TMP19]] to %struct.ST**
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP20]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP21:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 2
|
|
// CHECK-USE-I386-NEXT: [[TMP22:%.*]] = bitcast i8** [[TMP21]] to i32**
|
|
// CHECK-USE-I386-NEXT: store i32* [[J]], i32** [[TMP22]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP23:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 2
|
|
// CHECK-USE-I386-NEXT: store i8* null, i8** [[TMP23]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP24:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP25:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP26:%.*]] = getelementptr inbounds [3 x i64], [3 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8
|
|
// CHECK-USE-I386-NEXT: [[TMP27:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: store i32 2, i32* [[TMP27]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP28:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: store i32 3, i32* [[TMP28]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP29:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 2
|
|
// CHECK-USE-I386-NEXT: store i8** [[TMP24]], i8*** [[TMP29]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP30:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 3
|
|
// CHECK-USE-I386-NEXT: store i8** [[TMP25]], i8*** [[TMP30]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP31:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 4
|
|
// CHECK-USE-I386-NEXT: store i64* [[TMP26]], i64** [[TMP31]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP32:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 5
|
|
// CHECK-USE-I386-NEXT: store i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.4, i32 0, i32 0), i64** [[TMP32]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP33:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 6
|
|
// CHECK-USE-I386-NEXT: store i8** null, i8*** [[TMP33]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP34:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 7
|
|
// CHECK-USE-I386-NEXT: store i8** null, i8*** [[TMP34]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP35:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 8
|
|
// CHECK-USE-I386-NEXT: store i64 0, i64* [[TMP35]], align 8
|
|
// CHECK-USE-I386-NEXT: [[TMP36:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 9
|
|
// CHECK-USE-I386-NEXT: store i64 0, i64* [[TMP36]], align 8
|
|
// CHECK-USE-I386-NEXT: [[TMP37:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 10
|
|
// CHECK-USE-I386-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP37]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP38:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 11
|
|
// CHECK-USE-I386-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP38]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP39:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 12
|
|
// CHECK-USE-I386-NEXT: store i32 0, i32* [[TMP39]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP40:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]])
|
|
// CHECK-USE-I386-NEXT: [[TMP41:%.*]] = icmp ne i32 [[TMP40]], 0
|
|
// CHECK-USE-I386-NEXT: br i1 [[TMP41]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]]
|
|
// CHECK-USE-I386: omp_offload.failed:
|
|
// CHECK-USE-I386-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}(%struct.ST* [[THIS1]]) #[[ATTR3]]
|
|
// CHECK-USE-I386-NEXT: br label [[OMP_OFFLOAD_CONT]]
|
|
// CHECK-USE-I386: omp_offload.cont:
|
|
// CHECK-USE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-I386-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}
|
|
// CHECK-USE-I386-SAME: (%struct.ST* noundef [[THIS:%.*]]) #[[ATTR1]] {
|
|
// CHECK-USE-I386-NEXT: entry:
|
|
// CHECK-USE-I386-NEXT: [[THIS_ADDR:%.*]] = alloca %struct.ST*, align 4
|
|
// CHECK-USE-I386-NEXT: store %struct.ST* [[THIS]], %struct.ST** [[THIS_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[TMP0:%.*]] = load %struct.ST*, %struct.ST** [[THIS_ADDR]], align 4
|
|
// CHECK-USE-I386-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[TMP0]], i32 0, i32 0
|
|
// CHECK-USE-I386-NEXT: [[TMP1:%.*]] = load i32, i32* [[I]], align 4
|
|
// CHECK-USE-I386-NEXT: [[INC:%.*]] = add nsw i32 [[TMP1]], 1
|
|
// CHECK-USE-I386-NEXT: store i32 [[INC]], i32* [[I]], align 4
|
|
// CHECK-USE-I386-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[TMP0]], i32 0, i32 1
|
|
// CHECK-USE-I386-NEXT: [[TMP2:%.*]] = load i32, i32* [[J]], align 4
|
|
// CHECK-USE-I386-NEXT: [[INC1:%.*]] = add nsw i32 [[TMP2]], 1
|
|
// CHECK-USE-I386-NEXT: store i32 [[INC1]], i32* [[J]], align 4
|
|
// CHECK-USE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-USE-I386-LABEL: define {{[^@]+}}@.omp_offloading.requires_reg
|
|
// CHECK-USE-I386-SAME: () #[[ATTR4:[0-9]+]] {
|
|
// CHECK-USE-I386-NEXT: entry:
|
|
// CHECK-USE-I386-NEXT: call void @__tgt_register_requires(i64 1)
|
|
// CHECK-USE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-PPC64LE-LABEL: define {{[^@]+}}@_Z20explicit_maps_singlei
|
|
// CHECK-NOUSE-PPC64LE-SAME: (i32 noundef signext [[II:%.*]]) #[[ATTR0:[0-9]+]] {
|
|
// CHECK-NOUSE-PPC64LE-NEXT: entry:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[II_ADDR:%.*]] = alloca i32, align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[ST1:%.*]] = alloca [[STRUCT_ST:%.*]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[ST2:%.*]] = alloca [[STRUCT_ST]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [7 x i8*], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [7 x i8*], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [7 x i8*], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [7 x i64], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_BASEPTRS3:%.*]] = alloca [1 x i8*], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_PTRS4:%.*]] = alloca [1 x i8*], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_MAPPERS5:%.*]] = alloca [1 x i8*], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 [[II]], i32* [[II_ADDR]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP0:%.*]] = load i32, i32* [[II_ADDR]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 [[TMP0]], i32* [[A]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST1]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST1]], i32 0, i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP1:%.*]] = getelementptr i32, i32* [[J]], i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP2:%.*]] = bitcast i32* [[I]] to i8*
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP1]] to i8*
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP4:%.*]] = ptrtoint i8* [[TMP3]] to i64
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP5:%.*]] = ptrtoint i8* [[TMP2]] to i64
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP6:%.*]] = sub i64 [[TMP4]], [[TMP5]]
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP7:%.*]] = sdiv exact i64 [[TMP6]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[I1:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST2]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[J2:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST2]], i32 0, i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP8:%.*]] = getelementptr i32, i32* [[J2]], i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP9:%.*]] = bitcast i32* [[I1]] to i8*
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP10:%.*]] = bitcast i32* [[TMP8]] to i8*
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP11:%.*]] = ptrtoint i8* [[TMP10]] to i64
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP12:%.*]] = ptrtoint i8* [[TMP9]] to i64
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP13:%.*]] = sub i64 [[TMP11]], [[TMP12]]
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP14:%.*]] = sdiv exact i64 [[TMP13]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP15:%.*]] = bitcast [7 x i64]* [[DOTOFFLOAD_SIZES]] to i8*
|
|
// CHECK-NOUSE-PPC64LE-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 [[TMP15]], i8* align 8 bitcast ([7 x i64]* @.offload_sizes to i8*), i64 56, i1 false)
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP16:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP17:%.*]] = bitcast i8** [[TMP16]] to %struct.ST**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP17]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP18:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP19:%.*]] = bitcast i8** [[TMP18]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[I]], i32** [[TMP19]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP20:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64 [[TMP7]], i64* [[TMP20]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP21:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP21]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP22:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP23:%.*]] = bitcast i8** [[TMP22]] to %struct.ST**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP23]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP24:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP25:%.*]] = bitcast i8** [[TMP24]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[I]], i32** [[TMP25]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP26:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP26]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP27:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP28:%.*]] = bitcast i8** [[TMP27]] to %struct.ST**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP28]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP29:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 2
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP30:%.*]] = bitcast i8** [[TMP29]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[J]], i32** [[TMP30]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP31:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP31]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP32:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP33:%.*]] = bitcast i8** [[TMP32]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[A]], i32** [[TMP33]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP34:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 3
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP35:%.*]] = bitcast i8** [[TMP34]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[A]], i32** [[TMP35]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP36:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 3
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP36]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP37:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP38:%.*]] = bitcast i8** [[TMP37]] to %struct.ST**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP38]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP39:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP40:%.*]] = bitcast i8** [[TMP39]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[I1]], i32** [[TMP40]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP41:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64 [[TMP14]], i64* [[TMP41]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP42:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP42]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP43:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP44:%.*]] = bitcast i8** [[TMP43]] to %struct.ST**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP44]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP45:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 5
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP46:%.*]] = bitcast i8** [[TMP45]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[I1]], i32** [[TMP46]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP47:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 5
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP47]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP48:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 6
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP49:%.*]] = bitcast i8** [[TMP48]] to %struct.ST**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP49]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP50:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 6
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP51:%.*]] = bitcast i8** [[TMP50]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[J2]], i32** [[TMP51]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP52:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 6
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP52]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP53:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP54:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP55:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP56:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 2, i32* [[TMP56]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP57:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 7, i32* [[TMP57]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP58:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 2
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** [[TMP53]], i8*** [[TMP58]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP59:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 3
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** [[TMP54]], i8*** [[TMP59]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP60:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64* [[TMP55]], i64** [[TMP60]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP61:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 5
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64* getelementptr inbounds ([7 x i64], [7 x i64]* @.offload_maptypes, i32 0, i32 0), i64** [[TMP61]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP62:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 6
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** null, i8*** [[TMP62]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP63:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 7
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** null, i8*** [[TMP63]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP64:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64 0, i64* [[TMP64]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP65:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 9
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64 0, i64* [[TMP65]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP66:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 10
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP66]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP67:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 11
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP67]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP68:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 12
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 0, i32* [[TMP68]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP69:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]])
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP70:%.*]] = icmp ne i32 [[TMP69]], 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: br i1 [[TMP70]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]]
|
|
// CHECK-NOUSE-PPC64LE: omp_offload.failed:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}() #[[ATTR3:[0-9]+]]
|
|
// CHECK-NOUSE-PPC64LE-NEXT: br label [[OMP_OFFLOAD_CONT]]
|
|
// CHECK-NOUSE-PPC64LE: omp_offload.cont:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP71:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_BASEPTRS3]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP72:%.*]] = bitcast i8** [[TMP71]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[A]], i32** [[TMP72]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP73:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_PTRS4]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP74:%.*]] = bitcast i8** [[TMP73]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[A]], i32** [[TMP74]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP75:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_MAPPERS5]], i64 0, i64 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP75]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP76:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_BASEPTRS3]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP77:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_PTRS4]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[KERNEL_ARGS6:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP78:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 2, i32* [[TMP78]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP79:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 1, i32* [[TMP79]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP80:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 2
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** [[TMP76]], i8*** [[TMP80]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP81:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 3
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** [[TMP77]], i8*** [[TMP81]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP82:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64* getelementptr inbounds ([1 x i64], [1 x i64]* @.offload_sizes.1, i32 0, i32 0), i64** [[TMP82]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP83:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 5
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64* getelementptr inbounds ([1 x i64], [1 x i64]* @.offload_maptypes.2, i32 0, i32 0), i64** [[TMP83]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP84:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 6
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** null, i8*** [[TMP84]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP85:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 7
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** null, i8*** [[TMP85]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP86:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64 0, i64* [[TMP86]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP87:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 9
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64 0, i64* [[TMP87]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP88:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 10
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP88]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP89:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 11
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP89]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP90:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 12
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 0, i32* [[TMP90]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP91:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]])
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP92:%.*]] = icmp ne i32 [[TMP91]], 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: br i1 [[TMP92]], label [[OMP_OFFLOAD_FAILED7:%.*]], label [[OMP_OFFLOAD_CONT8:%.*]]
|
|
// CHECK-NOUSE-PPC64LE: omp_offload.failed7:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}() #[[ATTR3]]
|
|
// CHECK-NOUSE-PPC64LE-NEXT: br label [[OMP_OFFLOAD_CONT8]]
|
|
// CHECK-NOUSE-PPC64LE: omp_offload.cont8:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-PPC64LE-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}
|
|
// CHECK-NOUSE-PPC64LE-SAME: () #[[ATTR1:[0-9]+]] {
|
|
// CHECK-NOUSE-PPC64LE-NEXT: entry:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-PPC64LE-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}
|
|
// CHECK-NOUSE-PPC64LE-SAME: () #[[ATTR1]] {
|
|
// CHECK-NOUSE-PPC64LE-NEXT: entry:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-PPC64LE-LABEL: define {{[^@]+}}@_ZN2ST20test_present_membersEv
|
|
// CHECK-NOUSE-PPC64LE-SAME: (%struct.ST* noundef nonnull align 4 dereferenceable(8) [[THIS:%.*]]) #[[ATTR0]] align 2 {
|
|
// CHECK-NOUSE-PPC64LE-NEXT: entry:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[THIS_ADDR:%.*]] = alloca %struct.ST*, align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [3 x i8*], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [3 x i8*], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [3 x i8*], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [3 x i64], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store %struct.ST* [[THIS]], %struct.ST** [[THIS_ADDR]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[THIS1:%.*]] = load %struct.ST*, %struct.ST** [[THIS_ADDR]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[THIS1]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[THIS1]], i32 0, i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP0:%.*]] = getelementptr i32, i32* [[J]], i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP1:%.*]] = bitcast i32* [[I]] to i8*
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP2:%.*]] = bitcast i32* [[TMP0]] to i8*
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP3:%.*]] = ptrtoint i8* [[TMP2]] to i64
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP4:%.*]] = ptrtoint i8* [[TMP1]] to i64
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP5:%.*]] = sub i64 [[TMP3]], [[TMP4]]
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP6:%.*]] = sdiv exact i64 [[TMP5]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP7:%.*]] = bitcast [3 x i64]* [[DOTOFFLOAD_SIZES]] to i8*
|
|
// CHECK-NOUSE-PPC64LE-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 [[TMP7]], i8* align 8 bitcast ([3 x i64]* @.offload_sizes.3 to i8*), i64 24, i1 false)
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP8:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP9:%.*]] = bitcast i8** [[TMP8]] to %struct.ST**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP9]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP10:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP11:%.*]] = bitcast i8** [[TMP10]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[I]], i32** [[TMP11]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP12:%.*]] = getelementptr inbounds [3 x i64], [3 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64 [[TMP6]], i64* [[TMP12]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP13:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP13]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP14:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP15:%.*]] = bitcast i8** [[TMP14]] to %struct.ST**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP15]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP16:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP17:%.*]] = bitcast i8** [[TMP16]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[I]], i32** [[TMP17]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP18:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP18]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP19:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP20:%.*]] = bitcast i8** [[TMP19]] to %struct.ST**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP20]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP21:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 2
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP22:%.*]] = bitcast i8** [[TMP21]] to i32**
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32* [[J]], i32** [[TMP22]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP23:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i64 0, i64 2
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8* null, i8** [[TMP23]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP24:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP25:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP26:%.*]] = getelementptr inbounds [3 x i64], [3 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP27:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 2, i32* [[TMP27]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP28:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 1
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 3, i32* [[TMP28]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP29:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 2
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** [[TMP24]], i8*** [[TMP29]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP30:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 3
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** [[TMP25]], i8*** [[TMP30]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP31:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64* [[TMP26]], i64** [[TMP31]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP32:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 5
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.4, i32 0, i32 0), i64** [[TMP32]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP33:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 6
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** null, i8*** [[TMP33]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP34:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 7
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i8** null, i8*** [[TMP34]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP35:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64 0, i64* [[TMP35]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP36:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 9
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i64 0, i64* [[TMP36]], align 8
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP37:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 10
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP37]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP38:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 11
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP38]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP39:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 12
|
|
// CHECK-NOUSE-PPC64LE-NEXT: store i32 0, i32* [[TMP39]], align 4
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP40:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]])
|
|
// CHECK-NOUSE-PPC64LE-NEXT: [[TMP41:%.*]] = icmp ne i32 [[TMP40]], 0
|
|
// CHECK-NOUSE-PPC64LE-NEXT: br i1 [[TMP41]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]]
|
|
// CHECK-NOUSE-PPC64LE: omp_offload.failed:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}() #[[ATTR3]]
|
|
// CHECK-NOUSE-PPC64LE-NEXT: br label [[OMP_OFFLOAD_CONT]]
|
|
// CHECK-NOUSE-PPC64LE: omp_offload.cont:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-PPC64LE-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}
|
|
// CHECK-NOUSE-PPC64LE-SAME: () #[[ATTR1]] {
|
|
// CHECK-NOUSE-PPC64LE-NEXT: entry:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-PPC64LE-LABEL: define {{[^@]+}}@.omp_offloading.requires_reg
|
|
// CHECK-NOUSE-PPC64LE-SAME: () #[[ATTR4:[0-9]+]] {
|
|
// CHECK-NOUSE-PPC64LE-NEXT: entry:
|
|
// CHECK-NOUSE-PPC64LE-NEXT: call void @__tgt_register_requires(i64 1)
|
|
// CHECK-NOUSE-PPC64LE-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-I386-LABEL: define {{[^@]+}}@_Z20explicit_maps_singlei
|
|
// CHECK-NOUSE-I386-SAME: (i32 noundef [[II:%.*]]) #[[ATTR0:[0-9]+]] {
|
|
// CHECK-NOUSE-I386-NEXT: entry:
|
|
// CHECK-NOUSE-I386-NEXT: [[II_ADDR:%.*]] = alloca i32, align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[ST1:%.*]] = alloca [[STRUCT_ST:%.*]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[ST2:%.*]] = alloca [[STRUCT_ST]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [7 x i8*], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [7 x i8*], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [7 x i8*], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [7 x i64], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_BASEPTRS3:%.*]] = alloca [1 x i8*], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_PTRS4:%.*]] = alloca [1 x i8*], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_MAPPERS5:%.*]] = alloca [1 x i8*], align 4
|
|
// CHECK-NOUSE-I386-NEXT: store i32 [[II]], i32* [[II_ADDR]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP0:%.*]] = load i32, i32* [[II_ADDR]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: store i32 [[TMP0]], i32* [[A]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST1]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST1]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP1:%.*]] = getelementptr i32, i32* [[J]], i32 1
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP2:%.*]] = bitcast i32* [[I]] to i8*
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP1]] to i8*
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP4:%.*]] = ptrtoint i8* [[TMP3]] to i64
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP5:%.*]] = ptrtoint i8* [[TMP2]] to i64
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP6:%.*]] = sub i64 [[TMP4]], [[TMP5]]
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP7:%.*]] = sdiv exact i64 [[TMP6]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-NOUSE-I386-NEXT: [[I1:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST2]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[J2:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[ST2]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP8:%.*]] = getelementptr i32, i32* [[J2]], i32 1
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP9:%.*]] = bitcast i32* [[I1]] to i8*
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP10:%.*]] = bitcast i32* [[TMP8]] to i8*
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP11:%.*]] = ptrtoint i8* [[TMP10]] to i64
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP12:%.*]] = ptrtoint i8* [[TMP9]] to i64
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP13:%.*]] = sub i64 [[TMP11]], [[TMP12]]
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP14:%.*]] = sdiv exact i64 [[TMP13]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP15:%.*]] = bitcast [7 x i64]* [[DOTOFFLOAD_SIZES]] to i8*
|
|
// CHECK-NOUSE-I386-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 [[TMP15]], i8* align 4 bitcast ([7 x i64]* @.offload_sizes to i8*), i32 56, i1 false)
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP16:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP17:%.*]] = bitcast i8** [[TMP16]] to %struct.ST**
|
|
// CHECK-NOUSE-I386-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP17]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP18:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP19:%.*]] = bitcast i8** [[TMP18]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[I]], i32** [[TMP19]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP20:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: store i64 [[TMP7]], i64* [[TMP20]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP21:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP21]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP22:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP23:%.*]] = bitcast i8** [[TMP22]] to %struct.ST**
|
|
// CHECK-NOUSE-I386-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP23]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP24:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP25:%.*]] = bitcast i8** [[TMP24]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[I]], i32** [[TMP25]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP26:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP26]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP27:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP28:%.*]] = bitcast i8** [[TMP27]] to %struct.ST**
|
|
// CHECK-NOUSE-I386-NEXT: store %struct.ST* [[ST1]], %struct.ST** [[TMP28]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP29:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 2
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP30:%.*]] = bitcast i8** [[TMP29]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[J]], i32** [[TMP30]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP31:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 2
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP31]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP32:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 3
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP33:%.*]] = bitcast i8** [[TMP32]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[A]], i32** [[TMP33]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP34:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 3
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP35:%.*]] = bitcast i8** [[TMP34]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[A]], i32** [[TMP35]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP36:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 3
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP36]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP37:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP38:%.*]] = bitcast i8** [[TMP37]] to %struct.ST**
|
|
// CHECK-NOUSE-I386-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP38]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP39:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP40:%.*]] = bitcast i8** [[TMP39]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[I1]], i32** [[TMP40]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP41:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 4
|
|
// CHECK-NOUSE-I386-NEXT: store i64 [[TMP14]], i64* [[TMP41]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP42:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 4
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP42]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP43:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 5
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP44:%.*]] = bitcast i8** [[TMP43]] to %struct.ST**
|
|
// CHECK-NOUSE-I386-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP44]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP45:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 5
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP46:%.*]] = bitcast i8** [[TMP45]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[I1]], i32** [[TMP46]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP47:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 5
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP47]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP48:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 6
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP49:%.*]] = bitcast i8** [[TMP48]] to %struct.ST**
|
|
// CHECK-NOUSE-I386-NEXT: store %struct.ST* [[ST2]], %struct.ST** [[TMP49]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP50:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 6
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP51:%.*]] = bitcast i8** [[TMP50]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[J2]], i32** [[TMP51]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP52:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 6
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP52]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP53:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP54:%.*]] = getelementptr inbounds [7 x i8*], [7 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP55:%.*]] = getelementptr inbounds [7 x i64], [7 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP56:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: store i32 2, i32* [[TMP56]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP57:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: store i32 7, i32* [[TMP57]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP58:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 2
|
|
// CHECK-NOUSE-I386-NEXT: store i8** [[TMP53]], i8*** [[TMP58]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP59:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 3
|
|
// CHECK-NOUSE-I386-NEXT: store i8** [[TMP54]], i8*** [[TMP59]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP60:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 4
|
|
// CHECK-NOUSE-I386-NEXT: store i64* [[TMP55]], i64** [[TMP60]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP61:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 5
|
|
// CHECK-NOUSE-I386-NEXT: store i64* getelementptr inbounds ([7 x i64], [7 x i64]* @.offload_maptypes, i32 0, i32 0), i64** [[TMP61]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP62:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 6
|
|
// CHECK-NOUSE-I386-NEXT: store i8** null, i8*** [[TMP62]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP63:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 7
|
|
// CHECK-NOUSE-I386-NEXT: store i8** null, i8*** [[TMP63]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP64:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 8
|
|
// CHECK-NOUSE-I386-NEXT: store i64 0, i64* [[TMP64]], align 8
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP65:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 9
|
|
// CHECK-NOUSE-I386-NEXT: store i64 0, i64* [[TMP65]], align 8
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP66:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 10
|
|
// CHECK-NOUSE-I386-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP66]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP67:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 11
|
|
// CHECK-NOUSE-I386-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP67]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP68:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 12
|
|
// CHECK-NOUSE-I386-NEXT: store i32 0, i32* [[TMP68]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP69:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1:[0-9]+]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]])
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP70:%.*]] = icmp ne i32 [[TMP69]], 0
|
|
// CHECK-NOUSE-I386-NEXT: br i1 [[TMP70]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]]
|
|
// CHECK-NOUSE-I386: omp_offload.failed:
|
|
// CHECK-NOUSE-I386-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}() #[[ATTR3:[0-9]+]]
|
|
// CHECK-NOUSE-I386-NEXT: br label [[OMP_OFFLOAD_CONT]]
|
|
// CHECK-NOUSE-I386: omp_offload.cont:
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP71:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_BASEPTRS3]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP72:%.*]] = bitcast i8** [[TMP71]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[A]], i32** [[TMP72]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP73:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_PTRS4]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP74:%.*]] = bitcast i8** [[TMP73]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[A]], i32** [[TMP74]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP75:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_MAPPERS5]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP75]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP76:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_BASEPTRS3]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP77:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[DOTOFFLOAD_PTRS4]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[KERNEL_ARGS6:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS]], align 8
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP78:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: store i32 2, i32* [[TMP78]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP79:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: store i32 1, i32* [[TMP79]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP80:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 2
|
|
// CHECK-NOUSE-I386-NEXT: store i8** [[TMP76]], i8*** [[TMP80]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP81:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 3
|
|
// CHECK-NOUSE-I386-NEXT: store i8** [[TMP77]], i8*** [[TMP81]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP82:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 4
|
|
// CHECK-NOUSE-I386-NEXT: store i64* getelementptr inbounds ([1 x i64], [1 x i64]* @.offload_sizes.1, i32 0, i32 0), i64** [[TMP82]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP83:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 5
|
|
// CHECK-NOUSE-I386-NEXT: store i64* getelementptr inbounds ([1 x i64], [1 x i64]* @.offload_maptypes.2, i32 0, i32 0), i64** [[TMP83]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP84:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 6
|
|
// CHECK-NOUSE-I386-NEXT: store i8** null, i8*** [[TMP84]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP85:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 7
|
|
// CHECK-NOUSE-I386-NEXT: store i8** null, i8*** [[TMP85]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP86:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 8
|
|
// CHECK-NOUSE-I386-NEXT: store i64 0, i64* [[TMP86]], align 8
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP87:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 9
|
|
// CHECK-NOUSE-I386-NEXT: store i64 0, i64* [[TMP87]], align 8
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP88:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 10
|
|
// CHECK-NOUSE-I386-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP88]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP89:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 11
|
|
// CHECK-NOUSE-I386-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP89]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP90:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]], i32 0, i32 12
|
|
// CHECK-NOUSE-I386-NEXT: store i32 0, i32* [[TMP90]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP91:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS6]])
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP92:%.*]] = icmp ne i32 [[TMP91]], 0
|
|
// CHECK-NOUSE-I386-NEXT: br i1 [[TMP92]], label [[OMP_OFFLOAD_FAILED7:%.*]], label [[OMP_OFFLOAD_CONT8:%.*]]
|
|
// CHECK-NOUSE-I386: omp_offload.failed7:
|
|
// CHECK-NOUSE-I386-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}() #[[ATTR3]]
|
|
// CHECK-NOUSE-I386-NEXT: br label [[OMP_OFFLOAD_CONT8]]
|
|
// CHECK-NOUSE-I386: omp_offload.cont8:
|
|
// CHECK-NOUSE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-I386-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}
|
|
// CHECK-NOUSE-I386-SAME: () #[[ATTR1:[0-9]+]] {
|
|
// CHECK-NOUSE-I386-NEXT: entry:
|
|
// CHECK-NOUSE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-I386-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__Z20explicit_maps_singlei_l{{[0-9]*}}
|
|
// CHECK-NOUSE-I386-SAME: () #[[ATTR1]] {
|
|
// CHECK-NOUSE-I386-NEXT: entry:
|
|
// CHECK-NOUSE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-I386-LABEL: define {{[^@]+}}@_ZN2ST20test_present_membersEv
|
|
// CHECK-NOUSE-I386-SAME: (%struct.ST* noundef nonnull align 4 dereferenceable(8) [[THIS:%.*]]) #[[ATTR0]] align 2 {
|
|
// CHECK-NOUSE-I386-NEXT: entry:
|
|
// CHECK-NOUSE-I386-NEXT: [[THIS_ADDR:%.*]] = alloca %struct.ST*, align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_BASEPTRS:%.*]] = alloca [3 x i8*], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_PTRS:%.*]] = alloca [3 x i8*], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_MAPPERS:%.*]] = alloca [3 x i8*], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[DOTOFFLOAD_SIZES:%.*]] = alloca [3 x i64], align 4
|
|
// CHECK-NOUSE-I386-NEXT: store %struct.ST* [[THIS]], %struct.ST** [[THIS_ADDR]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[THIS1:%.*]] = load %struct.ST*, %struct.ST** [[THIS_ADDR]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[I:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[THIS1]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[J:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[THIS1]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP0:%.*]] = getelementptr i32, i32* [[J]], i32 1
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP1:%.*]] = bitcast i32* [[I]] to i8*
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP2:%.*]] = bitcast i32* [[TMP0]] to i8*
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP3:%.*]] = ptrtoint i8* [[TMP2]] to i64
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP4:%.*]] = ptrtoint i8* [[TMP1]] to i64
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP5:%.*]] = sub i64 [[TMP3]], [[TMP4]]
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP6:%.*]] = sdiv exact i64 [[TMP5]], ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64)
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP7:%.*]] = bitcast [3 x i64]* [[DOTOFFLOAD_SIZES]] to i8*
|
|
// CHECK-NOUSE-I386-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 [[TMP7]], i8* align 4 bitcast ([3 x i64]* @.offload_sizes.3 to i8*), i32 24, i1 false)
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP8:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP9:%.*]] = bitcast i8** [[TMP8]] to %struct.ST**
|
|
// CHECK-NOUSE-I386-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP9]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP10:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP11:%.*]] = bitcast i8** [[TMP10]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[I]], i32** [[TMP11]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP12:%.*]] = getelementptr inbounds [3 x i64], [3 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: store i64 [[TMP6]], i64* [[TMP12]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP13:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP13]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP14:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP15:%.*]] = bitcast i8** [[TMP14]] to %struct.ST**
|
|
// CHECK-NOUSE-I386-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP15]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP16:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP17:%.*]] = bitcast i8** [[TMP16]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[I]], i32** [[TMP17]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP18:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP18]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP19:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 2
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP20:%.*]] = bitcast i8** [[TMP19]] to %struct.ST**
|
|
// CHECK-NOUSE-I386-NEXT: store %struct.ST* [[THIS1]], %struct.ST** [[TMP20]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP21:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 2
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP22:%.*]] = bitcast i8** [[TMP21]] to i32**
|
|
// CHECK-NOUSE-I386-NEXT: store i32* [[J]], i32** [[TMP22]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP23:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_MAPPERS]], i32 0, i32 2
|
|
// CHECK-NOUSE-I386-NEXT: store i8* null, i8** [[TMP23]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP24:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_BASEPTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP25:%.*]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[DOTOFFLOAD_PTRS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP26:%.*]] = getelementptr inbounds [3 x i64], [3 x i64]* [[DOTOFFLOAD_SIZES]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: [[KERNEL_ARGS:%.*]] = alloca [[STRUCT___TGT_KERNEL_ARGUMENTS:%.*]], align 8
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP27:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 0
|
|
// CHECK-NOUSE-I386-NEXT: store i32 2, i32* [[TMP27]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP28:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 1
|
|
// CHECK-NOUSE-I386-NEXT: store i32 3, i32* [[TMP28]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP29:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 2
|
|
// CHECK-NOUSE-I386-NEXT: store i8** [[TMP24]], i8*** [[TMP29]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP30:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 3
|
|
// CHECK-NOUSE-I386-NEXT: store i8** [[TMP25]], i8*** [[TMP30]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP31:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 4
|
|
// CHECK-NOUSE-I386-NEXT: store i64* [[TMP26]], i64** [[TMP31]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP32:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 5
|
|
// CHECK-NOUSE-I386-NEXT: store i64* getelementptr inbounds ([3 x i64], [3 x i64]* @.offload_maptypes.4, i32 0, i32 0), i64** [[TMP32]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP33:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 6
|
|
// CHECK-NOUSE-I386-NEXT: store i8** null, i8*** [[TMP33]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP34:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 7
|
|
// CHECK-NOUSE-I386-NEXT: store i8** null, i8*** [[TMP34]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP35:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 8
|
|
// CHECK-NOUSE-I386-NEXT: store i64 0, i64* [[TMP35]], align 8
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP36:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 9
|
|
// CHECK-NOUSE-I386-NEXT: store i64 0, i64* [[TMP36]], align 8
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP37:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 10
|
|
// CHECK-NOUSE-I386-NEXT: store [3 x i32] [i32 -1, i32 0, i32 0], [3 x i32]* [[TMP37]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP38:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 11
|
|
// CHECK-NOUSE-I386-NEXT: store [3 x i32] zeroinitializer, [3 x i32]* [[TMP38]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP39:%.*]] = getelementptr inbounds [[STRUCT___TGT_KERNEL_ARGUMENTS]], %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]], i32 0, i32 12
|
|
// CHECK-NOUSE-I386-NEXT: store i32 0, i32* [[TMP39]], align 4
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP40:%.*]] = call i32 @__tgt_target_kernel(%struct.ident_t* @[[GLOB1]], i64 -1, i32 -1, i32 0, i8* @.{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}.region_id, %struct.__tgt_kernel_arguments* [[KERNEL_ARGS]])
|
|
// CHECK-NOUSE-I386-NEXT: [[TMP41:%.*]] = icmp ne i32 [[TMP40]], 0
|
|
// CHECK-NOUSE-I386-NEXT: br i1 [[TMP41]], label [[OMP_OFFLOAD_FAILED:%.*]], label [[OMP_OFFLOAD_CONT:%.*]]
|
|
// CHECK-NOUSE-I386: omp_offload.failed:
|
|
// CHECK-NOUSE-I386-NEXT: call void @{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}() #[[ATTR3]]
|
|
// CHECK-NOUSE-I386-NEXT: br label [[OMP_OFFLOAD_CONT]]
|
|
// CHECK-NOUSE-I386: omp_offload.cont:
|
|
// CHECK-NOUSE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-I386-LABEL: define {{[^@]+}}@{{__omp_offloading_[0-9a-z]+_[0-9a-z]+}}__ZN2ST20test_present_membersEv_l{{[0-9]*}}
|
|
// CHECK-NOUSE-I386-SAME: () #[[ATTR1]] {
|
|
// CHECK-NOUSE-I386-NEXT: entry:
|
|
// CHECK-NOUSE-I386-NEXT: ret void
|
|
//
|
|
//
|
|
// CHECK-NOUSE-I386-LABEL: define {{[^@]+}}@.omp_offloading.requires_reg
|
|
// CHECK-NOUSE-I386-SAME: () #[[ATTR4:[0-9]+]] {
|
|
// CHECK-NOUSE-I386-NEXT: entry:
|
|
// CHECK-NOUSE-I386-NEXT: call void @__tgt_register_requires(i64 1)
|
|
// CHECK-NOUSE-I386-NEXT: ret void
|