RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 19:52:54 +01:00
Code Issues Projects Releases Wiki Activity

minor changes.

Browse Source 
llvm-svn: 29740
This commit is contained in:
Chris Lattner 2006-08-16 22:57:46 +00:00
parent c0e2997872
commit 62b0dcb385
2 changed files with 24 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
View File

@ -1459,26 +1459,21 @@ SDOperand SelectionDAG::getVecLoad(unsigned Count, MVT::ValueType EVT,
SDOperand SV) {
SDOperand Ops[] = { Chain, Ptr, SV, getConstant(Count, MVT::i32),
getValueType(EVT) };
// Add token chain.
const MVT::ValueType *VTs = getNodeValueTypes(MVT::Vector, MVT::Other);
return getNode(ISD::VLOAD, VTs, 2, Ops, 5);
return getNode(ISD::VLOAD, getVTList(MVT::Vector, MVT::Other), Ops, 5);
}
SDOperand SelectionDAG::getExtLoad(unsigned Opcode, MVT::ValueType VT,
SDOperand Chain, SDOperand Ptr, SDOperand SV,
MVT::ValueType EVT) {
SDOperand Ops[] = { Chain, Ptr, SV, getValueType(EVT) };
const MVT::ValueType *VTs = getNodeValueTypes(VT, MVT::Other);
return getNode(Opcode, VTs, 2, Ops, 4);
return getNode(Opcode, getVTList(VT, MVT::Other), Ops, 4);
}
SDOperand SelectionDAG::getVAArg(MVT::ValueType VT,
SDOperand Chain, SDOperand Ptr,
SDOperand SV) {
SDOperand Ops[] = { Chain, Ptr, SV };
// Add token chain.
const MVT::ValueType *VTs = getNodeValueTypes(VT, MVT::Other);
return getNode(ISD::VAARG, VTs, 2, Ops, 3);
return getNode(ISD::VAARG, getVTList(VT, MVT::Other), Ops, 3);
}
SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
@ -1562,27 +1557,34 @@ SDOperand SelectionDAG::getNode(unsigned Opcode,
const SDOperand *Ops, unsigned NumOps) {
if (NumVTs == 1)
return getNode(Opcode, VTs[0], Ops, NumOps);
return getNode(Opcode, makeVTList(VTs, NumVTs), Ops, NumOps);
}
SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList,
const SDOperand *Ops, unsigned NumOps) {
if (VTList.NumVTs == 1)
return getNode(Opcode, VTList.VTs[0], Ops, NumOps);
switch (Opcode) {
case ISD::EXTLOAD:
case ISD::SEXTLOAD:
case ISD::ZEXTLOAD: {
MVT::ValueType EVT = cast<VTSDNode>(Ops[3])->getVT();
assert(NumOps == 4 && NumVTs == 2 && "Bad *EXTLOAD!");
assert(NumOps == 4 && VTList.NumVTs == 2 && "Bad *EXTLOAD!");
// If they are asking for an extending load from/to the same thing, return a
// normal load.
if (VTs[0] == EVT)
return getLoad(VTs[0], Ops[0], Ops[1], Ops[2]);
if (MVT::isVector(VTs[0])) {
assert(EVT == MVT::getVectorBaseType(VTs[0]) &&
if (VTList.VTs[0] == EVT)
return getLoad(VTList.VTs[0], Ops[0], Ops[1], Ops[2]);
if (MVT::isVector(VTList.VTs[0])) {
assert(EVT == MVT::getVectorBaseType(VTList.VTs[0]) &&
"Invalid vector extload!");
} else {
assert(EVT < VTs[0] &&
assert(EVT < VTList.VTs[0] &&
"Should only be an extending load, not truncating!");
}
assert((Opcode == ISD::EXTLOAD || MVT::isInteger(VTs[0])) &&
assert((Opcode == ISD::EXTLOAD || MVT::isInteger(VTList.VTs[0])) &&
"Cannot sign/zero extend a FP/Vector load!");
assert(MVT::isInteger(VTs[0]) == MVT::isInteger(EVT) &&
assert(MVT::isInteger(VTList.VTs[0]) == MVT::isInteger(EVT) &&
"Cannot convert from FP to Int or Int -> FP!");
break;
}
@ -1611,8 +1613,7 @@ SDOperand SelectionDAG::getNode(unsigned Opcode,
// Memoize the node unless it returns a flag.
SDNode *N;
SDVTList VTList = makeVTList(VTs, NumVTs);
if (VTs[NumVTs-1] != MVT::Flag) {
if (VTList.VTs[VTList.NumVTs-1] != MVT::Flag) {
SelectionDAGCSEMap::NodeID ID;
ID.SetOpcode(Opcode);
ID.SetValueTypes(VTList);

9
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
View File

@ -2515,7 +2515,7 @@ TargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy, bool isVarArg,
unsigned CallingConv, bool isTailCall,
SDOperand Callee,
ArgListTy &Args, SelectionDAG &DAG) {
std::vector<SDOperand> Ops;
SmallVector<SDOperand, 32> Ops;
Ops.push_back(Chain); // Op#0 - Chain
Ops.push_back(DAG.getConstant(CallingConv, getPointerTy())); // Op#1 - CC
Ops.push_back(DAG.getConstant(isVarArg, getPointerTy())); // Op#2 - VarArg
@ -2592,7 +2592,7 @@ TargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy, bool isVarArg,
}
// Figure out the result value types.
std::vector<MVT::ValueType> RetTys;
SmallVector<MVT::ValueType, 4> RetTys;
if (RetTy != Type::VoidTy) {
MVT::ValueType VT = getValueType(RetTy);
@ -2636,8 +2636,9 @@ TargetLowering::LowerCallTo(SDOperand Chain, const Type *RetTy, bool isVarArg,
RetTys.push_back(MVT::Other); // Always has a chain.
// Finally, create the CALL node.
SDOperand Res = DAG.getNode(ISD::CALL, DAG.getNodeValueTypes(RetTys),
RetTys.size(), &Ops[0], Ops.size());
SDOperand Res = DAG.getNode(ISD::CALL,
DAG.getVTList(&RetTys[0], RetTys.size()),
&Ops[0], Ops.size());
// This returns a pair of operands. The first element is the
// return value for the function (if RetTy is not VoidTy). The second