From b6bb7db62bdf0d2eae01075f9e9863903f4fd281 Mon Sep 17 00:00:00 2001 From: Hal Finkel Date: Mon, 12 Jan 2015 04:34:47 +0000 Subject: [PATCH] [PowerPC] Fix calls to non-function objects Looking at r225438 inspired me to see how the PowerPC backend handled the situation (calling a bitcasted TLS global), and it turns out we also produced an error (cannot select ...). What it means to "call" something that is not a function is implementation and platform specific, but in the name of doing something (besides crashing), this makes sure we do what GCC does (treat all such calls as calls through a function pointer -- meaning that the pointer is assumed, as is the convention on PPC, to point to a function descriptor structure holding the actual code address along with the function's TOC pointer and environment pointer). As GCC does, we now do the same for calling regular (non-TLS) non-function globals too. I'm not sure whether this is the most useful way to define the behavior, but at least we won't be alone. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225617 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Target/PowerPC/PPCISelLowering.cpp | 27 ++++++-- test/CodeGen/PowerPC/ppc64-nonfunc-calls.ll | 69 +++++++++++++++++++++ 2 files changed, 91 insertions(+), 5 deletions(-) create mode 100644 test/CodeGen/PowerPC/ppc64-nonfunc-calls.ll diff --git a/lib/Target/PowerPC/PPCISelLowering.cpp b/lib/Target/PowerPC/PPCISelLowering.cpp index e93c7819b1a..30f08d050da 100644 --- a/lib/Target/PowerPC/PPCISelLowering.cpp +++ b/lib/Target/PowerPC/PPCISelLowering.cpp @@ -3573,6 +3573,20 @@ void PrepareTailCall(SelectionDAG &DAG, SDValue &InFlag, SDValue &Chain, InFlag = Chain.getValue(1); } +// Is this global address that of a function that can be called by name? (as +// opposed to something that must hold a descriptor for an indirect call). +static bool isFunctionGlobalAddress(SDValue Callee) { + if (GlobalAddressSDNode *G = dyn_cast(Callee)) { + if (Callee.getOpcode() == ISD::GlobalTLSAddress || + Callee.getOpcode() == ISD::TargetGlobalTLSAddress) + return false; + + return G->getGlobal()->getType()->getElementType()->isFunctionTy(); + } + + return false; +} + static unsigned PrepareCall(SelectionDAG &DAG, SDValue &Callee, SDValue &InFlag, SDValue &Chain, SDLoc dl, int SPDiff, bool isTailCall, @@ -3598,7 +3612,10 @@ unsigned PrepareCall(SelectionDAG &DAG, SDValue &Callee, SDValue &InFlag, needIndirectCall = false; } - if (GlobalAddressSDNode *G = dyn_cast(Callee)) { + if (isFunctionGlobalAddress(Callee)) { + GlobalAddressSDNode *G = cast(Callee); + // A call to a TLS address is actually an indirect call to a + // thread-specific pointer. unsigned OpFlags = 0; if ((DAG.getTarget().getRelocationModel() != Reloc::Static && (Subtarget.getTargetTriple().isMacOSX() && @@ -4649,8 +4666,8 @@ PPCTargetLowering::LowerCall_64SVR4(SDValue Chain, SDValue Callee, // See PrepareCall() for more information about calls through function // pointers in the 64-bit SVR4 ABI. if (!isTailCall && - !dyn_cast(Callee) && - !dyn_cast(Callee)) { + !isFunctionGlobalAddress(Callee) && + !isa(Callee)) { // Load r2 into a virtual register and store it to the TOC save area. SDValue Val = DAG.getCopyFromReg(Chain, dl, PPC::X2, MVT::i64); // TOC save area offset. @@ -5053,8 +5070,8 @@ PPCTargetLowering::LowerCall_Darwin(SDValue Chain, SDValue Callee, // not mean the MTCTR instruction must use R12; it's easier to model this as // an extra parameter, so do that. if (!isTailCall && - !dyn_cast(Callee) && - !dyn_cast(Callee) && + !isFunctionGlobalAddress(Callee) && + !isa(Callee) && !isBLACompatibleAddress(Callee, DAG)) RegsToPass.push_back(std::make_pair((unsigned)(isPPC64 ? PPC::X12 : PPC::R12), Callee)); diff --git a/test/CodeGen/PowerPC/ppc64-nonfunc-calls.ll b/test/CodeGen/PowerPC/ppc64-nonfunc-calls.ll new file mode 100644 index 00000000000..9f56f0102b7 --- /dev/null +++ b/test/CodeGen/PowerPC/ppc64-nonfunc-calls.ll @@ -0,0 +1,69 @@ +; RUN: llc -mcpu=ppc64 < %s | FileCheck %s +target datalayout = "E-m:e-i64:64-n32:64" +target triple = "powerpc64-unknown-linux-gnu" + +%struct.cd = type { i64, i64, i64 } + +@something = global [33 x i8] c"this is not really code, but...\0A\00", align 1 +@tls_something = thread_local global %struct.cd zeroinitializer, align 8 +@extern_something = external global %struct.cd + +; Function Attrs: nounwind +define void @foo() #0 { +entry: + tail call void bitcast ([33 x i8]* @something to void ()*)() #0 + ret void + +; CHECK-LABEL: @foo +; CHECK-DAG: addis [[REG1:[0-9]+]], 2, something@toc@ha +; CHECK-DAG: std 2, 40(1) +; CHECK-DAG: addi [[REG3:[0-9]+]], [[REG1]], something@toc@l +; CHECK-DAG: ld [[REG2:[0-9]+]], 0([[REG3]]) +; CHECK-DAG: ld 11, 16([[REG3]]) +; CHECK-DAG: ld 2, 8([[REG3]]) +; CHECK-DAG: mtctr [[REG2]] +; CHECK: bctrl +; CHECK: ld 2, 40(1) +; CHECK: blr +} + +; Function Attrs: nounwind +define void @bar() #0 { +entry: + tail call void bitcast (%struct.cd* @tls_something to void ()*)() #0 + ret void + +; CHECK-LABEL: @bar +; CHECK-DAG: addis [[REG1:[0-9]+]], 13, tls_something@tprel@ha +; CHECK-DAG: std 2, 40(1) +; CHECK-DAG: addi [[REG3:[0-9]+]], [[REG1]], tls_something@tprel@l +; CHECK-DAG: ld [[REG2:[0-9]+]], 0([[REG3]]) +; CHECK-DAG: ld 11, 16([[REG3]]) +; CHECK-DAG: ld 2, 8([[REG3]]) +; CHECK-DAG: mtctr [[REG2]] +; CHECK: bctrl +; CHECK: ld 2, 40(1) +; CHECK: blr +} + +; Function Attrs: nounwind +define void @ext() #0 { +entry: + tail call void bitcast (%struct.cd* @extern_something to void ()*)() #0 + ret void + +; CHECK-LABEL: @ext +; CHECK-DAG: addis [[REG1:[0-9]+]], 2, [[NAME:[._A-Za-z0-9]+]]@toc@ha +; CHECK-DAG: std 2, 40(1) +; CHECK-DAG: ld [[REG3:[0-9]+]], [[NAME]]@toc@l(3) +; CHECK-DAG: ld [[REG2:[0-9]+]], 0([[REG3]]) +; CHECK-DAG: ld 11, 16([[REG3]]) +; CHECK-DAG: ld 2, 8([[REG3]]) +; CHECK-DAG: mtctr [[REG2]] +; CHECK: bctrl +; CHECK: ld 2, 40(1) +; CHECK: blr +} + +attributes #0 = { nounwind } +