diff --git a/debian/changelog b/debian/changelog index e00cdda7..ef7ed573 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,9 @@ +llvm-toolchain-snapshot (1:9~svn362869-1~exp1) experimental; urgency=medium + + * New snapshot release + + -- Sylvestre Ledru Sat, 08 Jun 2019 10:57:39 +0200 + llvm-toolchain-snapshot (1:9~svn358688-1~exp1) experimental; urgency=medium * New snapshot release diff --git a/debian/patches/D59702-mips64el-fix.diff b/debian/patches/D59702-mips64el-fix.diff deleted file mode 100644 index ef2254aa..00000000 --- a/debian/patches/D59702-mips64el-fix.diff +++ /dev/null @@ -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) diff --git a/debian/patches/OpenCL-Change-type-of-block-pointer-for-OpenCL.patch b/debian/patches/OpenCL-Change-type-of-block-pointer-for-OpenCL.patch deleted file mode 100644 index 19055a21..00000000 --- a/debian/patches/OpenCL-Change-type-of-block-pointer-for-OpenCL.patch +++ /dev/null @@ -1,152 +0,0 @@ -From 39a3ac0065c23d1e2d55dfd8792cc28a146a4307 Mon Sep 17 00:00:00 2001 -From: Alexey Bader -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(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 - diff --git a/debian/patches/OpenCL-Fix-assertion-due-to-blocks.patch b/debian/patches/OpenCL-Fix-assertion-due-to-blocks.patch deleted file mode 100644 index 27c0343b..00000000 --- a/debian/patches/OpenCL-Fix-assertion-due-to-blocks.patch +++ /dev/null @@ -1,57 +0,0 @@ -From 29e2813a2ab7d5569860bb07892dfef7b5374d96 Mon Sep 17 00:00:00 2001 -From: Yaxun Liu -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(CEE)) - return ME->getMemberDecl(); -+ if (auto *BE = dyn_cast(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 - diff --git a/debian/patches/OpenCL-Simplify-LLVM-IR-generated-for-OpenCL-blocks.patch b/debian/patches/OpenCL-Simplify-LLVM-IR-generated-for-OpenCL-blocks.patch deleted file mode 100644 index 19ac4683..00000000 --- a/debian/patches/OpenCL-Simplify-LLVM-IR-generated-for-OpenCL-blocks.patch +++ /dev/null @@ -1,290 +0,0 @@ -From c94ec28600255098ffb9d73d1b386a7c8a535590 Mon Sep 17 00:00:00 2001 -From: Andrew Savonichev -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(); -- - 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(), E->arguments()); -+ -+ // We *can* call the block directly unless it is a function argument. -+ if (!isa(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(), 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(), 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(); - 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(E) && E != Prev) { -+ Prev = E; -+ E = E->IgnoreCasts(); -+ if (auto DR = dyn_cast(E)) { -+ E = cast(DR->getDecl())->getInit(); -+ } -+ } -+ return cast(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(E)) { -- E = cast(DR->getDecl())->getInit(); -- } -- E = E->IgnoreImplicit(); -- if (auto Cast = dyn_cast(E)) { -- E = Cast->getSubExpr(); -- } -- auto *Block = cast(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 - diff --git a/debian/patches/mips64el-fix.diff b/debian/patches/mips64el-fix.diff deleted file mode 100644 index fec1bdaa..00000000 --- a/debian/patches/mips64el-fix.diff +++ /dev/null @@ -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 --#if defined(__x86_64__) || defined(__mips__) -+#if defined(__x86_64__) - #include - #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; diff --git a/debian/patches/ubuntu-eoan-distro.patch b/debian/patches/ubuntu-eoan-distro.patch deleted file mode 100644 index 1c445088..00000000 --- a/debian/patches/ubuntu-eoan-distro.patch +++ /dev/null @@ -1,33 +0,0 @@ -Description: Add uoan as supported architecture -Author: Gianfranco Costamagna -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;