mirror of
https://github.com/RPCS3/llvm.git
synced 2025-02-08 11:37:03 +00:00
[FastISel][X86] Remove no longer needed functions.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213037 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Juergen Ributzka
parent
a7d1d3a513
commit
3c0737454d
@ -126,10 +126,6 @@ private:
|
|||||||
bool X86SelectFPExt(const Instruction *I);
|
bool X86SelectFPExt(const Instruction *I);
|
||||||
bool X86SelectFPTrunc(const Instruction *I);
|
bool X86SelectFPTrunc(const Instruction *I);
|
||||||
|
|
||||||
bool X86SelectCall(const Instruction *I);
|
|
||||||
|
|
||||||
bool DoSelectCall(const Instruction *I, const char *MemIntName);
|
|
||||||
|
|
||||||
const X86InstrInfo *getInstrInfo() const {
|
const X86InstrInfo *getInstrInfo() const {
|
||||||
return getTargetMachine()->getInstrInfo();
|
return getTargetMachine()->getInstrInfo();
|
||||||
}
|
}
|
||||||
@ -2636,25 +2632,6 @@ bool X86FastISel::FastLowerArguments() {
|
|||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
bool X86FastISel::X86SelectCall(const Instruction *I) {
|
|
||||||
const CallInst *CI = cast<CallInst>(I);
|
|
||||||
const Value *Callee = CI->getCalledValue();
|
|
||||||
|
|
||||||
// Can't handle inline asm yet.
|
|
||||||
if (isa<InlineAsm>(Callee))
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// Skip intrinsic calls - we already handled these.
|
|
||||||
if (isa<IntrinsicInst>(CI))
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// Allow SelectionDAG isel to handle tail calls.
|
|
||||||
if (cast<CallInst>(I)->isTailCall())
|
|
||||||
return false;
|
|
||||||
|
|
||||||
return DoSelectCall(I, nullptr);
|
|
||||||
}
|
|
||||||
|
|
||||||
static unsigned computeBytesPoppedByCallee(const X86Subtarget *Subtarget,
|
static unsigned computeBytesPoppedByCallee(const X86Subtarget *Subtarget,
|
||||||
CallingConv::ID CC,
|
CallingConv::ID CC,
|
||||||
ImmutableCallSite *CS) {
|
ImmutableCallSite *CS) {
|
||||||
@ -2672,443 +2649,6 @@ static unsigned computeBytesPoppedByCallee(const X86Subtarget *Subtarget,
|
|||||||
return 4;
|
return 4;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Select either a call, or an llvm.memcpy/memmove/memset intrinsic
|
|
||||||
bool X86FastISel::DoSelectCall(const Instruction *I, const char *MemIntName) {
|
|
||||||
const CallInst *CI = cast<CallInst>(I);
|
|
||||||
const Value *Callee = CI->getCalledValue();
|
|
||||||
|
|
||||||
// Handle only C and fastcc calling conventions for now.
|
|
||||||
ImmutableCallSite CS(CI);
|
|
||||||
CallingConv::ID CC = CS.getCallingConv();
|
|
||||||
bool isWin64 = Subtarget->isCallingConvWin64(CC);
|
|
||||||
if (CC != CallingConv::C && CC != CallingConv::Fast &&
|
|
||||||
CC != CallingConv::X86_FastCall && CC != CallingConv::X86_64_Win64 &&
|
|
||||||
CC != CallingConv::X86_64_SysV)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// fastcc with -tailcallopt is intended to provide a guaranteed
|
|
||||||
// tail call optimization. Fastisel doesn't know how to do that.
|
|
||||||
if (CC == CallingConv::Fast && TM.Options.GuaranteedTailCallOpt)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
PointerType *PT = cast<PointerType>(CS.getCalledValue()->getType());
|
|
||||||
FunctionType *FTy = cast<FunctionType>(PT->getElementType());
|
|
||||||
bool isVarArg = FTy->isVarArg();
|
|
||||||
|
|
||||||
// Don't know how to handle Win64 varargs yet. Nothing special needed for
|
|
||||||
// x86-32. Special handling for x86-64 is implemented.
|
|
||||||
if (isVarArg && isWin64)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// Don't know about inalloca yet.
|
|
||||||
if (CS.hasInAllocaArgument())
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// Fast-isel doesn't know about callee-pop yet.
|
|
||||||
if (X86::isCalleePop(CC, Subtarget->is64Bit(), isVarArg,
|
|
||||||
TM.Options.GuaranteedTailCallOpt))
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// Check whether the function can return without sret-demotion.
|
|
||||||
SmallVector<ISD::OutputArg, 4> Outs;
|
|
||||||
GetReturnInfo(I->getType(), CS.getAttributes(), Outs, TLI);
|
|
||||||
bool CanLowerReturn = TLI.CanLowerReturn(CS.getCallingConv(),
|
|
||||||
*FuncInfo.MF, FTy->isVarArg(),
|
|
||||||
Outs, FTy->getContext());
|
|
||||||
if (!CanLowerReturn)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// Materialize callee address in a register. FIXME: GV address can be
|
|
||||||
// handled with a CALLpcrel32 instead.
|
|
||||||
X86AddressMode CalleeAM;
|
|
||||||
if (!X86SelectCallAddress(Callee, CalleeAM))
|
|
||||||
return false;
|
|
||||||
unsigned CalleeOp = 0;
|
|
||||||
const GlobalValue *GV = nullptr;
|
|
||||||
if (CalleeAM.GV != nullptr) {
|
|
||||||
GV = CalleeAM.GV;
|
|
||||||
} else if (CalleeAM.Base.Reg != 0) {
|
|
||||||
CalleeOp = CalleeAM.Base.Reg;
|
|
||||||
} else
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// Deal with call operands first.
|
|
||||||
SmallVector<const Value *, 8> ArgVals;
|
|
||||||
SmallVector<unsigned, 8> Args;
|
|
||||||
SmallVector<MVT, 8> ArgVTs;
|
|
||||||
SmallVector<ISD::ArgFlagsTy, 8> ArgFlags;
|
|
||||||
unsigned arg_size = CS.arg_size();
|
|
||||||
Args.reserve(arg_size);
|
|
||||||
ArgVals.reserve(arg_size);
|
|
||||||
ArgVTs.reserve(arg_size);
|
|
||||||
ArgFlags.reserve(arg_size);
|
|
||||||
for (ImmutableCallSite::arg_iterator i = CS.arg_begin(), e = CS.arg_end();
|
|
||||||
i != e; ++i) {
|
|
||||||
// If we're lowering a mem intrinsic instead of a regular call, skip the
|
|
||||||
// last two arguments, which should not passed to the underlying functions.
|
|
||||||
if (MemIntName && e-i <= 2)
|
|
||||||
break;
|
|
||||||
Value *ArgVal = *i;
|
|
||||||
ISD::ArgFlagsTy Flags;
|
|
||||||
unsigned AttrInd = i - CS.arg_begin() + 1;
|
|
||||||
if (CS.paramHasAttr(AttrInd, Attribute::SExt))
|
|
||||||
Flags.setSExt();
|
|
||||||
if (CS.paramHasAttr(AttrInd, Attribute::ZExt))
|
|
||||||
Flags.setZExt();
|
|
||||||
|
|
||||||
if (CS.paramHasAttr(AttrInd, Attribute::ByVal)) {
|
|
||||||
PointerType *Ty = cast<PointerType>(ArgVal->getType());
|
|
||||||
Type *ElementTy = Ty->getElementType();
|
|
||||||
unsigned FrameSize = DL.getTypeAllocSize(ElementTy);
|
|
||||||
unsigned FrameAlign = CS.getParamAlignment(AttrInd);
|
|
||||||
if (!FrameAlign)
|
|
||||||
FrameAlign = TLI.getByValTypeAlignment(ElementTy);
|
|
||||||
Flags.setByVal();
|
|
||||||
Flags.setByValSize(FrameSize);
|
|
||||||
Flags.setByValAlign(FrameAlign);
|
|
||||||
if (!IsMemcpySmall(FrameSize))
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (CS.paramHasAttr(AttrInd, Attribute::InReg))
|
|
||||||
Flags.setInReg();
|
|
||||||
if (CS.paramHasAttr(AttrInd, Attribute::Nest))
|
|
||||||
Flags.setNest();
|
|
||||||
|
|
||||||
// If this is an i1/i8/i16 argument, promote to i32 to avoid an extra
|
|
||||||
// instruction. This is safe because it is common to all fastisel supported
|
|
||||||
// calling conventions on x86.
|
|
||||||
if (ConstantInt *CI = dyn_cast<ConstantInt>(ArgVal)) {
|
|
||||||
if (CI->getBitWidth() == 1 || CI->getBitWidth() == 8 ||
|
|
||||||
CI->getBitWidth() == 16) {
|
|
||||||
if (Flags.isSExt())
|
|
||||||
ArgVal = ConstantExpr::getSExt(CI,Type::getInt32Ty(CI->getContext()));
|
|
||||||
else
|
|
||||||
ArgVal = ConstantExpr::getZExt(CI,Type::getInt32Ty(CI->getContext()));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned ArgReg;
|
|
||||||
|
|
||||||
// Passing bools around ends up doing a trunc to i1 and passing it.
|
|
||||||
// Codegen this as an argument + "and 1".
|
|
||||||
if (ArgVal->getType()->isIntegerTy(1) && isa<TruncInst>(ArgVal) &&
|
|
||||||
cast<TruncInst>(ArgVal)->getParent() == I->getParent() &&
|
|
||||||
ArgVal->hasOneUse()) {
|
|
||||||
ArgVal = cast<TruncInst>(ArgVal)->getOperand(0);
|
|
||||||
ArgReg = getRegForValue(ArgVal);
|
|
||||||
if (ArgReg == 0) return false;
|
|
||||||
|
|
||||||
MVT ArgVT;
|
|
||||||
if (!isTypeLegal(ArgVal->getType(), ArgVT)) return false;
|
|
||||||
|
|
||||||
ArgReg = FastEmit_ri(ArgVT, ArgVT, ISD::AND, ArgReg,
|
|
||||||
ArgVal->hasOneUse(), 1);
|
|
||||||
} else {
|
|
||||||
ArgReg = getRegForValue(ArgVal);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (ArgReg == 0) return false;
|
|
||||||
|
|
||||||
Type *ArgTy = ArgVal->getType();
|
|
||||||
MVT ArgVT;
|
|
||||||
if (!isTypeLegal(ArgTy, ArgVT))
|
|
||||||
return false;
|
|
||||||
if (ArgVT == MVT::x86mmx)
|
|
||||||
return false;
|
|
||||||
unsigned OriginalAlignment = DL.getABITypeAlignment(ArgTy);
|
|
||||||
Flags.setOrigAlign(OriginalAlignment);
|
|
||||||
|
|
||||||
Args.push_back(ArgReg);
|
|
||||||
ArgVals.push_back(ArgVal);
|
|
||||||
ArgVTs.push_back(ArgVT);
|
|
||||||
ArgFlags.push_back(Flags);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Analyze operands of the call, assigning locations to each operand.
|
|
||||||
SmallVector<CCValAssign, 16> ArgLocs;
|
|
||||||
CCState CCInfo(CC, isVarArg, *FuncInfo.MF, TM, ArgLocs,
|
|
||||||
I->getParent()->getContext());
|
|
||||||
|
|
||||||
// Allocate shadow area for Win64
|
|
||||||
if (isWin64)
|
|
||||||
CCInfo.AllocateStack(32, 8);
|
|
||||||
|
|
||||||
CCInfo.AnalyzeCallOperands(ArgVTs, ArgFlags, CC_X86);
|
|
||||||
|
|
||||||
// Get a count of how many bytes are to be pushed on the stack.
|
|
||||||
unsigned NumBytes = CCInfo.getNextStackOffset();
|
|
||||||
|
|
||||||
// Issue CALLSEQ_START
|
|
||||||
unsigned AdjStackDown = TII.getCallFrameSetupOpcode();
|
|
||||||
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AdjStackDown))
|
|
||||||
.addImm(NumBytes);
|
|
||||||
|
|
||||||
// Process argument: walk the register/memloc assignments, inserting
|
|
||||||
// copies / loads.
|
|
||||||
SmallVector<unsigned, 4> RegArgs;
|
|
||||||
for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
|
|
||||||
CCValAssign &VA = ArgLocs[i];
|
|
||||||
unsigned Arg = Args[VA.getValNo()];
|
|
||||||
EVT ArgVT = ArgVTs[VA.getValNo()];
|
|
||||||
|
|
||||||
// Promote the value if needed.
|
|
||||||
switch (VA.getLocInfo()) {
|
|
||||||
case CCValAssign::Full: break;
|
|
||||||
case CCValAssign::SExt: {
|
|
||||||
assert(VA.getLocVT().isInteger() && !VA.getLocVT().isVector() &&
|
|
||||||
"Unexpected extend");
|
|
||||||
bool Emitted = X86FastEmitExtend(ISD::SIGN_EXTEND, VA.getLocVT(),
|
|
||||||
Arg, ArgVT, Arg);
|
|
||||||
assert(Emitted && "Failed to emit a sext!"); (void)Emitted;
|
|
||||||
ArgVT = VA.getLocVT();
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case CCValAssign::ZExt: {
|
|
||||||
assert(VA.getLocVT().isInteger() && !VA.getLocVT().isVector() &&
|
|
||||||
"Unexpected extend");
|
|
||||||
bool Emitted = X86FastEmitExtend(ISD::ZERO_EXTEND, VA.getLocVT(),
|
|
||||||
Arg, ArgVT, Arg);
|
|
||||||
assert(Emitted && "Failed to emit a zext!"); (void)Emitted;
|
|
||||||
ArgVT = VA.getLocVT();
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case CCValAssign::AExt: {
|
|
||||||
assert(VA.getLocVT().isInteger() && !VA.getLocVT().isVector() &&
|
|
||||||
"Unexpected extend");
|
|
||||||
bool Emitted = X86FastEmitExtend(ISD::ANY_EXTEND, VA.getLocVT(),
|
|
||||||
Arg, ArgVT, Arg);
|
|
||||||
if (!Emitted)
|
|
||||||
Emitted = X86FastEmitExtend(ISD::ZERO_EXTEND, VA.getLocVT(),
|
|
||||||
Arg, ArgVT, Arg);
|
|
||||||
if (!Emitted)
|
|
||||||
Emitted = X86FastEmitExtend(ISD::SIGN_EXTEND, VA.getLocVT(),
|
|
||||||
Arg, ArgVT, Arg);
|
|
||||||
|
|
||||||
assert(Emitted && "Failed to emit a aext!"); (void)Emitted;
|
|
||||||
ArgVT = VA.getLocVT();
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case CCValAssign::BCvt: {
|
|
||||||
unsigned BC = FastEmit_r(ArgVT.getSimpleVT(), VA.getLocVT(),
|
|
||||||
ISD::BITCAST, Arg, /*TODO: Kill=*/false);
|
|
||||||
assert(BC != 0 && "Failed to emit a bitcast!");
|
|
||||||
Arg = BC;
|
|
||||||
ArgVT = VA.getLocVT();
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case CCValAssign::VExt:
|
|
||||||
// VExt has not been implemented, so this should be impossible to reach
|
|
||||||
// for now. However, fallback to Selection DAG isel once implemented.
|
|
||||||
return false;
|
|
||||||
case CCValAssign::Indirect:
|
|
||||||
// FIXME: Indirect doesn't need extending, but fast-isel doesn't fully
|
|
||||||
// support this.
|
|
||||||
return false;
|
|
||||||
case CCValAssign::FPExt:
|
|
||||||
llvm_unreachable("Unexpected loc info!");
|
|
||||||
}
|
|
||||||
|
|
||||||
if (VA.isRegLoc()) {
|
|
||||||
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
|
|
||||||
TII.get(TargetOpcode::COPY), VA.getLocReg()).addReg(Arg);
|
|
||||||
RegArgs.push_back(VA.getLocReg());
|
|
||||||
} else {
|
|
||||||
unsigned LocMemOffset = VA.getLocMemOffset();
|
|
||||||
X86AddressMode AM;
|
|
||||||
const X86RegisterInfo *RegInfo = static_cast<const X86RegisterInfo*>(
|
|
||||||
getTargetMachine()->getRegisterInfo());
|
|
||||||
AM.Base.Reg = RegInfo->getStackRegister();
|
|
||||||
AM.Disp = LocMemOffset;
|
|
||||||
const Value *ArgVal = ArgVals[VA.getValNo()];
|
|
||||||
ISD::ArgFlagsTy Flags = ArgFlags[VA.getValNo()];
|
|
||||||
|
|
||||||
if (Flags.isByVal()) {
|
|
||||||
X86AddressMode SrcAM;
|
|
||||||
SrcAM.Base.Reg = Arg;
|
|
||||||
bool Res = TryEmitSmallMemcpy(AM, SrcAM, Flags.getByValSize());
|
|
||||||
assert(Res && "memcpy length already checked!"); (void)Res;
|
|
||||||
} else if (isa<ConstantInt>(ArgVal) || isa<ConstantPointerNull>(ArgVal)) {
|
|
||||||
// If this is a really simple value, emit this with the Value* version
|
|
||||||
// of X86FastEmitStore. If it isn't simple, we don't want to do this,
|
|
||||||
// as it can cause us to reevaluate the argument.
|
|
||||||
if (!X86FastEmitStore(ArgVT, ArgVal, AM))
|
|
||||||
return false;
|
|
||||||
} else {
|
|
||||||
if (!X86FastEmitStore(ArgVT, Arg, /*ValIsKill=*/false, AM))
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// ELF / PIC requires GOT in the EBX register before function calls via PLT
|
|
||||||
// GOT pointer.
|
|
||||||
if (Subtarget->isPICStyleGOT()) {
|
|
||||||
unsigned Base = getInstrInfo()->getGlobalBaseReg(FuncInfo.MF);
|
|
||||||
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
|
|
||||||
TII.get(TargetOpcode::COPY), X86::EBX).addReg(Base);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (Subtarget->is64Bit() && isVarArg && !isWin64) {
|
|
||||||
// Count the number of XMM registers allocated.
|
|
||||||
static const MCPhysReg XMMArgRegs[] = {
|
|
||||||
X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
|
|
||||||
X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
|
|
||||||
};
|
|
||||||
unsigned NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs, 8);
|
|
||||||
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(X86::MOV8ri),
|
|
||||||
X86::AL).addImm(NumXMMRegs);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Issue the call.
|
|
||||||
MachineInstrBuilder MIB;
|
|
||||||
if (CalleeOp) {
|
|
||||||
// Register-indirect call.
|
|
||||||
unsigned CallOpc;
|
|
||||||
if (Subtarget->is64Bit())
|
|
||||||
CallOpc = X86::CALL64r;
|
|
||||||
else
|
|
||||||
CallOpc = X86::CALL32r;
|
|
||||||
MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(CallOpc))
|
|
||||||
.addReg(CalleeOp);
|
|
||||||
|
|
||||||
} else {
|
|
||||||
// Direct call.
|
|
||||||
assert(GV && "Not a direct call");
|
|
||||||
unsigned CallOpc;
|
|
||||||
if (Subtarget->is64Bit())
|
|
||||||
CallOpc = X86::CALL64pcrel32;
|
|
||||||
else
|
|
||||||
CallOpc = X86::CALLpcrel32;
|
|
||||||
|
|
||||||
// See if we need any target-specific flags on the GV operand.
|
|
||||||
unsigned char OpFlags = 0;
|
|
||||||
|
|
||||||
// On ELF targets, in both X86-64 and X86-32 mode, direct calls to
|
|
||||||
// external symbols most go through the PLT in PIC mode. If the symbol
|
|
||||||
// has hidden or protected visibility, or if it is static or local, then
|
|
||||||
// we don't need to use the PLT - we can directly call it.
|
|
||||||
if (Subtarget->isTargetELF() &&
|
|
||||||
TM.getRelocationModel() == Reloc::PIC_ &&
|
|
||||||
GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
|
|
||||||
OpFlags = X86II::MO_PLT;
|
|
||||||
} else if (Subtarget->isPICStyleStubAny() &&
|
|
||||||
(GV->isDeclaration() || GV->isWeakForLinker()) &&
|
|
||||||
(!Subtarget->getTargetTriple().isMacOSX() ||
|
|
||||||
Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
|
|
||||||
// PC-relative references to external symbols should go through $stub,
|
|
||||||
// unless we're building with the leopard linker or later, which
|
|
||||||
// automatically synthesizes these stubs.
|
|
||||||
OpFlags = X86II::MO_DARWIN_STUB;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(CallOpc));
|
|
||||||
if (MemIntName)
|
|
||||||
MIB.addExternalSymbol(MemIntName, OpFlags);
|
|
||||||
else
|
|
||||||
MIB.addGlobalAddress(GV, 0, OpFlags);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add a register mask with the call-preserved registers.
|
|
||||||
// Proper defs for return values will be added by setPhysRegsDeadExcept().
|
|
||||||
MIB.addRegMask(TRI.getCallPreservedMask(CS.getCallingConv()));
|
|
||||||
|
|
||||||
// Add an implicit use GOT pointer in EBX.
|
|
||||||
if (Subtarget->isPICStyleGOT())
|
|
||||||
MIB.addReg(X86::EBX, RegState::Implicit);
|
|
||||||
|
|
||||||
if (Subtarget->is64Bit() && isVarArg && !isWin64)
|
|
||||||
MIB.addReg(X86::AL, RegState::Implicit);
|
|
||||||
|
|
||||||
// Add implicit physical register uses to the call.
|
|
||||||
for (unsigned i = 0, e = RegArgs.size(); i != e; ++i)
|
|
||||||
MIB.addReg(RegArgs[i], RegState::Implicit);
|
|
||||||
|
|
||||||
// Issue CALLSEQ_END
|
|
||||||
unsigned AdjStackUp = TII.getCallFrameDestroyOpcode();
|
|
||||||
unsigned NumBytesCallee = computeBytesPoppedByCallee(Subtarget, CC, &CS);
|
|
||||||
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(AdjStackUp))
|
|
||||||
.addImm(NumBytes).addImm(NumBytesCallee);
|
|
||||||
|
|
||||||
// Build info for return calling conv lowering code.
|
|
||||||
// FIXME: This is practically a copy-paste from TargetLowering::LowerCallTo.
|
|
||||||
SmallVector<ISD::InputArg, 32> Ins;
|
|
||||||
SmallVector<EVT, 4> RetTys;
|
|
||||||
ComputeValueVTs(TLI, I->getType(), RetTys);
|
|
||||||
for (unsigned i = 0, e = RetTys.size(); i != e; ++i) {
|
|
||||||
EVT VT = RetTys[i];
|
|
||||||
MVT RegisterVT = TLI.getRegisterType(I->getParent()->getContext(), VT);
|
|
||||||
unsigned NumRegs = TLI.getNumRegisters(I->getParent()->getContext(), VT);
|
|
||||||
for (unsigned j = 0; j != NumRegs; ++j) {
|
|
||||||
ISD::InputArg MyFlags;
|
|
||||||
MyFlags.VT = RegisterVT;
|
|
||||||
MyFlags.Used = !CS.getInstruction()->use_empty();
|
|
||||||
if (CS.paramHasAttr(0, Attribute::SExt))
|
|
||||||
MyFlags.Flags.setSExt();
|
|
||||||
if (CS.paramHasAttr(0, Attribute::ZExt))
|
|
||||||
MyFlags.Flags.setZExt();
|
|
||||||
if (CS.paramHasAttr(0, Attribute::InReg))
|
|
||||||
MyFlags.Flags.setInReg();
|
|
||||||
Ins.push_back(MyFlags);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Now handle call return values.
|
|
||||||
SmallVector<unsigned, 4> UsedRegs;
|
|
||||||
SmallVector<CCValAssign, 16> RVLocs;
|
|
||||||
CCState CCRetInfo(CC, false, *FuncInfo.MF, TM, RVLocs,
|
|
||||||
I->getParent()->getContext());
|
|
||||||
unsigned ResultReg = FuncInfo.CreateRegs(I->getType());
|
|
||||||
CCRetInfo.AnalyzeCallResult(Ins, RetCC_X86);
|
|
||||||
for (unsigned i = 0; i != RVLocs.size(); ++i) {
|
|
||||||
EVT CopyVT = RVLocs[i].getValVT();
|
|
||||||
unsigned CopyReg = ResultReg + i;
|
|
||||||
|
|
||||||
// If this is a call to a function that returns an fp value on the x87 fp
|
|
||||||
// stack, but where we prefer to use the value in xmm registers, copy it
|
|
||||||
// out as F80 and use a truncate to move it from fp stack reg to xmm reg.
|
|
||||||
if ((RVLocs[i].getLocReg() == X86::ST0 ||
|
|
||||||
RVLocs[i].getLocReg() == X86::ST1)) {
|
|
||||||
if (isScalarFPTypeInSSEReg(RVLocs[i].getValVT())) {
|
|
||||||
CopyVT = MVT::f80;
|
|
||||||
CopyReg = createResultReg(&X86::RFP80RegClass);
|
|
||||||
}
|
|
||||||
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
|
|
||||||
TII.get(X86::FpPOP_RETVAL), CopyReg);
|
|
||||||
} else {
|
|
||||||
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
|
|
||||||
TII.get(TargetOpcode::COPY),
|
|
||||||
CopyReg).addReg(RVLocs[i].getLocReg());
|
|
||||||
UsedRegs.push_back(RVLocs[i].getLocReg());
|
|
||||||
}
|
|
||||||
|
|
||||||
if (CopyVT != RVLocs[i].getValVT()) {
|
|
||||||
// Round the F80 the right size, which also moves to the appropriate xmm
|
|
||||||
// register. This is accomplished by storing the F80 value in memory and
|
|
||||||
// then loading it back. Ewww...
|
|
||||||
EVT ResVT = RVLocs[i].getValVT();
|
|
||||||
unsigned Opc = ResVT == MVT::f32 ? X86::ST_Fp80m32 : X86::ST_Fp80m64;
|
|
||||||
unsigned MemSize = ResVT.getSizeInBits()/8;
|
|
||||||
int FI = MFI.CreateStackObject(MemSize, MemSize, false);
|
|
||||||
addFrameReference(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
|
|
||||||
TII.get(Opc)), FI)
|
|
||||||
.addReg(CopyReg);
|
|
||||||
Opc = ResVT == MVT::f32 ? X86::MOVSSrm : X86::MOVSDrm;
|
|
||||||
addFrameReference(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
|
|
||||||
TII.get(Opc), ResultReg + i), FI);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (RVLocs.size())
|
|
||||||
UpdateValueMap(I, ResultReg, RVLocs.size());
|
|
||||||
|
|
||||||
// Set all unused physreg defs as dead.
|
|
||||||
static_cast<MachineInstr *>(MIB)->setPhysRegsDeadExcept(UsedRegs, TRI);
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool X86FastISel::FastLowerCall(CallLoweringInfo &CLI) {
|
bool X86FastISel::FastLowerCall(CallLoweringInfo &CLI) {
|
||||||
auto &OutVals = CLI.OutVals;
|
auto &OutVals = CLI.OutVals;
|
||||||
auto &OutFlags = CLI.OutFlags;
|
auto &OutFlags = CLI.OutFlags;
|
||||||
@ -3516,8 +3056,6 @@ X86FastISel::TargetSelectInstruction(const Instruction *I) {
|
|||||||
return X86SelectZExt(I);
|
return X86SelectZExt(I);
|
||||||
case Instruction::Br:
|
case Instruction::Br:
|
||||||
return X86SelectBranch(I);
|
return X86SelectBranch(I);
|
||||||
case Instruction::Call:
|
|
||||||
return X86SelectCall(I);
|
|
||||||
case Instruction::LShr:
|
case Instruction::LShr:
|
||||||
case Instruction::AShr:
|
case Instruction::AShr:
|
||||||
case Instruction::Shl:
|
case Instruction::Shl:
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user