This is an archive of the discontinued LLVM Phabricator instance.

Differential D23120

[OpenCL] Added underscores to the names of 'to_addr' OpenCL built-ins.
ClosedPublic

Authored by bader on Aug 3 2016, 6:24 AM.

Details

Reviewers
yaxunl
Anastasia
Commits
rG4192c1db5d23: Merging r277743: --------------------------------------------------------------…
rGd81623261a37: [OpenCL] Added underscores to the names of 'to_addr' OpenCL built-ins.
rC277743: [OpenCL] Added underscores to the names of 'to_addr' OpenCL built-ins.
rL277743: [OpenCL] Added underscores to the names of 'to_addr' OpenCL built-ins.
Summary

In order to re-define OpenCL built-in functions
'to_{private,local,global}' in OpenCL run-time library LLVM names must
be different from the clang built-in function names.

Diff Detail

Repository
rL LLVM

Event Timeline

bader updated this revision to Diff 66653.Aug 3 2016, 6:24 AM
bader retitled this revision from to [OpenCL] Added underscores to the names of 'to_addr' OpenCL built-ins..
bader updated this object.
bader added reviewers: Anastasia, yaxunl.
bader added a subscriber: cfe-commits.
yaxunl accepted this revision.Aug 3 2016, 6:39 AM
yaxunl edited edge metadata.

LGTM. Thanks!

This revision is now accepted and ready to land.Aug 3 2016, 6:39 AM
Anastasia accepted this revision.Aug 4 2016, 10:41 AM
Anastasia edited edge metadata.

LGTM! Thanks!

bader closed this revision.Aug 4 2016, 11:14 AM
Closed by commit rL277743: [OpenCL] Added underscores to the names of 'to_addr' OpenCL built-ins. (authored by bader). · Explain WhyAug 4 2016, 11:14 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
cfe/
trunk/
lib/
CodeGen/
5 lines
test/
CodeGenOpenCL/
28 lines

Diff 66832

