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

Misc cleanup; addresses Duncan's comments on r138877.

Browse Source 
llvm-svn: 138887
This commit is contained in:
Eli Friedman 2011-08-31 20:13:26 +00:00
parent de17548520
commit f57df1ac66
4 changed files with 17 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
View File

@ -110,9 +110,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_BITCAST(SDNode *N) {
SDValue DAGTypeLegalizer::SoftenFloatRes_MERGE_VALUES(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_MERGE_VALUES(SDNode *N) {
SDValue Op = DecomposeMERGE_VALUES(N); SDValue Op = DecomposeMERGE_VALUES(N);
return Op.getValueType().isVector() ? return BitConvertToInteger(Op);
BitConvertVectorToIntegerVector(Op) :
BitConvertToInteger(Op);
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) {

7
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp
View File

@ -139,8 +139,6 @@ void DAGTypeLegalizer::PromoteIntegerResult(SDNode *N, unsigned ResNo) {
SDValue DAGTypeLegalizer::PromoteIntRes_MERGE_VALUES(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_MERGE_VALUES(SDNode *N) {
SDValue Op = DecomposeMERGE_VALUES(N); SDValue Op = DecomposeMERGE_VALUES(N);
assert(Op.getValueType().isInteger()
&& "Must decompose to an integer type!");
return GetPromotedInteger(Op); return GetPromotedInteger(Op);
} }
@ -1556,11 +1554,10 @@ void DAGTypeLegalizer::ExpandIntRes_ADDSUBE(SDNode *N,
// use the new one. // use the new one.
ReplaceValueWith(SDValue(N, 1), Hi.getValue(1)); ReplaceValueWith(SDValue(N, 1), Hi.getValue(1));
} }
void DAGTypeLegalizer::ExpandIntRes_MERGE_VALUES(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_MERGE_VALUES(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
SDValue Res = DecomposeMERGE_VALUES(N); SDValue Res = DecomposeMERGE_VALUES(N);
assert(Res.getValueType().isInteger()
&& "Cannot split a non-integer value.");
SplitInteger(Res, Lo, Hi); SplitInteger(Res, Lo, Hi);
} }

15
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp
View File

@ -948,21 +948,22 @@ bool DAGTypeLegalizer::CustomWidenLowerNode(SDNode *N, EVT VT) {
SDValue DAGTypeLegalizer::DecomposeMERGE_VALUES(SDNode *N) { SDValue DAGTypeLegalizer::DecomposeMERGE_VALUES(SDNode *N) {
unsigned i; unsigned i;
// A MERGE_VALUES node can produce any number of values. // A MERGE_VALUES node can produce any number of values.
// We know that the first illegal type needs to be handled. // Replace the results other than the first illegal one with the
// corresponding input operands.
for (i = 0; isTypeLegal(N->getValueType(i)); ++i) for (i = 0; isTypeLegal(N->getValueType(i)); ++i)
ReplaceValueWith(SDValue(N, i), SDValue(N->getOperand(i))); ReplaceValueWith(SDValue(N, i), SDValue(N->getOperand(i)));
// The first illegal result must be the one that needs to be handled. // The first illegal result is the one which needs to be handled;
SDValue BadValue = N->getOperand(i); // type legalization legalizes values in order.
SDValue IllegalValue = N->getOperand(i);
// Legalize the rest of the results into the input operands whether they // Continue replacing results.
// are legal or not.
unsigned e = N->getNumValues(); unsigned e = N->getNumValues();
for (++i; i != e; ++i) for (++i; i != e; ++i)
ReplaceValueWith(SDValue(N, i), SDValue(N->getOperand(i))); ReplaceValueWith(SDValue(N, i), SDValue(N->getOperand(i)));
return BadValue; return IllegalValue;
} }
/// GetSplitDestVTs - Compute the VTs needed for the low/hi parts of a type /// GetSplitDestVTs - Compute the VTs needed for the low/hi parts of a type

13
lib/CodeGen/SelectionDAG/LegalizeTypes.h
View File

@ -149,10 +149,9 @@ private:
bool CustomLowerNode(SDNode *N, EVT VT, bool LegalizeResult); bool CustomLowerNode(SDNode *N, EVT VT, bool LegalizeResult);
bool CustomWidenLowerNode(SDNode *N, EVT VT); bool CustomWidenLowerNode(SDNode *N, EVT VT);
// DecomposeMERGE_VALUES takes a SDNode and returns the first // DecomposeMERGE_VALUES takes a SDNode and returns the first
// illegal operand that needs to be modified. // illegal value. All other results are replaced with the
// All other nodes are legalized, whether they are legal or not. // corresponding input operand.
// The resulting SDValue needs to be modified to make it legal.
SDValue DecomposeMERGE_VALUES(SDNode *N); SDValue DecomposeMERGE_VALUES(SDNode *N);
SDValue GetVectorElementPointer(SDValue VecPtr, EVT EltVT, SDValue Index); SDValue GetVectorElementPointer(SDValue VecPtr, EVT EltVT, SDValue Index);
@ -162,9 +161,9 @@ private:
const SDValue *Ops, unsigned NumOps, bool isSigned, const SDValue *Ops, unsigned NumOps, bool isSigned,
DebugLoc dl); DebugLoc dl);
std::pair<SDValue, SDValue> ExpandChainLibCall(RTLIB::Libcall LC, std::pair<SDValue, SDValue> ExpandChainLibCall(RTLIB::Libcall LC,
SDNode *Node, bool isSigned); SDNode *Node, bool isSigned);
std::pair<SDValue, SDValue> ExpandAtomic(SDNode *Node); std::pair<SDValue, SDValue> ExpandAtomic(SDNode *Node);
SDValue PromoteTargetBoolean(SDValue Bool, EVT VT); SDValue PromoteTargetBoolean(SDValue Bool, EVT VT);
void ReplaceValueWith(SDValue From, SDValue To); void ReplaceValueWith(SDValue From, SDValue To);