replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

pass the calling convention into Lower*CallTo, instead of using ad-hoc flags. 

llvm-svn: 34587
This commit is contained in:
Chris Lattner 2007-02-25 09:06:15 +00:00
parent 0cd9960fe7
commit 7802f3e2ea
2 changed files with 19 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
llvm/lib/Target/X86/X86ISelLowering.cpp
View File

@ -763,7 +763,7 @@ SDOperand X86TargetLowering::LowerCCCArguments(SDOperand Op, SelectionDAG &DAG,
} }
SDOperand X86TargetLowering::LowerCCCCallTo(SDOperand Op, SelectionDAG &DAG, SDOperand X86TargetLowering::LowerCCCCallTo(SDOperand Op, SelectionDAG &DAG,
bool isStdCall) { unsigned CC) {
SDOperand Chain = Op.getOperand(0); SDOperand Chain = Op.getOperand(0);
bool isVarArg = cast<ConstantSDNode>(Op.getOperand(2))->getValue() != 0; bool isVarArg = cast<ConstantSDNode>(Op.getOperand(2))->getValue() != 0;
bool isTailCall = cast<ConstantSDNode>(Op.getOperand(3))->getValue() != 0; bool isTailCall = cast<ConstantSDNode>(Op.getOperand(3))->getValue() != 0;
@ -808,7 +808,7 @@ SDOperand X86TargetLowering::LowerCCCCallTo(SDOperand Op, SelectionDAG &DAG,
ArgInRegs[i], ArgInRegs[i],
NumIntRegs, NumXMMRegs, 3, NumIntRegs, NumXMMRegs, 3,
ObjSize, ObjIntRegs, ObjXMMRegs, ObjSize, ObjIntRegs, ObjXMMRegs,
!isStdCall); CC != CallingConv::X86_StdCall);
if (ObjSize > 4) if (ObjSize > 4)
ArgIncrement = ObjSize; ArgIncrement = ObjSize;
@ -842,7 +842,7 @@ SDOperand X86TargetLowering::LowerCCCCallTo(SDOperand Op, SelectionDAG &DAG,
ArgInRegs[i], ArgInRegs[i],
NumIntRegs, NumXMMRegs, 3, NumIntRegs, NumXMMRegs, 3,
ObjSize, ObjIntRegs, ObjXMMRegs, ObjSize, ObjIntRegs, ObjXMMRegs,
!isStdCall); CC != CallingConv::X86_StdCall);
if (ObjSize > 4) if (ObjSize > 4)
ArgIncrement = ObjSize; ArgIncrement = ObjSize;
@ -868,7 +868,6 @@ SDOperand X86TargetLowering::LowerCCCCallTo(SDOperand Op, SelectionDAG &DAG,
case MVT::v2i64: case MVT::v2i64:
case MVT::v4f32: case MVT::v4f32:
case MVT::v2f64: case MVT::v2f64:
assert(!isStdCall && "Unhandled argument type!");
RegsToPass.push_back(std::make_pair(XMMArgRegs[NumXMMRegs], Arg)); RegsToPass.push_back(std::make_pair(XMMArgRegs[NumXMMRegs], Arg));
break; break;
} }
@ -956,12 +955,11 @@ SDOperand X86TargetLowering::LowerCCCCallTo(SDOperand Op, SelectionDAG &DAG,
// Create the CALLSEQ_END node. // Create the CALLSEQ_END node.
unsigned NumBytesForCalleeToPush = 0; unsigned NumBytesForCalleeToPush = 0;
if (isStdCall) { if (CC == CallingConv::X86_StdCall) {
if (isVarArg) { if (isVarArg)
NumBytesForCalleeToPush = NumSRetBytes; NumBytesForCalleeToPush = NumSRetBytes;
} else { else
NumBytesForCalleeToPush = NumBytes; NumBytesForCalleeToPush = NumBytes;
}
} else { } else {
// If this is is a call to a struct-return function, the callee // If this is is a call to a struct-return function, the callee
// pops the hidden struct pointer, so we have to push it back. // pops the hidden struct pointer, so we have to push it back.
@ -980,8 +978,7 @@ SDOperand X86TargetLowering::LowerCCCCallTo(SDOperand Op, SelectionDAG &DAG,
// Handle result values, copying them out of physregs into vregs that we // Handle result values, copying them out of physregs into vregs that we
// return. // return.
return SDOperand(LowerCallResult(Chain, InFlag, Op.Val, CallingConv::C, DAG), return SDOperand(LowerCallResult(Chain, InFlag, Op.Val, CC, DAG), Op.ResNo);
Op.ResNo);
} }
@ -1219,7 +1216,8 @@ X86TargetLowering::LowerX86_64CCCArguments(SDOperand Op, SelectionDAG &DAG) {
} }
SDOperand SDOperand
X86TargetLowering::LowerX86_64CCCCallTo(SDOperand Op, SelectionDAG &DAG) { X86TargetLowering::LowerX86_64CCCCallTo(SDOperand Op, SelectionDAG &DAG,
unsigned CallingConv) {
SDOperand Chain = Op.getOperand(0); SDOperand Chain = Op.getOperand(0);
bool isVarArg = cast<ConstantSDNode>(Op.getOperand(2))->getValue() != 0; bool isVarArg = cast<ConstantSDNode>(Op.getOperand(2))->getValue() != 0;
bool isTailCall = cast<ConstantSDNode>(Op.getOperand(3))->getValue() != 0; bool isTailCall = cast<ConstantSDNode>(Op.getOperand(3))->getValue() != 0;
@ -1652,7 +1650,7 @@ X86TargetLowering::LowerFastCCArguments(SDOperand Op, SelectionDAG &DAG,
} }
SDOperand X86TargetLowering::LowerFastCCCallTo(SDOperand Op, SelectionDAG &DAG, SDOperand X86TargetLowering::LowerFastCCCallTo(SDOperand Op, SelectionDAG &DAG,
bool isFastCall) { unsigned CC) {
SDOperand Chain = Op.getOperand(0); SDOperand Chain = Op.getOperand(0);
bool isTailCall = cast<ConstantSDNode>(Op.getOperand(3))->getValue() != 0; bool isTailCall = cast<ConstantSDNode>(Op.getOperand(3))->getValue() != 0;
SDOperand Callee = Op.getOperand(4); SDOperand Callee = Op.getOperand(4);
@ -1677,7 +1675,8 @@ SDOperand X86TargetLowering::LowerFastCCCallTo(SDOperand Op, SelectionDAG &DAG,
X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3 X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3
}; };
unsigned GPRInd = (isFastCall ? 1 : 0); bool isFastCall = CC == CallingConv::X86_FastCall;
unsigned GPRInd = isFastCall ? 1 : 0;
for (unsigned i = 0; i != NumOps; ++i) { for (unsigned i = 0; i != NumOps; ++i) {
SDOperand Arg = Op.getOperand(5+2*i); SDOperand Arg = Op.getOperand(5+2*i);
@ -3935,21 +3934,20 @@ SDOperand X86TargetLowering::LowerCALL(SDOperand Op, SelectionDAG &DAG) {
unsigned CallingConv= cast<ConstantSDNode>(Op.getOperand(1))->getValue(); unsigned CallingConv= cast<ConstantSDNode>(Op.getOperand(1))->getValue();
if (Subtarget->is64Bit()) if (Subtarget->is64Bit())
return LowerX86_64CCCCallTo(Op, DAG); return LowerX86_64CCCCallTo(Op, DAG, CallingConv);
else else
switch (CallingConv) { switch (CallingConv) {
default: default:
assert(0 && "Unsupported calling convention"); assert(0 && "Unsupported calling convention");
case CallingConv::Fast: case CallingConv::Fast:
if (EnableFastCC) if (EnableFastCC)
return LowerFastCCCallTo(Op, DAG); return LowerFastCCCallTo(Op, DAG, CallingConv);
// Falls through // Falls through
case CallingConv::C: case CallingConv::C:
return LowerCCCCallTo(Op, DAG);
case CallingConv::X86_StdCall: case CallingConv::X86_StdCall:
return LowerCCCCallTo(Op, DAG, true); return LowerCCCCallTo(Op, DAG, CallingConv);
case CallingConv::X86_FastCall: case CallingConv::X86_FastCall:
return LowerFastCCCallTo(Op, DAG, true); return LowerFastCCCallTo(Op, DAG, CallingConv);
} }
} }

8
llvm/lib/Target/X86/X86ISelLowering.h
View File

@ -366,18 +366,16 @@ namespace llvm {
// C and StdCall Calling Convention implementation. // C and StdCall Calling Convention implementation.
SDOperand LowerCCCArguments(SDOperand Op, SelectionDAG &DAG, SDOperand LowerCCCArguments(SDOperand Op, SelectionDAG &DAG,
bool isStdCall = false); bool isStdCall = false);
SDOperand LowerCCCCallTo(SDOperand Op, SelectionDAG &DAG, SDOperand LowerCCCCallTo(SDOperand Op, SelectionDAG &DAG, unsigned CC);
bool isStdCall = false);
// X86-64 C Calling Convention implementation. // X86-64 C Calling Convention implementation.
SDOperand LowerX86_64CCCArguments(SDOperand Op, SelectionDAG &DAG); SDOperand LowerX86_64CCCArguments(SDOperand Op, SelectionDAG &DAG);
SDOperand LowerX86_64CCCCallTo(SDOperand Op, SelectionDAG &DAG); SDOperand LowerX86_64CCCCallTo(SDOperand Op, SelectionDAG &DAG,unsigned CC);
// Fast and FastCall Calling Convention implementation. // Fast and FastCall Calling Convention implementation.
SDOperand LowerFastCCArguments(SDOperand Op, SelectionDAG &DAG, SDOperand LowerFastCCArguments(SDOperand Op, SelectionDAG &DAG,
bool isFastCall = false); bool isFastCall = false);
SDOperand LowerFastCCCallTo(SDOperand Op, SelectionDAG &DAG, SDOperand LowerFastCCCallTo(SDOperand Op, SelectionDAG &DAG, unsigned CC);
bool isFastCall = false);
SDOperand LowerBUILD_VECTOR(SDOperand Op, SelectionDAG &DAG); SDOperand LowerBUILD_VECTOR(SDOperand Op, SelectionDAG &DAG);
SDOperand LowerVECTOR_SHUFFLE(SDOperand Op, SelectionDAG &DAG); SDOperand LowerVECTOR_SHUFFLE(SDOperand Op, SelectionDAG &DAG);