mirror of
https://git.proxmox.com/git/llvm-toolchain
synced 2025-08-05 02:53:13 +00:00
New snapshot release
This commit is contained in:
Sylvestre Ledru
parent
e0a803917a
commit
56df40616a
6
debian/changelog
vendored
6
debian/changelog
vendored
@ -1,3 +1,9 @@
|
||||
llvm-toolchain-snapshot (1:9~svn362869-1~exp1) experimental; urgency=medium
|
||||
|
||||
* New snapshot release
|
||||
|
||||
-- Sylvestre Ledru <sylvestre@debian.org> Sat, 08 Jun 2019 10:57:39 +0200
|
||||
|
||||
llvm-toolchain-snapshot (1:9~svn358688-1~exp1) experimental; urgency=medium
|
||||
|
||||
* New snapshot release
|
||||
|
||||
17
debian/patches/D59702-mips64el-fix.diff
vendored
17
debian/patches/D59702-mips64el-fix.diff
vendored
@ -1,17 +0,0 @@
|
||||
Index: llvm-toolchain-8-8/compiler-rt/cmake/base-config-ix.cmake
|
||||
===================================================================
|
||||
--- llvm-toolchain-8-8.orig/compiler-rt/cmake/base-config-ix.cmake
|
||||
+++ llvm-toolchain-8-8/compiler-rt/cmake/base-config-ix.cmake
|
||||
@@ -195,10 +195,10 @@ macro(test_targets)
|
||||
# clang's default CPU's. In the 64-bit case, we must also specify the ABI
|
||||
# since the default ABI differs between gcc and clang.
|
||||
# FIXME: Ideally, we would build the N32 library too.
|
||||
- test_target_arch(mipsel "" "-mips32r2" "-mabi=32")
|
||||
+ test_target_arch(mipsel "" "-mips32r2" "-mabi=32" "-D_LARGEFILE_SOURCE" "-D_FILE_OFFSET_BITS=64")
|
||||
test_target_arch(mips64el "" "-mips64r2" "-mabi=64")
|
||||
elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "mips")
|
||||
- test_target_arch(mips "" "-mips32r2" "-mabi=32")
|
||||
+ test_target_arch(mips "" "-mips32r2" "-mabi=32" "-D_LARGEFILE_SOURCE" "-D_FILE_OFFSET_BITS=64")
|
||||
test_target_arch(mips64 "" "-mips64r2" "-mabi=64")
|
||||
elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "arm")
|
||||
if(WIN32)
|
||||
@ -1,152 +0,0 @@
|
||||
From 39a3ac0065c23d1e2d55dfd8792cc28a146a4307 Mon Sep 17 00:00:00 2001
|
||||
From: Alexey Bader <alexey.bader@intel.com>
|
||||
Date: Tue, 19 Feb 2019 15:19:06 +0000
|
||||
Subject: [PATCH 1/2] [OpenCL] Change type of block pointer for OpenCL
|
||||
|
||||
Summary:
|
||||
|
||||
For some reason OpenCL blocks in LLVM IR are represented as function pointers.
|
||||
These pointers do not point to any real function and never get called. Actually
|
||||
they point to some structure, which in turn contains pointer to the real block
|
||||
invoke function.
|
||||
This patch changes represntation of OpenCL blocks in LLVM IR from function
|
||||
pointers to pointers to `%struct.__block_literal_generic`.
|
||||
Such representation allows to avoid unnecessary bitcasts and simplifies
|
||||
further processing (e.g. translation to SPIR-V ) of the module for targets
|
||||
which do not support function pointers.
|
||||
|
||||
Patch by: Alexey Sotkin.
|
||||
|
||||
Reviewers: Anastasia, yaxunl, svenvh
|
||||
|
||||
Reviewed By: Anastasia
|
||||
|
||||
Subscribers: alexbatashev, cfe-commits
|
||||
|
||||
Tags: #clang
|
||||
|
||||
Differential Revision: https://reviews.llvm.org/D58277
|
||||
|
||||
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@354337 91177308-0d34-0410-b5e6-96231b3b80d8
|
||||
---
|
||||
lib/CodeGen/CodeGenTypes.cpp | 4 +++-
|
||||
test/CodeGenOpenCL/blocks.cl | 18 ++++++++----------
|
||||
test/CodeGenOpenCL/cl20-device-side-enqueue.cl | 18 +++++++++---------
|
||||
3 files changed, 20 insertions(+), 20 deletions(-)
|
||||
|
||||
diff --git a/lib/CodeGen/CodeGenTypes.cpp b/lib/CodeGen/CodeGenTypes.cpp
|
||||
index 2acf1ac..93b3ebf 100644
|
||||
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
|
||||
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
|
||||
@@ -637,7 +637,9 @@ llvm::Type *CodeGenTypes::ConvertType(QualType T) {
|
||||
|
||||
case Type::BlockPointer: {
|
||||
const QualType FTy = cast<BlockPointerType>(Ty)->getPointeeType();
|
||||
- llvm::Type *PointeeType = ConvertTypeForMem(FTy);
|
||||
+ llvm::Type *PointeeType = CGM.getLangOpts().OpenCL
|
||||
+ ? CGM.getGenericBlockLiteralType()
|
||||
+ : ConvertTypeForMem(FTy);
|
||||
unsigned AS = Context.getTargetAddressSpace(FTy);
|
||||
ResultType = llvm::PointerType::get(PointeeType, AS);
|
||||
break;
|
||||
diff --git a/test/CodeGenOpenCL/blocks.cl b/test/CodeGenOpenCL/blocks.cl
|
||||
index 675240c..19aacc3 100644
|
||||
--- a/clang/test/CodeGenOpenCL/blocks.cl
|
||||
+++ b/clang/test/CodeGenOpenCL/blocks.cl
|
||||
@@ -35,11 +35,10 @@ void foo(){
|
||||
// SPIR: %[[block_captured:.*]] = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 }>, <{ i32, i32, i8 addrspace(4)*, i32 }>* %[[block]], i32 0, i32 3
|
||||
// SPIR: %[[i_value:.*]] = load i32, i32* %i
|
||||
// SPIR: store i32 %[[i_value]], i32* %[[block_captured]],
|
||||
- // SPIR: %[[blk_ptr:.*]] = bitcast <{ i32, i32, i8 addrspace(4)*, i32 }>* %[[block]] to i32 ()*
|
||||
- // SPIR: %[[blk_gen_ptr:.*]] = addrspacecast i32 ()* %[[blk_ptr]] to i32 () addrspace(4)*
|
||||
- // SPIR: store i32 () addrspace(4)* %[[blk_gen_ptr]], i32 () addrspace(4)** %[[block_B:.*]],
|
||||
- // SPIR: %[[blk_gen_ptr:.*]] = load i32 () addrspace(4)*, i32 () addrspace(4)** %[[block_B]]
|
||||
- // SPIR: %[[block_literal:.*]] = bitcast i32 () addrspace(4)* %[[blk_gen_ptr]] to %struct.__opencl_block_literal_generic addrspace(4)*
|
||||
+ // SPIR: %[[blk_ptr:.*]] = bitcast <{ i32, i32, i8 addrspace(4)*, i32 }>* %[[block]] to %struct.__opencl_block_literal_generic*
|
||||
+ // SPIR: %[[blk_gen_ptr:.*]] = addrspacecast %struct.__opencl_block_literal_generic* %[[blk_ptr]] to %struct.__opencl_block_literal_generic addrspace(4)*
|
||||
+ // SPIR: store %struct.__opencl_block_literal_generic addrspace(4)* %[[blk_gen_ptr]], %struct.__opencl_block_literal_generic addrspace(4)** %[[block_B:.*]],
|
||||
+ // SPIR: %[[block_literal:.*]] = load %struct.__opencl_block_literal_generic addrspace(4)*, %struct.__opencl_block_literal_generic addrspace(4)** %[[block_B]]
|
||||
// SPIR: %[[invoke_addr:.*]] = getelementptr inbounds %struct.__opencl_block_literal_generic, %struct.__opencl_block_literal_generic addrspace(4)* %[[block_literal]], i32 0, i32 2
|
||||
// SPIR: %[[blk_gen_ptr:.*]] = bitcast %struct.__opencl_block_literal_generic addrspace(4)* %[[block_literal]] to i8 addrspace(4)*
|
||||
// SPIR: %[[invoke_func_ptr:.*]] = load i8 addrspace(4)*, i8 addrspace(4)* addrspace(4)* %[[invoke_addr]]
|
||||
@@ -50,11 +49,10 @@ void foo(){
|
||||
// AMDGCN: %[[block_captured:.*]] = getelementptr inbounds <{ i32, i32, i8*, i32 }>, <{ i32, i32, i8*, i32 }> addrspace(5)* %[[block]], i32 0, i32 3
|
||||
// AMDGCN: %[[i_value:.*]] = load i32, i32 addrspace(5)* %i
|
||||
// AMDGCN: store i32 %[[i_value]], i32 addrspace(5)* %[[block_captured]],
|
||||
- // AMDGCN: %[[blk_ptr:.*]] = bitcast <{ i32, i32, i8*, i32 }> addrspace(5)* %[[block]] to i32 () addrspace(5)*
|
||||
- // AMDGCN: %[[blk_gen_ptr:.*]] = addrspacecast i32 () addrspace(5)* %[[blk_ptr]] to i32 ()*
|
||||
- // AMDGCN: store i32 ()* %[[blk_gen_ptr]], i32 ()* addrspace(5)* %[[block_B:.*]],
|
||||
- // AMDGCN: %[[blk_gen_ptr:.*]] = load i32 ()*, i32 ()* addrspace(5)* %[[block_B]]
|
||||
- // AMDGCN: %[[block_literal:.*]] = bitcast i32 ()* %[[blk_gen_ptr]] to %struct.__opencl_block_literal_generic*
|
||||
+ // AMDGCN: %[[blk_ptr:.*]] = bitcast <{ i32, i32, i8*, i32 }> addrspace(5)* %[[block]] to %struct.__opencl_block_literal_generic addrspace(5)*
|
||||
+ // AMDGCN: %[[blk_gen_ptr:.*]] = addrspacecast %struct.__opencl_block_literal_generic addrspace(5)* %[[blk_ptr]] to %struct.__opencl_block_literal_generic*
|
||||
+ // AMDGCN: store %struct.__opencl_block_literal_generic* %[[blk_gen_ptr]], %struct.__opencl_block_literal_generic* addrspace(5)* %[[block_B:.*]],
|
||||
+ // AMDGCN: %[[block_literal:.*]] = load %struct.__opencl_block_literal_generic*, %struct.__opencl_block_literal_generic* addrspace(5)* %[[block_B]]
|
||||
// AMDGCN: %[[invoke_addr:.*]] = getelementptr inbounds %struct.__opencl_block_literal_generic, %struct.__opencl_block_literal_generic* %[[block_literal]], i32 0, i32 2
|
||||
// AMDGCN: %[[blk_gen_ptr:.*]] = bitcast %struct.__opencl_block_literal_generic* %[[block_literal]] to i8*
|
||||
// AMDGCN: %[[invoke_func_ptr:.*]] = load i8*, i8** %[[invoke_addr]]
|
||||
diff --git a/test/CodeGenOpenCL/cl20-device-side-enqueue.cl b/test/CodeGenOpenCL/cl20-device-side-enqueue.cl
|
||||
index 4732194..8445016 100644
|
||||
--- a/clang/test/CodeGenOpenCL/cl20-device-side-enqueue.cl
|
||||
+++ b/clang/test/CodeGenOpenCL/cl20-device-side-enqueue.cl
|
||||
@@ -11,7 +11,7 @@ typedef struct {int a;} ndrange_t;
|
||||
|
||||
// For a block global variable, first emit the block literal as a global variable, then emit the block variable itself.
|
||||
// COMMON: [[BL_GLOBAL:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32, i8 addrspace(4)* } { i32 {{[0-9]+}}, i32 {{[0-9]+}}, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*, i8 addrspace(3)*)* [[INV_G:@[^ ]+]] to i8*) to i8 addrspace(4)*) }
|
||||
-// COMMON: @block_G = addrspace(1) constant void (i8 addrspace(3)*) addrspace(4)* addrspacecast (void (i8 addrspace(3)*) addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BL_GLOBAL]] to void (i8 addrspace(3)*) addrspace(1)*) to void (i8 addrspace(3)*) addrspace(4)*)
|
||||
+// COMMON: @block_G = addrspace(1) constant %struct.__opencl_block_literal_generic addrspace(4)* addrspacecast (%struct.__opencl_block_literal_generic addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BL_GLOBAL]] to %struct.__opencl_block_literal_generic addrspace(1)*) to %struct.__opencl_block_literal_generic addrspace(4)*)
|
||||
|
||||
// For anonymous blocks without captures, emit block literals as global variable.
|
||||
// COMMON: [[BLG1:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32, i8 addrspace(4)* } { i32 {{[0-9]+}}, i32 {{[0-9]+}}, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*, i8 addrspace(3)*)* {{@[^ ]+}} to i8*) to i8 addrspace(4)*) }
|
||||
@@ -77,9 +77,9 @@ kernel void device_side_enqueue(global int *a, global int *b, int i) {
|
||||
// COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
|
||||
// COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
|
||||
// COMMON: store i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*)* [[INVL1:@__device_side_enqueue_block_invoke[^ ]*]] to i8*) to i8 addrspace(4)*), i8 addrspace(4)** %block.invoke
|
||||
- // B32: [[BL:%[0-9]+]] = bitcast <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block to void ()*
|
||||
- // B64: [[BL:%[0-9]+]] = bitcast <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32 addrspace(1)*, i32 }>* %block to void ()*
|
||||
- // COMMON: [[BL_I8:%[0-9]+]] = addrspacecast void ()* [[BL]] to i8 addrspace(4)*
|
||||
+ // B32: [[BL:%[0-9]+]] = bitcast <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block to %struct.__opencl_block_literal_generic*
|
||||
+ // B64: [[BL:%[0-9]+]] = bitcast <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32 addrspace(1)*, i32 }>* %block to %struct.__opencl_block_literal_generic*
|
||||
+ // COMMON: [[BL_I8:%[0-9]+]] = addrspacecast %struct.__opencl_block_literal_generic* [[BL]] to i8 addrspace(4)*
|
||||
// COMMON-LABEL: call i32 @__enqueue_kernel_basic(
|
||||
// COMMON-SAME: %opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* byval [[NDR]]{{([0-9]+)?}},
|
||||
// COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVLK1:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*),
|
||||
@@ -95,8 +95,8 @@ kernel void device_side_enqueue(global int *a, global int *b, int i) {
|
||||
// COMMON: [[WAIT_EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %event_wait_list to %opencl.clk_event_t{{.*}}* addrspace(4)*
|
||||
// COMMON: [[EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %clk_event to %opencl.clk_event_t{{.*}}* addrspace(4)*
|
||||
// COMMON: store i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*)* [[INVL2:@__device_side_enqueue_block_invoke[^ ]*]] to i8*) to i8 addrspace(4)*), i8 addrspace(4)** %block.invoke
|
||||
- // COMMON: [[BL:%[0-9]+]] = bitcast <{ i32, i32, i8 addrspace(4)*, i32{{.*}}, i32{{.*}}, i32{{.*}} }>* %block3 to void ()*
|
||||
- // COMMON: [[BL_I8:%[0-9]+]] = addrspacecast void ()* [[BL]] to i8 addrspace(4)*
|
||||
+ // COMMON: [[BL:%[0-9]+]] = bitcast <{ i32, i32, i8 addrspace(4)*, i32{{.*}}, i32{{.*}}, i32{{.*}} }>* %block3 to %struct.__opencl_block_literal_generic*
|
||||
+ // COMMON: [[BL_I8:%[0-9]+]] = addrspacecast %struct.__opencl_block_literal_generic* [[BL]] to i8 addrspace(4)*
|
||||
// COMMON-LABEL: call i32 @__enqueue_kernel_basic_events
|
||||
// COMMON-SAME: (%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}}* addrspace(4)* [[WAIT_EVNT]], %opencl.clk_event_t{{.*}}* addrspace(4)* [[EVNT]],
|
||||
// COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVLK2:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*),
|
||||
@@ -300,13 +300,13 @@ kernel void device_side_enqueue(global int *a, global int *b, int i) {
|
||||
// Emits global block literal [[BLG8]] and invoke function [[INVG8]].
|
||||
// The full type of these expressions are long (and repeated elsewhere), so we
|
||||
// capture it as part of the regex for convenience and clarity.
|
||||
- // COMMON: store void () addrspace(4)* addrspacecast (void () addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to void () addrspace(1)*) to void () addrspace(4)*), void () addrspace(4)** %block_A
|
||||
+ // COMMON: store %struct.__opencl_block_literal_generic addrspace(4)* addrspacecast (%struct.__opencl_block_literal_generic addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to %struct.__opencl_block_literal_generic addrspace(1)*) to %struct.__opencl_block_literal_generic addrspace(4)*), %struct.__opencl_block_literal_generic addrspace(4)** %block_A
|
||||
void (^const block_A)(void) = ^{
|
||||
return;
|
||||
};
|
||||
|
||||
// Emits global block literal [[BLG9]] and invoke function [[INVG9]].
|
||||
- // COMMON: store void (i8 addrspace(3)*) addrspace(4)* addrspacecast (void (i8 addrspace(3)*) addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG9]] to void (i8 addrspace(3)*) addrspace(1)*) to void (i8 addrspace(3)*) addrspace(4)*), void (i8 addrspace(3)*) addrspace(4)** %block_B
|
||||
+ // COMMON: store %struct.__opencl_block_literal_generic addrspace(4)* addrspacecast (%struct.__opencl_block_literal_generic addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG9]] to %struct.__opencl_block_literal_generic addrspace(1)*) to %struct.__opencl_block_literal_generic addrspace(4)*), %struct.__opencl_block_literal_generic addrspace(4)** %block_B
|
||||
void (^const block_B)(local void *) = ^(local void *a) {
|
||||
return;
|
||||
};
|
||||
@@ -346,7 +346,7 @@ kernel void device_side_enqueue(global int *a, global int *b, int i) {
|
||||
// COMMON: store i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*)* [[INVL3:@__device_side_enqueue_block_invoke[^ ]*]] to i8*) to i8 addrspace(4)*), i8 addrspace(4)** %block.invoke
|
||||
// COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
|
||||
// COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
|
||||
- // COMMON: [[BL_I8:%[0-9]+]] = addrspacecast void ()* {{.*}} to i8 addrspace(4)*
|
||||
+ // COMMON: [[BL_I8:%[0-9]+]] = addrspacecast %struct.__opencl_block_literal_generic* {{.*}} to i8 addrspace(4)*
|
||||
// COMMON-LABEL: call i32 @__enqueue_kernel_basic(
|
||||
// COMMON-SAME: %opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* byval [[NDR]]{{([0-9]+)?}},
|
||||
// COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVLK3:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*),
|
||||
--
|
||||
1.8.3.1
|
||||
|
||||
@ -1,57 +0,0 @@
|
||||
From 29e2813a2ab7d5569860bb07892dfef7b5374d96 Mon Sep 17 00:00:00 2001
|
||||
From: Yaxun Liu <Yaxun.Liu@amd.com>
|
||||
Date: Tue, 26 Feb 2019 16:20:41 +0000
|
||||
Subject: [PATCH] [OpenCL] Fix assertion due to blocks
|
||||
|
||||
A recent change caused assertion in CodeGenFunction::EmitBlockCallExpr when a block is called.
|
||||
|
||||
There is code
|
||||
|
||||
Func = CGM.getOpenCLRuntime().getInvokeFunction(E->getCallee());
|
||||
getCalleeDecl calls Expr::getReferencedDeclOfCallee, which does not handle
|
||||
BlockExpr and returns nullptr, which causes isa to assert.
|
||||
|
||||
This patch fixes that.
|
||||
|
||||
Differential Revision: https://reviews.llvm.org/D58658
|
||||
|
||||
|
||||
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@354893 91177308-0d34-0410-b5e6-96231b3b80d8
|
||||
---
|
||||
lib/AST/Expr.cpp | 2 ++
|
||||
test/CodeGenOpenCL/blocks.cl | 6 ++++++
|
||||
2 files changed, 8 insertions(+)
|
||||
|
||||
diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
|
||||
index aef1eab..85690c7 100644
|
||||
--- a/clang/lib/AST/Expr.cpp
|
||||
+++ b/clang/lib/AST/Expr.cpp
|
||||
@@ -1358,6 +1358,8 @@ Decl *Expr::getReferencedDeclOfCallee() {
|
||||
return DRE->getDecl();
|
||||
if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
|
||||
return ME->getMemberDecl();
|
||||
+ if (auto *BE = dyn_cast<BlockExpr>(CEE))
|
||||
+ return BE->getBlockDecl();
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
diff --git a/clang/test/CodeGenOpenCL/blocks.cl b/clang/test/CodeGenOpenCL/blocks.cl
|
||||
index ab5a2c6..c3e2685 100644
|
||||
--- a/clang/test/CodeGenOpenCL/blocks.cl
|
||||
+++ b/clang/test/CodeGenOpenCL/blocks.cl
|
||||
@@ -90,6 +90,12 @@ int get42() {
|
||||
return blockArgFunc(^{return 42;});
|
||||
}
|
||||
|
||||
+// COMMON-LABEL: define {{.*}}@call_block
|
||||
+// call {{.*}}@__call_block_block_invoke
|
||||
+int call_block() {
|
||||
+ return ^int(int num) { return num; } (11);
|
||||
+}
|
||||
+
|
||||
// CHECK-DEBUG: !DIDerivedType(tag: DW_TAG_member, name: "__size"
|
||||
// CHECK-DEBUG: !DIDerivedType(tag: DW_TAG_member, name: "__align"
|
||||
|
||||
--
|
||||
1.8.3.1
|
||||
|
||||
@ -1,290 +0,0 @@
|
||||
From c94ec28600255098ffb9d73d1b386a7c8a535590 Mon Sep 17 00:00:00 2001
|
||||
From: Andrew Savonichev <andrew.savonichev@intel.com>
|
||||
Date: Thu, 21 Feb 2019 11:02:10 +0000
|
||||
Subject: [PATCH 2/2] [OpenCL] Simplify LLVM IR generated for OpenCL blocks
|
||||
|
||||
Summary:
|
||||
Emit direct call of block invoke functions when possible, i.e. in case the
|
||||
block is not passed as a function argument.
|
||||
Also doing some refactoring of `CodeGenFunction::EmitBlockCallExpr()`
|
||||
|
||||
Reviewers: Anastasia, yaxunl, svenvh
|
||||
|
||||
Reviewed By: Anastasia
|
||||
|
||||
Subscribers: cfe-commits
|
||||
|
||||
Tags: #clang
|
||||
|
||||
Differential Revision: https://reviews.llvm.org/D58388
|
||||
|
||||
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@354568 91177308-0d34-0410-b5e6-96231b3b80d8
|
||||
---
|
||||
lib/CodeGen/CGBlocks.cpp | 77 +++++++++++++-------------
|
||||
lib/CodeGen/CGOpenCLRuntime.cpp | 30 +++++++---
|
||||
lib/CodeGen/CGOpenCLRuntime.h | 4 ++
|
||||
test/CodeGenOpenCL/blocks.cl | 10 +---
|
||||
test/CodeGenOpenCL/cl20-device-side-enqueue.cl | 34 +++++++++---
|
||||
5 files changed, 91 insertions(+), 64 deletions(-)
|
||||
|
||||
diff --git a/clang/lib/CodeGen/CGBlocks.cpp b/clang/lib/CodeGen/CGBlocks.cpp
|
||||
index fa3c3ee..10a0238 100644
|
||||
--- a/clang/lib/CodeGen/CGBlocks.cpp
|
||||
+++ b/clang/lib/CodeGen/CGBlocks.cpp
|
||||
@@ -1261,52 +1261,49 @@ RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E,
|
||||
ReturnValueSlot ReturnValue) {
|
||||
const BlockPointerType *BPT =
|
||||
E->getCallee()->getType()->getAs<BlockPointerType>();
|
||||
-
|
||||
llvm::Value *BlockPtr = EmitScalarExpr(E->getCallee());
|
||||
-
|
||||
- // Get a pointer to the generic block literal.
|
||||
- // For OpenCL we generate generic AS void ptr to be able to reuse the same
|
||||
- // block definition for blocks with captures generated as private AS local
|
||||
- // variables and without captures generated as global AS program scope
|
||||
- // variables.
|
||||
- unsigned AddrSpace = 0;
|
||||
- if (getLangOpts().OpenCL)
|
||||
- AddrSpace = getContext().getTargetAddressSpace(LangAS::opencl_generic);
|
||||
-
|
||||
- llvm::Type *BlockLiteralTy =
|
||||
- llvm::PointerType::get(CGM.getGenericBlockLiteralType(), AddrSpace);
|
||||
-
|
||||
- // Bitcast the callee to a block literal.
|
||||
- BlockPtr =
|
||||
- Builder.CreatePointerCast(BlockPtr, BlockLiteralTy, "block.literal");
|
||||
-
|
||||
- // Get the function pointer from the literal.
|
||||
- llvm::Value *FuncPtr =
|
||||
- Builder.CreateStructGEP(CGM.getGenericBlockLiteralType(), BlockPtr,
|
||||
- CGM.getLangOpts().OpenCL ? 2 : 3);
|
||||
-
|
||||
- // Add the block literal.
|
||||
+ llvm::Type *GenBlockTy = CGM.getGenericBlockLiteralType();
|
||||
+ llvm::Value *Func = nullptr;
|
||||
+ QualType FnType = BPT->getPointeeType();
|
||||
+ ASTContext &Ctx = getContext();
|
||||
CallArgList Args;
|
||||
|
||||
- QualType VoidPtrQualTy = getContext().VoidPtrTy;
|
||||
- llvm::Type *GenericVoidPtrTy = VoidPtrTy;
|
||||
if (getLangOpts().OpenCL) {
|
||||
- GenericVoidPtrTy = CGM.getOpenCLRuntime().getGenericVoidPointerType();
|
||||
- VoidPtrQualTy =
|
||||
- getContext().getPointerType(getContext().getAddrSpaceQualType(
|
||||
- getContext().VoidTy, LangAS::opencl_generic));
|
||||
- }
|
||||
-
|
||||
- BlockPtr = Builder.CreatePointerCast(BlockPtr, GenericVoidPtrTy);
|
||||
- Args.add(RValue::get(BlockPtr), VoidPtrQualTy);
|
||||
-
|
||||
- QualType FnType = BPT->getPointeeType();
|
||||
+ // For OpenCL, BlockPtr is already casted to generic block literal.
|
||||
+
|
||||
+ // First argument of a block call is a generic block literal casted to
|
||||
+ // generic void pointer, i.e. i8 addrspace(4)*
|
||||
+ llvm::Value *BlockDescriptor = Builder.CreatePointerCast(
|
||||
+ BlockPtr, CGM.getOpenCLRuntime().getGenericVoidPointerType());
|
||||
+ QualType VoidPtrQualTy = Ctx.getPointerType(
|
||||
+ Ctx.getAddrSpaceQualType(Ctx.VoidTy, LangAS::opencl_generic));
|
||||
+ Args.add(RValue::get(BlockDescriptor), VoidPtrQualTy);
|
||||
+ // And the rest of the arguments.
|
||||
+ EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(), E->arguments());
|
||||
+
|
||||
+ // We *can* call the block directly unless it is a function argument.
|
||||
+ if (!isa<ParmVarDecl>(E->getCalleeDecl()))
|
||||
+ Func = CGM.getOpenCLRuntime().getInvokeFunction(E->getCallee());
|
||||
+ else {
|
||||
+ llvm::Value *FuncPtr = Builder.CreateStructGEP(GenBlockTy, BlockPtr, 2);
|
||||
+ Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign());
|
||||
+ }
|
||||
+ } else {
|
||||
+ // Bitcast the block literal to a generic block literal.
|
||||
+ BlockPtr = Builder.CreatePointerCast(
|
||||
+ BlockPtr, llvm::PointerType::get(GenBlockTy, 0), "block.literal");
|
||||
+ // Get pointer to the block invoke function
|
||||
+ llvm::Value *FuncPtr = Builder.CreateStructGEP(GenBlockTy, BlockPtr, 3);
|
||||
|
||||
- // And the rest of the arguments.
|
||||
- EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(), E->arguments());
|
||||
+ // First argument is a block literal casted to a void pointer
|
||||
+ BlockPtr = Builder.CreatePointerCast(BlockPtr, VoidPtrTy);
|
||||
+ Args.add(RValue::get(BlockPtr), Ctx.VoidPtrTy);
|
||||
+ // And the rest of the arguments.
|
||||
+ EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(), E->arguments());
|
||||
|
||||
- // Load the function.
|
||||
- llvm::Value *Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign());
|
||||
+ // Load the function.
|
||||
+ Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign());
|
||||
+ }
|
||||
|
||||
const FunctionType *FuncTy = FnType->castAs<FunctionType>();
|
||||
const CGFunctionInfo &FnInfo =
|
||||
diff --git a/clang/lib/CodeGen/CGOpenCLRuntime.cpp b/clang/lib/CodeGen/CGOpenCLRuntime.cpp
|
||||
index 7f6f595..75003e5 100644
|
||||
--- a/clang/lib/CodeGen/CGOpenCLRuntime.cpp
|
||||
+++ b/clang/lib/CodeGen/CGOpenCLRuntime.cpp
|
||||
@@ -123,6 +123,23 @@ llvm::PointerType *CGOpenCLRuntime::getGenericVoidPointerType() {
|
||||
CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic));
|
||||
}
|
||||
|
||||
+// Get the block literal from an expression derived from the block expression.
|
||||
+// OpenCL v2.0 s6.12.5:
|
||||
+// Block variable declarations are implicitly qualified with const. Therefore
|
||||
+// all block variables must be initialized at declaration time and may not be
|
||||
+// reassigned.
|
||||
+static const BlockExpr *getBlockExpr(const Expr *E) {
|
||||
+ const Expr *Prev = nullptr; // to make sure we do not stuck in infinite loop.
|
||||
+ while(!isa<BlockExpr>(E) && E != Prev) {
|
||||
+ Prev = E;
|
||||
+ E = E->IgnoreCasts();
|
||||
+ if (auto DR = dyn_cast<DeclRefExpr>(E)) {
|
||||
+ E = cast<VarDecl>(DR->getDecl())->getInit();
|
||||
+ }
|
||||
+ }
|
||||
+ return cast<BlockExpr>(E);
|
||||
+}
|
||||
+
|
||||
/// Record emitted llvm invoke function and llvm block literal for the
|
||||
/// corresponding block expression.
|
||||
void CGOpenCLRuntime::recordBlockInfo(const BlockExpr *E,
|
||||
@@ -137,20 +154,17 @@ void CGOpenCLRuntime::recordBlockInfo(const BlockExpr *E,
|
||||
EnqueuedBlockMap[E].Kernel = nullptr;
|
||||
}
|
||||
|
||||
+llvm::Function *CGOpenCLRuntime::getInvokeFunction(const Expr *E) {
|
||||
+ return EnqueuedBlockMap[getBlockExpr(E)].InvokeFunc;
|
||||
+}
|
||||
+
|
||||
CGOpenCLRuntime::EnqueuedBlockInfo
|
||||
CGOpenCLRuntime::emitOpenCLEnqueuedBlock(CodeGenFunction &CGF, const Expr *E) {
|
||||
CGF.EmitScalarExpr(E);
|
||||
|
||||
// The block literal may be assigned to a const variable. Chasing down
|
||||
// to get the block literal.
|
||||
- if (auto DR = dyn_cast<DeclRefExpr>(E)) {
|
||||
- E = cast<VarDecl>(DR->getDecl())->getInit();
|
||||
- }
|
||||
- E = E->IgnoreImplicit();
|
||||
- if (auto Cast = dyn_cast<CastExpr>(E)) {
|
||||
- E = Cast->getSubExpr();
|
||||
- }
|
||||
- auto *Block = cast<BlockExpr>(E);
|
||||
+ const BlockExpr *Block = getBlockExpr(E);
|
||||
|
||||
assert(EnqueuedBlockMap.find(Block) != EnqueuedBlockMap.end() &&
|
||||
"Block expression not emitted");
|
||||
diff --git a/clang/lib/CodeGen/CGOpenCLRuntime.h b/clang/lib/CodeGen/CGOpenCLRuntime.h
|
||||
index 750721f..4effc7e 100644
|
||||
--- a/clang/lib/CodeGen/CGOpenCLRuntime.h
|
||||
+++ b/clang/lib/CodeGen/CGOpenCLRuntime.h
|
||||
@@ -92,6 +92,10 @@ public:
|
||||
/// \param Block block literal emitted for the block expression.
|
||||
void recordBlockInfo(const BlockExpr *E, llvm::Function *InvokeF,
|
||||
llvm::Value *Block);
|
||||
+
|
||||
+ /// \return LLVM block invoke function emitted for an expression derived from
|
||||
+ /// the block expression.
|
||||
+ llvm::Function *getInvokeFunction(const Expr *E);
|
||||
};
|
||||
|
||||
}
|
||||
diff --git a/clang/test/CodeGenOpenCL/blocks.cl b/clang/test/CodeGenOpenCL/blocks.cl
|
||||
index 19aacc3..ab5a2c6 100644
|
||||
--- a/clang/test/CodeGenOpenCL/blocks.cl
|
||||
+++ b/clang/test/CodeGenOpenCL/blocks.cl
|
||||
@@ -39,11 +39,8 @@ void foo(){
|
||||
// SPIR: %[[blk_gen_ptr:.*]] = addrspacecast %struct.__opencl_block_literal_generic* %[[blk_ptr]] to %struct.__opencl_block_literal_generic addrspace(4)*
|
||||
// SPIR: store %struct.__opencl_block_literal_generic addrspace(4)* %[[blk_gen_ptr]], %struct.__opencl_block_literal_generic addrspace(4)** %[[block_B:.*]],
|
||||
// SPIR: %[[block_literal:.*]] = load %struct.__opencl_block_literal_generic addrspace(4)*, %struct.__opencl_block_literal_generic addrspace(4)** %[[block_B]]
|
||||
- // SPIR: %[[invoke_addr:.*]] = getelementptr inbounds %struct.__opencl_block_literal_generic, %struct.__opencl_block_literal_generic addrspace(4)* %[[block_literal]], i32 0, i32 2
|
||||
// SPIR: %[[blk_gen_ptr:.*]] = bitcast %struct.__opencl_block_literal_generic addrspace(4)* %[[block_literal]] to i8 addrspace(4)*
|
||||
- // SPIR: %[[invoke_func_ptr:.*]] = load i8 addrspace(4)*, i8 addrspace(4)* addrspace(4)* %[[invoke_addr]]
|
||||
- // SPIR: %[[invoke_func:.*]] = addrspacecast i8 addrspace(4)* %[[invoke_func_ptr]] to i32 (i8 addrspace(4)*)*
|
||||
- // SPIR: call {{.*}}i32 %[[invoke_func]](i8 addrspace(4)* %[[blk_gen_ptr]])
|
||||
+ // SPIR: call {{.*}}i32 @__foo_block_invoke(i8 addrspace(4)* %[[blk_gen_ptr]])
|
||||
// AMDGCN: %[[block_invoke:.*]] = getelementptr inbounds <{ i32, i32, i8*, i32 }>, <{ i32, i32, i8*, i32 }> addrspace(5)* %[[block:.*]], i32 0, i32 2
|
||||
// AMDGCN: store i8* bitcast (i32 (i8*)* @__foo_block_invoke to i8*), i8* addrspace(5)* %[[block_invoke]]
|
||||
// AMDGCN: %[[block_captured:.*]] = getelementptr inbounds <{ i32, i32, i8*, i32 }>, <{ i32, i32, i8*, i32 }> addrspace(5)* %[[block]], i32 0, i32 3
|
||||
@@ -53,11 +50,8 @@ void foo(){
|
||||
// AMDGCN: %[[blk_gen_ptr:.*]] = addrspacecast %struct.__opencl_block_literal_generic addrspace(5)* %[[blk_ptr]] to %struct.__opencl_block_literal_generic*
|
||||
// AMDGCN: store %struct.__opencl_block_literal_generic* %[[blk_gen_ptr]], %struct.__opencl_block_literal_generic* addrspace(5)* %[[block_B:.*]],
|
||||
// AMDGCN: %[[block_literal:.*]] = load %struct.__opencl_block_literal_generic*, %struct.__opencl_block_literal_generic* addrspace(5)* %[[block_B]]
|
||||
- // AMDGCN: %[[invoke_addr:.*]] = getelementptr inbounds %struct.__opencl_block_literal_generic, %struct.__opencl_block_literal_generic* %[[block_literal]], i32 0, i32 2
|
||||
// AMDGCN: %[[blk_gen_ptr:.*]] = bitcast %struct.__opencl_block_literal_generic* %[[block_literal]] to i8*
|
||||
- // AMDGCN: %[[invoke_func_ptr:.*]] = load i8*, i8** %[[invoke_addr]]
|
||||
- // AMDGCN: %[[invoke_func:.*]] = bitcast i8* %[[invoke_func_ptr]] to i32 (i8*)*
|
||||
- // AMDGCN: call {{.*}}i32 %[[invoke_func]](i8* %[[blk_gen_ptr]])
|
||||
+ // AMDGCN: call {{.*}}i32 @__foo_block_invoke(i8* %[[blk_gen_ptr]])
|
||||
|
||||
int (^ block_B)(void) = ^{
|
||||
return i;
|
||||
diff --git a/clang/test/CodeGenOpenCL/cl20-device-side-enqueue.cl b/clang/test/CodeGenOpenCL/cl20-device-side-enqueue.cl
|
||||
index 8445016..1566912 100644
|
||||
--- a/clang/test/CodeGenOpenCL/cl20-device-side-enqueue.cl
|
||||
+++ b/clang/test/CodeGenOpenCL/cl20-device-side-enqueue.cl
|
||||
@@ -312,9 +312,7 @@ kernel void device_side_enqueue(global int *a, global int *b, int i) {
|
||||
};
|
||||
|
||||
// Uses global block literal [[BLG8]] and invoke function [[INVG8]].
|
||||
- // COMMON: [[r1:%.*]] = load i8 addrspace(4)*, i8 addrspace(4)* addrspace(4)* getelementptr inbounds (%struct.__opencl_block_literal_generic, %struct.__opencl_block_literal_generic addrspace(4)* addrspacecast (%struct.__opencl_block_literal_generic addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to %struct.__opencl_block_literal_generic addrspace(1)*) to %struct.__opencl_block_literal_generic addrspace(4)*), i32 0, i32 2)
|
||||
- // COMMON: [[r2:%.*]] = addrspacecast i8 addrspace(4)* [[r1]] to void (i8 addrspace(4)*)*
|
||||
- // COMMON: call spir_func void [[r2]](i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*))
|
||||
+ // COMMON: call spir_func void @__device_side_enqueue_block_invoke_11(i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*))
|
||||
block_A();
|
||||
|
||||
// Emits global block literal [[BLG8]] and block kernel [[INVGK8]]. [[INVGK8]] calls [[INVG8]].
|
||||
@@ -333,15 +331,35 @@ kernel void device_side_enqueue(global int *a, global int *b, int i) {
|
||||
unsigned size = get_kernel_work_group_size(block_A);
|
||||
|
||||
// Uses global block literal [[BLG8]] and invoke function [[INVG8]]. Make sure no redundant block literal and invoke functions are emitted.
|
||||
- // COMMON: [[r1:%.*]] = load i8 addrspace(4)*, i8 addrspace(4)* addrspace(4)* getelementptr inbounds (%struct.__opencl_block_literal_generic, %struct.__opencl_block_literal_generic addrspace(4)* addrspacecast (%struct.__opencl_block_literal_generic addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to %struct.__opencl_block_literal_generic addrspace(1)*) to %struct.__opencl_block_literal_generic addrspace(4)*), i32 0, i32 2)
|
||||
- // COMMON: [[r2:%.*]] = addrspacecast i8 addrspace(4)* [[r1]] to void (i8 addrspace(4)*)*
|
||||
- // COMMON: call spir_func void [[r2]](i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*))
|
||||
+ // COMMON: call spir_func void @__device_side_enqueue_block_invoke_11(i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*))
|
||||
block_A();
|
||||
|
||||
+ // Make sure that block invoke function is resolved correctly after sequence of assignements.
|
||||
+ // COMMON: store %struct.__opencl_block_literal_generic addrspace(4)*
|
||||
+ // COMMON-SAME: addrspacecast (%struct.__opencl_block_literal_generic addrspace(1)*
|
||||
+ // COMMON-SAME: bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BL_GLOBAL]] to %struct.__opencl_block_literal_generic addrspace(1)*)
|
||||
+ // COMMON-SAME: to %struct.__opencl_block_literal_generic addrspace(4)*),
|
||||
+ // COMMON-SAME: %struct.__opencl_block_literal_generic addrspace(4)** %b1,
|
||||
+ bl_t b1 = block_G;
|
||||
+ // COMMON: store %struct.__opencl_block_literal_generic addrspace(4)*
|
||||
+ // COMMON-SAME: addrspacecast (%struct.__opencl_block_literal_generic addrspace(1)*
|
||||
+ // COMMON-SAME: bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BL_GLOBAL]] to %struct.__opencl_block_literal_generic addrspace(1)*)
|
||||
+ // COMMON-SAME: to %struct.__opencl_block_literal_generic addrspace(4)*),
|
||||
+ // COMMON-SAME: %struct.__opencl_block_literal_generic addrspace(4)** %b2,
|
||||
+ bl_t b2 = b1;
|
||||
+ // COMMON: call spir_func void @block_G_block_invoke(i8 addrspace(4)* addrspacecast (i8 addrspace(1)*
|
||||
+ // COMMON-SAME: bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BL_GLOBAL]] to i8 addrspace(1)*)
|
||||
+ // COOMON-SAME: to i8 addrspace(4)*), i8 addrspace(3)* null)
|
||||
+ b2(0);
|
||||
+ // Uses global block literal [[BL_GLOBAL]] and block kernel [[INV_G_K]]. [[INV_G_K]] calls [[INV_G]].
|
||||
+ // COMMON: call i32 @__get_kernel_preferred_work_group_size_multiple_impl(
|
||||
+ // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INV_G_K:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*),
|
||||
+ // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* [[BL_GLOBAL]] to i8 addrspace(1)*) to i8 addrspace(4)*))
|
||||
+ size = get_kernel_preferred_work_group_size_multiple(b2);
|
||||
+
|
||||
void (^block_C)(void) = ^{
|
||||
callee(i, a);
|
||||
};
|
||||
-
|
||||
// Emits block literal on stack and block kernel [[INVLK3]].
|
||||
// COMMON: store i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*)* [[INVL3:@__device_side_enqueue_block_invoke[^ ]*]] to i8*) to i8 addrspace(4)*), i8 addrspace(4)** %block.invoke
|
||||
// COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
|
||||
@@ -404,8 +422,8 @@ kernel void device_side_enqueue(global int *a, global int *b, int i) {
|
||||
// COMMON: define internal spir_func void [[INVG8]](i8 addrspace(4)*{{.*}})
|
||||
// COMMON: define internal spir_func void [[INVG9]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)* %{{.*}})
|
||||
// COMMON: define internal spir_kernel void [[INVGK8]](i8 addrspace(4)*{{.*}})
|
||||
+// COMMON: define internal spir_kernel void [[INV_G_K]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}})
|
||||
// COMMON: define internal spir_kernel void [[INVLK3]](i8 addrspace(4)*{{.*}})
|
||||
// COMMON: define internal spir_kernel void [[INVGK9]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}})
|
||||
-// COMMON: define internal spir_kernel void [[INV_G_K]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}})
|
||||
// COMMON: define internal spir_kernel void [[INVGK10]](i8 addrspace(4)*{{.*}})
|
||||
// COMMON: define internal spir_kernel void [[INVGK11]](i8 addrspace(4)*{{.*}})
|
||||
--
|
||||
1.8.3.1
|
||||
|
||||
26
debian/patches/mips64el-fix.diff
vendored
26
debian/patches/mips64el-fix.diff
vendored
@ -1,26 +0,0 @@
|
||||
Index: llvm-toolchain-8-8~+rc5/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_linux.cc
|
||||
===================================================================
|
||||
--- llvm-toolchain-8-8~+rc5.orig/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_linux.cc
|
||||
+++ llvm-toolchain-8-8~+rc5/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_linux.cc
|
||||
@@ -29,7 +29,7 @@
|
||||
// are not defined anywhere in userspace headers. Fake them. This seems to work
|
||||
// fine with newer headers, too.
|
||||
#include <linux/posix_types.h>
|
||||
-#if defined(__x86_64__) || defined(__mips__)
|
||||
+#if defined(__x86_64__)
|
||||
#include <sys/stat.h>
|
||||
#else
|
||||
#define ino_t __kernel_ino_t
|
||||
Index: llvm-toolchain-8-8~+rc5/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h
|
||||
===================================================================
|
||||
--- llvm-toolchain-8-8~+rc5.orig/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h
|
||||
+++ llvm-toolchain-8-8~+rc5/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h
|
||||
@@ -84,7 +84,7 @@ namespace __sanitizer {
|
||||
#elif defined(__mips__)
|
||||
const unsigned struct_kernel_stat_sz =
|
||||
SANITIZER_ANDROID ? FIRST_32_SECOND_64(104, 128) :
|
||||
- FIRST_32_SECOND_64(160, 216);
|
||||
+ FIRST_32_SECOND_64(144, 104);
|
||||
const unsigned struct_kernel_stat64_sz = 104;
|
||||
#elif defined(__s390__) && !defined(__s390x__)
|
||||
const unsigned struct_kernel_stat_sz = 64;
|
||||
33
debian/patches/ubuntu-eoan-distro.patch
vendored
33
debian/patches/ubuntu-eoan-distro.patch
vendored
@ -1,33 +0,0 @@
|
||||
Description: Add uoan as supported architecture
|
||||
Author: Gianfranco Costamagna <locutusofborg@debian.org>
|
||||
Last-Update: 2019-04-21
|
||||
|
||||
--- llvm-toolchain-8-8.orig/clang/include/clang/Driver/Distro.h
|
||||
+++ llvm-toolchain-8-8/clang/include/clang/Driver/Distro.h
|
||||
@@ -64,6 +64,7 @@ public:
|
||||
UbuntuBionic,
|
||||
UbuntuCosmic,
|
||||
UbuntuDisco,
|
||||
+ UbuntuEoan,
|
||||
UnknownDistro
|
||||
};
|
||||
|
||||
@@ -117,7 +118,7 @@ public:
|
||||
}
|
||||
|
||||
bool IsUbuntu() const {
|
||||
- return DistroVal >= UbuntuHardy && DistroVal <= UbuntuDisco;
|
||||
+ return DistroVal >= UbuntuHardy && DistroVal <= UbuntuEoan;
|
||||
}
|
||||
|
||||
bool IsAlpineLinux() const {
|
||||
--- llvm-toolchain-8-8.orig/clang/lib/Driver/Distro.cpp
|
||||
+++ llvm-toolchain-8-8/clang/lib/Driver/Distro.cpp
|
||||
@@ -52,6 +52,7 @@ static Distro::DistroType DetectDistro(l
|
||||
.Case("bionic", Distro::UbuntuBionic)
|
||||
.Case("cosmic", Distro::UbuntuCosmic)
|
||||
.Case("disco", Distro::UbuntuDisco)
|
||||
+ .Case("eoan", Distro::UbuntuEoan)
|
||||
.Default(Distro::UnknownDistro);
|
||||
if (Version != Distro::UnknownDistro)
|
||||
return Version;
|
||||
Loading…
Reference in New Issue
Block a user