RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-01-09 13:41:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[PowerPC] Fix calls to non-function objects

Browse Source 
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
This commit is contained in:
Hal Finkel 2015-01-12 04:34:47 +00:00
parent dc5a2dabfe
commit b6bb7db62b
2 changed files with 91 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
lib/Target/PowerPC/PPCISelLowering.cpp
View File

@ -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<GlobalAddressSDNode>(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<GlobalAddressSDNode>(Callee)) {
if (isFunctionGlobalAddress(Callee)) {
GlobalAddressSDNode *G = cast<GlobalAddressSDNode>(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<GlobalAddressSDNode>(Callee) &&
!dyn_cast<ExternalSymbolSDNode>(Callee)) {
!isFunctionGlobalAddress(Callee) &&
!isa<ExternalSymbolSDNode>(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<GlobalAddressSDNode>(Callee) &&
!dyn_cast<ExternalSymbolSDNode>(Callee) &&
!isFunctionGlobalAddress(Callee) &&
!isa<ExternalSymbolSDNode>(Callee) &&
!isBLACompatibleAddress(Callee, DAG))
RegsToPass.push_back(std::make_pair((unsigned)(isPPC64 ? PPC::X12 :
PPC::R12), Callee));

69
test/CodeGen/PowerPC/ppc64-nonfunc-calls.ll Normal file
View File

@ -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 }