cfe/trunk/lib/CodeGen/CGBuiltin.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,203 Lines • ▼ Show 20 Lines auto NewRetT = llvm::PointerType::get(Int8Ty,
E->getType()->getPointeeType().getAddressSpace())); E->getType()->getPointeeType().getAddressSpace()));
auto FTy = llvm::FunctionType::get(NewRetT, {NewArgT}, false); auto FTy = llvm::FunctionType::get(NewRetT, {NewArgT}, false);
llvm::Value *NewArg; llvm::Value *NewArg;
if (Arg0->getType()->getPointerAddressSpace() != if (Arg0->getType()->getPointerAddressSpace() !=
NewArgT->getPointerAddressSpace()) NewArgT->getPointerAddressSpace())
NewArg = Builder.CreateAddrSpaceCast(Arg0, NewArgT); NewArg = Builder.CreateAddrSpaceCast(Arg0, NewArgT);
else else
NewArg = Builder.CreateBitOrPointerCast(Arg0, NewArgT); NewArg = Builder.CreateBitOrPointerCast(Arg0, NewArgT);
auto NewCall = Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, auto NewName = std::string("__") + E->getDirectCallee()->getName().str();
E->getDirectCallee()->getName()), {NewArg}); auto NewCall =
Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, NewName), {NewArg});
return RValue::get(Builder.CreateBitOrPointerCast(NewCall, return RValue::get(Builder.CreateBitOrPointerCast(NewCall,
ConvertType(E->getType()))); ConvertType(E->getType())));
} }
// OpenCL v2.0, s6.13.17 - Enqueue kernel function. // OpenCL v2.0, s6.13.17 - Enqueue kernel function.
// It contains four different overload formats specified in Table 6.13.17.1. // It contains four different overload formats specified in Table 6.13.17.1.
case Builtin::BIenqueue_kernel: { case Builtin::BIenqueue_kernel: {
StringRef Name; // Generated function call name StringRef Name; // Generated function call name
▲ Show 20 Lines • Show All 5,900 Lines • Show Last 20 Lines

cfe/trunk/test/CodeGenOpenCL/to_addr_builtin.cl

// RUN: %clang_cc1 -triple spir-unknown-unknown -emit-llvm -O0 -cl-std=CL2.0 -o - %s | FileCheck %s // RUN: %clang_cc1 -triple spir-unknown-unknown -emit-llvm -O0 -cl-std=CL2.0 -o - %s | FileCheck %s
// CHECK: %[[A:.*]] = type { float, float, float } // CHECK: %[[A:.*]] = type { float, float, float }
typedef struct { typedef struct {
float x,y,z; float x,y,z;
} A; } A;
typedef private A *PA; typedef private A *PA;
typedef global A *GA; typedef global A *GA;
void test(void) { void test(void) {
global int *glob; global int *glob;
local int *loc; local int *loc;
private int *priv; private int *priv;
generic int *gen; generic int *gen;
//CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(1)* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(1)* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8 addrspace(1)* @to_global(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8 addrspace(1)* @__to_global(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8 addrspace(1)* %[[RET]] to i32 addrspace(1)* //CHECK: %{{.*}} = bitcast i8 addrspace(1)* %[[RET]] to i32 addrspace(1)*
glob = to_global(glob); glob = to_global(glob);
//CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(3)* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(3)* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8 addrspace(1)* @to_global(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8 addrspace(1)* @__to_global(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8 addrspace(1)* %[[RET]] to i32 addrspace(1)* //CHECK: %{{.*}} = bitcast i8 addrspace(1)* %[[RET]] to i32 addrspace(1)*
glob = to_global(loc); glob = to_global(loc);
//CHECK: %[[ARG:.*]] = addrspacecast i32* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = addrspacecast i32* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8 addrspace(1)* @to_global(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8 addrspace(1)* @__to_global(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8 addrspace(1)* %[[RET]] to i32 addrspace(1)* //CHECK: %{{.*}} = bitcast i8 addrspace(1)* %[[RET]] to i32 addrspace(1)*
glob = to_global(priv); glob = to_global(priv);
//CHECK: %[[ARG:.*]] = bitcast i32 addrspace(4)* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = bitcast i32 addrspace(4)* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8 addrspace(1)* @to_global(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8 addrspace(1)* @__to_global(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8 addrspace(1)* %[[RET]] to i32 addrspace(1)* //CHECK: %{{.*}} = bitcast i8 addrspace(1)* %[[RET]] to i32 addrspace(1)*
glob = to_global(gen); glob = to_global(gen);
//CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(1)* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(1)* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8 addrspace(3)* @to_local(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8 addrspace(3)* @__to_local(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8 addrspace(3)* %[[RET]] to i32 addrspace(3)* //CHECK: %{{.*}} = bitcast i8 addrspace(3)* %[[RET]] to i32 addrspace(3)*
loc = to_local(glob); loc = to_local(glob);
//CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(3)* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(3)* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8 addrspace(3)* @to_local(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8 addrspace(3)* @__to_local(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8 addrspace(3)* %[[RET]] to i32 addrspace(3)* //CHECK: %{{.*}} = bitcast i8 addrspace(3)* %[[RET]] to i32 addrspace(3)*
loc = to_local(loc); loc = to_local(loc);
//CHECK: %[[ARG:.*]] = addrspacecast i32* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = addrspacecast i32* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8 addrspace(3)* @to_local(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8 addrspace(3)* @__to_local(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8 addrspace(3)* %[[RET]] to i32 addrspace(3)* //CHECK: %{{.*}} = bitcast i8 addrspace(3)* %[[RET]] to i32 addrspace(3)*
loc = to_local(priv); loc = to_local(priv);
//CHECK: %[[ARG:.*]] = bitcast i32 addrspace(4)* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = bitcast i32 addrspace(4)* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8 addrspace(3)* @to_local(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8 addrspace(3)* @__to_local(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8 addrspace(3)* %[[RET]] to i32 addrspace(3)* //CHECK: %{{.*}} = bitcast i8 addrspace(3)* %[[RET]] to i32 addrspace(3)*
loc = to_local(gen); loc = to_local(gen);
//CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(1)* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(1)* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8* @to_private(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8* @__to_private(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8* %[[RET]] to i32* //CHECK: %{{.*}} = bitcast i8* %[[RET]] to i32*
priv = to_private(glob); priv = to_private(glob);
//CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(3)* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = addrspacecast i32 addrspace(3)* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8* @to_private(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8* @__to_private(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8* %[[RET]] to i32* //CHECK: %{{.*}} = bitcast i8* %[[RET]] to i32*
priv = to_private(loc); priv = to_private(loc);
//CHECK: %[[ARG:.*]] = addrspacecast i32* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = addrspacecast i32* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8* @to_private(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8* @__to_private(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8* %[[RET]] to i32* //CHECK: %{{.*}} = bitcast i8* %[[RET]] to i32*
priv = to_private(priv); priv = to_private(priv);
//CHECK: %[[ARG:.*]] = bitcast i32 addrspace(4)* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = bitcast i32 addrspace(4)* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8* @to_private(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8* @__to_private(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8* %[[RET]] to i32* //CHECK: %{{.*}} = bitcast i8* %[[RET]] to i32*
priv = to_private(gen); priv = to_private(gen);
//CHECK: %[[ARG:.*]] = addrspacecast %[[A]]* %{{.*}} to i8 addrspace(4)* //CHECK: %[[ARG:.*]] = addrspacecast %[[A]]* %{{.*}} to i8 addrspace(4)*
//CHECK: %[[RET:.*]] = call i8 addrspace(1)* @to_global(i8 addrspace(4)* %[[ARG]]) //CHECK: %[[RET:.*]] = call i8 addrspace(1)* @__to_global(i8 addrspace(4)* %[[ARG]])
//CHECK: %{{.*}} = bitcast i8 addrspace(1)* %[[RET]] to %[[A]] addrspace(1)* //CHECK: %{{.*}} = bitcast i8 addrspace(1)* %[[RET]] to %[[A]] addrspace(1)*
PA pA; PA pA;
GA gA = to_global(pA); GA gA = to_global(pA);
//CHECK-NOT: addrspacecast //CHECK-NOT: addrspacecast
//CHECK-NOT: bitcast //CHECK-NOT: bitcast
//CHECK: call i8 addrspace(1)* @to_global(i8 addrspace(4)* %{{.*}}) //CHECK: call i8 addrspace(1)* @__to_global(i8 addrspace(4)* %{{.*}})
//CHECK-NOT: addrspacecast //CHECK-NOT: addrspacecast
//CHECK-NOT: bitcast //CHECK-NOT: bitcast
generic void *gen_v; generic void *gen_v;
global void *glob_v = to_global(gen_v); global void *glob_v = to_global(gen_v);
} }