[llvm-commits] [llvm] r98999 - in /llvm/trunk/utils/TableGen: CodeGenDAGPatterns.cpp CodeGenDAGPatterns.h DAGISelEmitter.cpp DAGISelMatcherGen.cpp FastISelEmitter.cpp
Chris Lattner
sabre at nondot.org
Fri Mar 19 14:37:09 PDT 2010
Author: lattner
Date: Fri Mar 19 16:37:09 2010
New Revision: 98999
URL: http://llvm.org/viewvc/llvm-project?rev=98999&view=rev
Log:
major surgery on tblgen: generalize TreePatternNode
to maintain a list of types (one for each result of
the node) instead of a single type. There are liberal
hacks added to emulate the old behavior in various
situations, but they can start disolving now.
Modified:
llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp
llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h
llvm/trunk/utils/TableGen/DAGISelEmitter.cpp
llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp
llvm/trunk/utils/TableGen/FastISelEmitter.cpp
Modified: llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp?rev=98999&r1=98998&r2=98999&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp (original)
+++ llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp Fri Mar 19 16:37:09 2010
@@ -566,6 +566,7 @@
const SDNodeInfo &NodeInfo,
TreePattern &TP) const {
unsigned NumResults = NodeInfo.getNumResults();
+ unsigned ResNo = 0; // TODO: Set to the result # we're working with.
assert(NumResults <= 1 &&
"We only work with nodes with zero or one result so far!");
@@ -582,24 +583,25 @@
default: assert(0 && "Unknown constraint type!");
case SDTCisVT:
// Operand must be a particular type.
- return NodeToApply->UpdateNodeType(x.SDTCisVT_Info.VT, TP);
+ return NodeToApply->UpdateNodeType(ResNo, x.SDTCisVT_Info.VT, TP);
case SDTCisPtrTy:
// Operand must be same as target pointer type.
- return NodeToApply->UpdateNodeType(MVT::iPTR, TP);
+ return NodeToApply->UpdateNodeType(ResNo, MVT::iPTR, TP);
case SDTCisInt:
// Require it to be one of the legal integer VTs.
- return NodeToApply->getExtType().EnforceInteger(TP);
+ return NodeToApply->getExtType(ResNo).EnforceInteger(TP);
case SDTCisFP:
// Require it to be one of the legal fp VTs.
- return NodeToApply->getExtType().EnforceFloatingPoint(TP);
+ return NodeToApply->getExtType(ResNo).EnforceFloatingPoint(TP);
case SDTCisVec:
// Require it to be one of the legal vector VTs.
- return NodeToApply->getExtType().EnforceVector(TP);
+ return NodeToApply->getExtType(ResNo).EnforceVector(TP);
case SDTCisSameAs: {
+ unsigned OResNo = 0; // FIXME: getOperandNum should return pair.
TreePatternNode *OtherNode =
getOperandNum(x.SDTCisSameAs_Info.OtherOperandNum, N, NumResults);
- return NodeToApply->UpdateNodeType(OtherNode->getExtType(), TP) |
- OtherNode->UpdateNodeType(NodeToApply->getExtType(), TP);
+ return NodeToApply->UpdateNodeType(OResNo, OtherNode->getExtType(ResNo),TP)|
+ OtherNode->UpdateNodeType(ResNo,NodeToApply->getExtType(OResNo),TP);
}
case SDTCisVTSmallerThanOp: {
// The NodeToApply must be a leaf node that is a VT. OtherOperandNum must
@@ -614,40 +616,44 @@
if (!isInteger(VT))
TP.error(N->getOperator()->getName() + " VT operand must be integer!");
+ unsigned OResNo = 0; // FIXME: getOperandNum should return pair.
TreePatternNode *OtherNode =
getOperandNum(x.SDTCisVTSmallerThanOp_Info.OtherOperandNum, N,NumResults);
// It must be integer.
- bool MadeChange = OtherNode->getExtType().EnforceInteger(TP);
+ bool MadeChange = OtherNode->getExtType(OResNo).EnforceInteger(TP);
// This doesn't try to enforce any information on the OtherNode, it just
// validates it when information is determined.
- if (OtherNode->hasTypeSet() && OtherNode->getType() <= VT)
- OtherNode->UpdateNodeType(MVT::Other, TP); // Throw an error.
+ if (OtherNode->hasTypeSet(OResNo) && OtherNode->getType(OResNo) <= VT)
+ OtherNode->UpdateNodeType(OResNo, MVT::Other, TP); // Throw an error.
return MadeChange;
}
case SDTCisOpSmallerThanOp: {
+ unsigned BResNo = 0; // FIXME: getOperandNum should return pair.
TreePatternNode *BigOperand =
getOperandNum(x.SDTCisOpSmallerThanOp_Info.BigOperandNum, N, NumResults);
- return NodeToApply->getExtType().
- EnforceSmallerThan(BigOperand->getExtType(), TP);
+ return NodeToApply->getExtType(ResNo).
+ EnforceSmallerThan(BigOperand->getExtType(BResNo), TP);
}
case SDTCisEltOfVec: {
+ unsigned VResNo = 0; // FIXME: getOperandNum should return pair.
TreePatternNode *VecOperand =
getOperandNum(x.SDTCisEltOfVec_Info.OtherOperandNum, N, NumResults);
- if (VecOperand->hasTypeSet()) {
- if (!isVector(VecOperand->getType()))
+ if (VecOperand->hasTypeSet(VResNo)) {
+ if (!isVector(VecOperand->getType(VResNo)))
TP.error(N->getOperator()->getName() + " VT operand must be a vector!");
- EVT IVT = VecOperand->getType();
+ EVT IVT = VecOperand->getType(VResNo);
IVT = IVT.getVectorElementType();
- return NodeToApply->UpdateNodeType(IVT.getSimpleVT().SimpleTy, TP);
+ return NodeToApply->UpdateNodeType(ResNo, IVT.getSimpleVT().SimpleTy, TP);
}
- if (NodeToApply->hasTypeSet() && VecOperand->getExtType().hasVectorTypes()){
+ if (NodeToApply->hasTypeSet(ResNo) &&
+ VecOperand->getExtType(VResNo).hasVectorTypes()){
// Filter vector types out of VecOperand that don't have the right element
// type.
- return VecOperand->getExtType().
- EnforceVectorEltTypeIs(NodeToApply->getType(), TP);
+ return VecOperand->getExtType(VResNo).
+ EnforceVectorEltTypeIs(NodeToApply->getType(ResNo), TP);
}
return false;
}
@@ -740,17 +746,73 @@
#endif
}
-
+static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) {
+ if (Operator->getName() == "set" ||
+ Operator->getName() == "implicit" ||
+ Operator->getName() == "parallel")
+ return 0; // All return nothing.
+
+ if (Operator->isSubClassOf("Intrinsic")) {
+ unsigned NumRes = CDP.getIntrinsic(Operator).IS.RetVTs.size();
+ if (NumRes == 1 && CDP.getIntrinsic(Operator).IS.RetVTs[0] == MVT::isVoid)
+ return 0;
+ return NumRes;
+ }
+
+ if (Operator->isSubClassOf("SDNode"))
+ return CDP.getSDNodeInfo(Operator).getNumResults();
+
+ if (Operator->isSubClassOf("PatFrag")) {
+ // If we've already parsed this pattern fragment, get it. Otherwise, handle
+ // the forward reference case where one pattern fragment references another
+ // before it is processed.
+ if (TreePattern *PFRec = CDP.getPatternFragmentIfRead(Operator))
+ return PFRec->getOnlyTree()->getNumTypes();
+
+ // Get the result tree.
+ DagInit *Tree = Operator->getValueAsDag("Fragment");
+ Record *Op = 0;
+ if (Tree && dynamic_cast<DefInit*>(Tree->getOperator()))
+ Op = dynamic_cast<DefInit*>(Tree->getOperator())->getDef();
+ assert(Op && "Invalid Fragment");
+ return GetNumNodeResults(Op, CDP);
+ }
+
+ if (Operator->isSubClassOf("Instruction")) {
+ CodeGenInstruction &InstInfo = CDP.getTargetInfo().getInstruction(Operator);
+
+ // FIXME: Handle implicit defs right.
+ if (InstInfo.NumDefs != 0)
+ return 1; // FIXME: Handle inst results right!
+
+ if (!InstInfo.ImplicitDefs.empty()) {
+ // Add on one implicit def if it has a resolvable type.
+ Record *FirstImplicitDef = InstInfo.ImplicitDefs[0];
+ assert(FirstImplicitDef->isSubClassOf("Register"));
+ const std::vector<MVT::SimpleValueType> &RegVTs =
+ CDP.getTargetInfo().getRegisterVTs(FirstImplicitDef);
+ if (RegVTs.size() == 1)
+ return 1;
+ }
+ return 0;
+ }
+
+ if (Operator->isSubClassOf("SDNodeXForm"))
+ return 1; // FIXME: Generalize SDNodeXForm
+
+ Operator->dump();
+ errs() << "Unhandled node in GetNumNodeResults\n";
+ exit(1);
+}
void TreePatternNode::print(raw_ostream &OS) const {
- if (isLeaf()) {
+ if (isLeaf())
OS << *getLeafValue();
- } else {
+ else
OS << '(' << getOperator()->getName();
- }
-
- if (!isTypeCompletelyUnknown())
- OS << ':' << getExtType().getName();
+
+ for (unsigned i = 0, e = Types.size(); i != e; ++i)
+ OS << ':' << getExtType(i).getName();
if (!isLeaf()) {
if (getNumChildren() != 0) {
@@ -786,7 +848,7 @@
bool TreePatternNode::isIsomorphicTo(const TreePatternNode *N,
const MultipleUseVarSet &DepVars) const {
if (N == this) return true;
- if (N->isLeaf() != isLeaf() || getExtType() != N->getExtType() ||
+ if (N->isLeaf() != isLeaf() || getExtTypes() != N->getExtTypes() ||
getPredicateFns() != N->getPredicateFns() ||
getTransformFn() != N->getTransformFn())
return false;
@@ -815,16 +877,16 @@
TreePatternNode *TreePatternNode::clone() const {
TreePatternNode *New;
if (isLeaf()) {
- New = new TreePatternNode(getLeafValue());
+ New = new TreePatternNode(getLeafValue(), getNumTypes());
} else {
std::vector<TreePatternNode*> CChildren;
CChildren.reserve(Children.size());
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
CChildren.push_back(getChild(i)->clone());
- New = new TreePatternNode(getOperator(), CChildren);
+ New = new TreePatternNode(getOperator(), CChildren, getNumTypes());
}
New->setName(getName());
- New->setType(getExtType());
+ New->Types = Types;
New->setPredicateFns(getPredicateFns());
New->setTransformFn(getTransformFn());
return New;
@@ -832,7 +894,8 @@
/// RemoveAllTypes - Recursively strip all the types of this tree.
void TreePatternNode::RemoveAllTypes() {
- setType(EEVT::TypeSet()); // Reset to unknown type.
+ for (unsigned i = 0, e = Types.size(); i != e; ++i)
+ Types[i] = EEVT::TypeSet(); // Reset to unknown type.
if (isLeaf()) return;
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
getChild(i)->RemoveAllTypes();
@@ -914,7 +977,8 @@
}
FragTree->setName(getName());
- FragTree->UpdateNodeType(getExtType(), TP);
+ for (unsigned i = 0, e = Types.size(); i != e; ++i)
+ FragTree->UpdateNodeType(i, getExtType(i), TP);
// Transfer in the old predicates.
for (unsigned i = 0, e = getPredicateFns().size(); i != e; ++i)
@@ -932,8 +996,10 @@
/// type which should be applied to it. This will infer the type of register
/// references from the register file information, for example.
///
-static EEVT::TypeSet getImplicitType(Record *R, bool NotRegisters,
- TreePattern &TP) {
+static EEVT::TypeSet getImplicitType(Record *R, unsigned ResNo,
+ bool NotRegisters, TreePattern &TP) {
+ assert(ResNo == 0 && "FIXME: Unhandled result number");
+
// Check to see if this is a register or a register class.
if (R->isSubClassOf("RegisterClass")) {
if (NotRegisters)
@@ -1044,17 +1110,23 @@
if (isLeaf()) {
if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) {
// If it's a regclass or something else known, include the type.
- return UpdateNodeType(getImplicitType(DI->getDef(), NotRegisters, TP),TP);
+ bool MadeChange = false;
+ for (unsigned i = 0, e = Types.size(); i != e; ++i)
+ MadeChange |= UpdateNodeType(i, getImplicitType(DI->getDef(), i,
+ NotRegisters, TP), TP);
+ return MadeChange;
}
if (IntInit *II = dynamic_cast<IntInit*>(getLeafValue())) {
+ assert(Types.size() == 1 && "Invalid IntInit");
+
// Int inits are always integers. :)
- bool MadeChange = Type.EnforceInteger(TP);
+ bool MadeChange = Types[0].EnforceInteger(TP);
- if (!hasTypeSet())
+ if (!Types[0].isConcrete())
return MadeChange;
- MVT::SimpleValueType VT = getType();
+ MVT::SimpleValueType VT = getType(0);
if (VT == MVT::iPTR || VT == MVT::iPTRAny)
return MadeChange;
@@ -1075,7 +1147,7 @@
return MadeChange;
TP.error("Integer value '" + itostr(II->getValue())+
- "' is out of range for type '" + getEnumName(getType()) + "'!");
+ "' is out of range for type '" + getEnumName(getType(0)) + "'!");
return MadeChange;
}
return false;
@@ -1083,27 +1155,31 @@
// special handling for set, which isn't really an SDNode.
if (getOperator()->getName() == "set") {
- assert (getNumChildren() >= 2 && "Missing RHS of a set?");
+ assert(getNumTypes() == 0 && "Set doesn't produce a value");
+ assert(getNumChildren() >= 2 && "Missing RHS of a set?");
unsigned NC = getNumChildren();
- bool MadeChange = false;
+
+ TreePatternNode *SetVal = getChild(NC-1);
+ bool MadeChange = SetVal->ApplyTypeConstraints(TP, NotRegisters);
+
for (unsigned i = 0; i < NC-1; ++i) {
- MadeChange = getChild(i)->ApplyTypeConstraints(TP, NotRegisters);
- MadeChange |= getChild(NC-1)->ApplyTypeConstraints(TP, NotRegisters);
+ TreePatternNode *Child = getChild(i);
+ MadeChange |= Child->ApplyTypeConstraints(TP, NotRegisters);
// Types of operands must match.
- MadeChange |=getChild(i)->UpdateNodeType(getChild(NC-1)->getExtType(),TP);
- MadeChange |=getChild(NC-1)->UpdateNodeType(getChild(i)->getExtType(),TP);
- MadeChange |=UpdateNodeType(MVT::isVoid, TP);
+ MadeChange |= Child->UpdateNodeType(0, SetVal->getExtType(i), TP);
+ MadeChange |= SetVal->UpdateNodeType(i, Child->getExtType(0), TP);
}
return MadeChange;
}
if (getOperator()->getName() == "implicit" ||
getOperator()->getName() == "parallel") {
+ assert(getNumTypes() == 0 && "Node doesn't produce a value");
+
bool MadeChange = false;
for (unsigned i = 0; i < getNumChildren(); ++i)
MadeChange = getChild(i)->ApplyTypeConstraints(TP, NotRegisters);
- MadeChange |= UpdateNodeType(MVT::isVoid, TP);
return MadeChange;
}
@@ -1112,13 +1188,16 @@
MadeChange |= getChild(0)->ApplyTypeConstraints(TP, NotRegisters);
MadeChange |= getChild(1)->ApplyTypeConstraints(TP, NotRegisters);
+ assert(getChild(0)->getNumTypes() == 1 &&
+ getChild(1)->getNumTypes() == 1 && "Unhandled case");
+
// child #1 of COPY_TO_REGCLASS should be a register class. We don't care
// what type it gets, so if it didn't get a concrete type just give it the
// first viable type from the reg class.
- if (!getChild(1)->hasTypeSet() &&
- !getChild(1)->getExtType().isCompletelyUnknown()) {
- MVT::SimpleValueType RCVT = getChild(1)->getExtType().getTypeList()[0];
- MadeChange |= getChild(1)->UpdateNodeType(RCVT, TP);
+ if (!getChild(1)->hasTypeSet(0) &&
+ !getChild(1)->getExtType(0).isCompletelyUnknown()) {
+ MVT::SimpleValueType RCVT = getChild(1)->getExtType(0).getTypeList()[0];
+ MadeChange |= getChild(1)->UpdateNodeType(0, RCVT, TP);
}
return MadeChange;
}
@@ -1129,22 +1208,26 @@
// Apply the result type to the node.
unsigned NumRetVTs = Int->IS.RetVTs.size();
unsigned NumParamVTs = Int->IS.ParamVTs.size();
-
+ if (NumRetVTs == 1 && Int->IS.RetVTs[0] == MVT::isVoid)
+ NumRetVTs = 0;
+
for (unsigned i = 0, e = NumRetVTs; i != e; ++i)
- MadeChange |= UpdateNodeType(Int->IS.RetVTs[i], TP);
+ MadeChange |= UpdateNodeType(i, Int->IS.RetVTs[i], TP);
- if (getNumChildren() != NumParamVTs + NumRetVTs)
+ if (getNumChildren() != NumParamVTs + 1)
TP.error("Intrinsic '" + Int->Name + "' expects " +
- utostr(NumParamVTs + NumRetVTs - 1) + " operands, not " +
+ utostr(NumParamVTs) + " operands, not " +
utostr(getNumChildren() - 1) + " operands!");
// Apply type info to the intrinsic ID.
- MadeChange |= getChild(0)->UpdateNodeType(MVT::iPTR, TP);
+ MadeChange |= getChild(0)->UpdateNodeType(0, MVT::iPTR, TP);
- for (unsigned i = NumRetVTs, e = getNumChildren(); i != e; ++i) {
- MVT::SimpleValueType OpVT = Int->IS.ParamVTs[i - NumRetVTs];
- MadeChange |= getChild(i)->UpdateNodeType(OpVT, TP);
- MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters);
+ for (unsigned i = 0, e = getNumChildren()-1; i != e; ++i) {
+ MadeChange |= getChild(i+1)->ApplyTypeConstraints(TP, NotRegisters);
+
+ MVT::SimpleValueType OpVT = Int->IS.ParamVTs[i];
+ assert(getChild(i+1)->getNumTypes() == 1 && "Unhandled case");
+ MadeChange |= getChild(i+1)->UpdateNodeType(0, OpVT, TP);
}
return MadeChange;
}
@@ -1155,18 +1238,14 @@
bool MadeChange = NI.ApplyTypeConstraints(this, TP);
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters);
- // Branch, etc. do not produce results and top-level forms in instr pattern
- // must have void types.
- if (NI.getNumResults() == 0)
- MadeChange |= UpdateNodeType(MVT::isVoid, TP);
-
- return MadeChange;
+ return MadeChange;
}
if (getOperator()->isSubClassOf("Instruction")) {
const DAGInstruction &Inst = CDP.getInstruction(getOperator());
+ unsigned ResNo = 0;
assert(Inst.getNumResults() <= 1 &&
- "Only supports zero or one result instrs!");
+ "FIXME: Only supports zero or one result instrs!");
CodeGenInstruction &InstInfo =
CDP.getTargetInfo().getInstruction(getOperator());
@@ -1195,23 +1274,23 @@
assert(FirstImplicitDef->isSubClassOf("Register"));
const std::vector<MVT::SimpleValueType> &RegVTs =
CDP.getTargetInfo().getRegisterVTs(FirstImplicitDef);
- if (RegVTs.size() == 1)
+ if (RegVTs.size() == 1) // FIXME: Generalize.
ResultType = EEVT::TypeSet(RegVTs);
- else
- ResultType = EEVT::TypeSet(MVT::isVoid, TP);
} else {
// Otherwise, the instruction produces no value result.
- // FIXME: Model "no result" different than "one result that is void"
- ResultType = EEVT::TypeSet(MVT::isVoid, TP);
}
- bool MadeChange = UpdateNodeType(ResultType, TP);
+ bool MadeChange = false;
+
+ if (!ResultType.isCompletelyUnknown())
+ MadeChange |= UpdateNodeType(ResNo, ResultType, TP);
// If this is an INSERT_SUBREG, constrain the source and destination VTs to
// be the same.
if (getOperator()->getName() == "INSERT_SUBREG") {
- MadeChange |= UpdateNodeType(getChild(0)->getExtType(), TP);
- MadeChange |= getChild(0)->UpdateNodeType(getExtType(), TP);
+ assert(getChild(0)->getNumTypes() == 1 && "FIXME: Unhandled");
+ MadeChange |= UpdateNodeType(0, getChild(0)->getExtType(0), TP);
+ MadeChange |= getChild(0)->UpdateNodeType(0, getExtType(0), TP);
}
unsigned ChildNo = 0;
@@ -1233,15 +1312,17 @@
MVT::SimpleValueType VT;
TreePatternNode *Child = getChild(ChildNo++);
+ assert(Child->getNumTypes() == 1 && "Unknown case?");
+
if (OperandNode->isSubClassOf("RegisterClass")) {
const CodeGenRegisterClass &RC =
CDP.getTargetInfo().getRegisterClass(OperandNode);
- MadeChange |= Child->UpdateNodeType(RC.getValueTypes(), TP);
+ MadeChange |= Child->UpdateNodeType(0, RC.getValueTypes(), TP);
} else if (OperandNode->isSubClassOf("Operand")) {
VT = getValueType(OperandNode->getValueAsDef("Type"));
- MadeChange |= Child->UpdateNodeType(VT, TP);
+ MadeChange |= Child->UpdateNodeType(0, VT, TP);
} else if (OperandNode->isSubClassOf("PointerLikeRegClass")) {
- MadeChange |= Child->UpdateNodeType(MVT::iPTR, TP);
+ MadeChange |= Child->UpdateNodeType(0, MVT::iPTR, TP);
} else if (OperandNode->getName() == "unknown") {
// Nothing to do.
} else {
@@ -1373,6 +1454,7 @@
ComputeNamedNodes(N->getChild(i));
}
+
TreePatternNode *TreePattern::ParseTreePattern(DagInit *Dag) {
DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator());
if (!OpDef) error("Pattern has unexpected operator type!");
@@ -1401,11 +1483,11 @@
Args.push_back(Dag->getArgName(0));
}
- New = new TreePatternNode(DI);
+ New = new TreePatternNode(DI, 1);
} else if (DagInit *DI = dynamic_cast<DagInit*>(Arg)) {
New = ParseTreePattern(DI);
} else if (IntInit *II = dynamic_cast<IntInit*>(Arg)) {
- New = new TreePatternNode(II);
+ New = new TreePatternNode(II, 1);
if (!Dag->getArgName(0).empty())
error("Constant int argument should not have a name!");
} else if (BitsInit *BI = dynamic_cast<BitsInit*>(Arg)) {
@@ -1414,7 +1496,7 @@
if (II == 0 || !dynamic_cast<IntInit*>(II))
error("Bits value must be constants!");
- New = new TreePatternNode(dynamic_cast<IntInit*>(II));
+ New = new TreePatternNode(dynamic_cast<IntInit*>(II), 1);
if (!Dag->getArgName(0).empty())
error("Constant int argument should not have a name!");
} else {
@@ -1424,7 +1506,8 @@
}
// Apply the type cast.
- New->UpdateNodeType(getValueType(Operator), *this);
+ assert(New->getNumTypes() == 1 && "FIXME: Unhandled");
+ New->UpdateNodeType(0, getValueType(Operator), *this);
if (New->getNumChildren() == 0)
New->setName(Dag->getArgName(0));
return New;
@@ -1463,7 +1546,7 @@
std::vector<std::pair<Init*, std::string> >()));
--i; // Revisit this node...
} else {
- TreePatternNode *Node = new TreePatternNode(DefI);
+ TreePatternNode *Node = new TreePatternNode(DefI, 1);
Node->setName(Dag->getArgName(i));
Children.push_back(Node);
@@ -1475,7 +1558,7 @@
}
}
} else if (IntInit *II = dynamic_cast<IntInit*>(Arg)) {
- TreePatternNode *Node = new TreePatternNode(II);
+ TreePatternNode *Node = new TreePatternNode(II, 1);
if (!Dag->getArgName(i).empty())
error("Constant int argument should not have a name!");
Children.push_back(Node);
@@ -1485,7 +1568,7 @@
if (II == 0 || !dynamic_cast<IntInit*>(II))
error("Bits value must be constants!");
- TreePatternNode *Node = new TreePatternNode(dynamic_cast<IntInit*>(II));
+ TreePatternNode *Node = new TreePatternNode(dynamic_cast<IntInit*>(II),1);
if (!Dag->getArgName(i).empty())
error("Constant int argument should not have a name!");
Children.push_back(Node);
@@ -1516,11 +1599,12 @@
Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode();
}
- TreePatternNode *IIDNode = new TreePatternNode(new IntInit(IID));
+ TreePatternNode *IIDNode = new TreePatternNode(new IntInit(IID), 1);
Children.insert(Children.begin(), IIDNode);
}
- TreePatternNode *Result = new TreePatternNode(Operator, Children);
+ unsigned NumResults = GetNumNodeResults(Operator, CDP);
+ TreePatternNode *Result = new TreePatternNode(Operator, Children, NumResults);
Result->setName(Dag->getName());
return Result;
}
@@ -1567,7 +1651,11 @@
continue;
}
- MadeChange |=Nodes[i]->UpdateNodeType(InNodes[0]->getExtType(),*this);
+ assert(Nodes[i]->getNumTypes() == 1 &
+ InNodes[0]->getNumTypes() == 1 &&
+ "FIXME: cannot name multiple result nodes yet");
+ MadeChange |= Nodes[i]->UpdateNodeType(0, InNodes[0]->getExtType(0),
+ *this);
}
}
@@ -1575,8 +1663,12 @@
// same type.
if (I->second.size() > 1) {
for (unsigned i = 0, e = Nodes.size()-1; i != e; ++i) {
- MadeChange |=Nodes[i]->UpdateNodeType(Nodes[i+1]->getExtType(),*this);
- MadeChange |=Nodes[i+1]->UpdateNodeType(Nodes[i]->getExtType(),*this);
+ TreePatternNode *N1 = Nodes[i], *N2 = Nodes[i+1];
+ assert(N1->getNumTypes() == 1 & N2->getNumTypes() == 1 &&
+ "FIXME: cannot name multiple result nodes yet");
+
+ MadeChange |= N1->UpdateNodeType(0, N2->getExtType(0), *this);
+ MadeChange |= N2->UpdateNodeType(0, N1->getExtType(0), *this);
}
}
}
@@ -1874,7 +1966,7 @@
// Ensure that the inputs agree if we've already seen this input.
if (Rec != SlotRec)
I->error("All $" + Pat->getName() + " inputs must agree with each other");
- if (Slot->getExtType() != Pat->getExtType())
+ if (Slot->getExtTypes() != Pat->getExtTypes())
I->error("All $" + Pat->getName() + " inputs must agree with each other");
return true;
}
@@ -1913,7 +2005,7 @@
// If this is not a set, verify that the children nodes are not void typed,
// and recurse.
for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) {
- if (Pat->getChild(i)->getType() == MVT::isVoid)
+ if (Pat->getChild(i)->getNumTypes() == 0)
I->error("Cannot have void nodes inside of patterns!");
FindPatternInputsAndOutputs(I, Pat->getChild(i), InstInputs, InstResults,
InstImpInputs, InstImpResults);
@@ -2168,7 +2260,7 @@
// fill in the InstResults map.
for (unsigned j = 0, e = I->getNumTrees(); j != e; ++j) {
TreePatternNode *Pat = I->getTree(j);
- if (!Pat->hasTypeSet() || Pat->getType() != MVT::isVoid)
+ if (Pat->getNumTypes() != 0)
I->error("Top-level forms in instruction pattern should have"
" void types");
@@ -2188,7 +2280,7 @@
// Check that all of the results occur first in the list.
std::vector<Record*> Results;
- TreePatternNode *Res0Node = NULL;
+ TreePatternNode *Res0Node = 0;
for (unsigned i = 0; i != NumResults; ++i) {
if (i == CGI.OperandList.size())
I->error("'" + InstResults.begin()->first +
@@ -2266,7 +2358,7 @@
OpNode->setTransformFn(0);
std::vector<TreePatternNode*> Children;
Children.push_back(OpNode);
- OpNode = new TreePatternNode(Xform, Children);
+ OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes());
}
ResultNodeOperands.push_back(OpNode);
@@ -2277,10 +2369,11 @@
" occurs in pattern but not in operands list!");
TreePatternNode *ResultPattern =
- new TreePatternNode(I->getRecord(), ResultNodeOperands);
+ new TreePatternNode(I->getRecord(), ResultNodeOperands,
+ GetNumNodeResults(I->getRecord(), *this));
// Copy fully inferred output node type to instruction result pattern.
- if (NumResults > 0)
- ResultPattern->setType(Res0Node->getExtType());
+ for (unsigned i = 0; i != NumResults; ++i)
+ ResultPattern->setType(i, Res0Node->getExtType(i));
// Create and insert the instruction.
// FIXME: InstImpResults and InstImpInputs should not be part of
@@ -2341,7 +2434,7 @@
// If this is the first instance of the name, remember the node.
if (Rec.second++ == 0)
Rec.first = P;
- else if (Rec.first->getType() != P->getType())
+ else if (Rec.first->getExtTypes() != P->getExtTypes())
PatternTop->error("repetition of value: $" + P->getName() +
" where different uses have different types!");
}
@@ -2429,23 +2522,29 @@
// If this type is already concrete or completely unknown we can't do
// anything.
- if (N->getExtType().isCompletelyUnknown() || N->getExtType().isConcrete())
- return false;
+ for (unsigned i = 0, e = N->getNumTypes(); i != e; ++i) {
+ if (N->getExtType(i).isCompletelyUnknown() || N->getExtType(i).isConcrete())
+ continue;
+
+ // Otherwise, force its type to the first possibility (an arbitrary choice).
+ if (N->getExtType(i).MergeInTypeInfo(N->getExtType(i).getTypeList()[0], TP))
+ return true;
+ }
- // Otherwise, force its type to the first possibility (an arbitrary choice).
- return N->getExtType().MergeInTypeInfo(N->getExtType().getTypeList()[0], TP);
+ return false;
}
void CodeGenDAGPatterns::ParsePatterns() {
std::vector<Record*> Patterns = Records.getAllDerivedDefinitions("Pattern");
for (unsigned i = 0, e = Patterns.size(); i != e; ++i) {
- DagInit *Tree = Patterns[i]->getValueAsDag("PatternToMatch");
+ Record *CurPattern = Patterns[i];
+ DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch");
DefInit *OpDef = dynamic_cast<DefInit*>(Tree->getOperator());
Record *Operator = OpDef->getDef();
TreePattern *Pattern;
if (Operator->getName() != "parallel")
- Pattern = new TreePattern(Patterns[i], Tree, true, *this);
+ Pattern = new TreePattern(CurPattern, Tree, true, *this);
else {
std::vector<Init*> Values;
RecTy *ListTy = 0;
@@ -2470,17 +2569,17 @@
}
}
ListInit *LI = new ListInit(Values, new ListRecTy(ListTy));
- Pattern = new TreePattern(Patterns[i], LI, true, *this);
+ Pattern = new TreePattern(CurPattern, LI, true, *this);
}
// Inline pattern fragments into it.
Pattern->InlinePatternFragments();
- ListInit *LI = Patterns[i]->getValueAsListInit("ResultInstrs");
+ ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs");
if (LI->getSize() == 0) continue; // no pattern.
// Parse the instruction.
- TreePattern *Result = new TreePattern(Patterns[i], LI, false, *this);
+ TreePattern *Result = new TreePattern(CurPattern, LI, false, *this);
// Inline pattern fragments into it.
Result->InlinePatternFragments();
@@ -2508,12 +2607,13 @@
// resolve cases where the input type is known to be a pointer type (which
// is considered resolved), but the result knows it needs to be 32- or
// 64-bits. Infer the other way for good measure.
- if (!Result->getTree(0)->getExtType().isVoid() &&
- !Pattern->getTree(0)->getExtType().isVoid()) {
+ for (unsigned i = 0, e = std::min(Result->getTree(0)->getNumTypes(),
+ Pattern->getTree(0)->getNumTypes());
+ i != e; ++i) {
IterateInference = Pattern->getTree(0)->
- UpdateNodeType(Result->getTree(0)->getExtType(), *Result);
+ UpdateNodeType(i, Result->getTree(0)->getExtType(i), *Result);
IterateInference |= Result->getTree(0)->
- UpdateNodeType(Pattern->getTree(0)->getExtType(), *Result);
+ UpdateNodeType(i, Pattern->getTree(0)->getExtType(i), *Result);
}
// If our iteration has converged and the input pattern's types are fully
@@ -2559,25 +2659,29 @@
OpNode->setTransformFn(0);
std::vector<TreePatternNode*> Children;
Children.push_back(OpNode);
- OpNode = new TreePatternNode(Xform, Children);
+ OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes());
}
ResultNodeOperands.push_back(OpNode);
}
DstPattern = Result->getOnlyTree();
if (!DstPattern->isLeaf())
DstPattern = new TreePatternNode(DstPattern->getOperator(),
- ResultNodeOperands);
- DstPattern->setType(Result->getOnlyTree()->getExtType());
+ ResultNodeOperands,
+ DstPattern->getNumTypes());
+
+ for (unsigned i = 0, e = Result->getOnlyTree()->getNumTypes(); i != e; ++i)
+ DstPattern->setType(i, Result->getOnlyTree()->getExtType(i));
+
TreePattern Temp(Result->getRecord(), DstPattern, false, *this);
Temp.InferAllTypes();
AddPatternToMatch(Pattern,
- PatternToMatch(Patterns[i]->getValueAsListInit("Predicates"),
- Pattern->getTree(0),
- Temp.getOnlyTree(), InstImpResults,
- Patterns[i]->getValueAsInt("AddedComplexity"),
- Patterns[i]->getID()));
+ PatternToMatch(CurPattern->getValueAsListInit("Predicates"),
+ Pattern->getTree(0),
+ Temp.getOnlyTree(), InstImpResults,
+ CurPattern->getValueAsInt("AddedComplexity"),
+ CurPattern->getID()));
}
}
@@ -2611,13 +2715,15 @@
std::vector<TreePatternNode*> NewChildren;
for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i)
NewChildren.push_back(ChildVariants[i][Idxs[i]]);
- TreePatternNode *R = new TreePatternNode(Orig->getOperator(), NewChildren);
+ TreePatternNode *R = new TreePatternNode(Orig->getOperator(), NewChildren,
+ Orig->getNumTypes());
// Copy over properties.
R->setName(Orig->getName());
R->setPredicateFns(Orig->getPredicateFns());
R->setTransformFn(Orig->getTransformFn());
- R->setType(Orig->getExtType());
+ for (unsigned i = 0, e = Orig->getNumTypes(); i != e; ++i)
+ R->setType(i, Orig->getExtType(i));
// If this pattern cannot match, do not include it as a variant.
std::string ErrString;
Modified: llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h?rev=98999&r1=98998&r2=98999&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h (original)
+++ llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h Fri Mar 19 16:37:09 2010
@@ -238,10 +238,10 @@
/// patterns), and as such should be ref counted. We currently just leak all
/// TreePatternNode objects!
class TreePatternNode {
- /// The type of this node. Before and during type inference, this may be a
- /// set of possible types. After (successful) type inference, this is a
- /// single type.
- EEVT::TypeSet Type;
+ /// The type of each node result. Before and during type inference, each
+ /// result may be a set of possible types. After (successful) type inference,
+ /// each is a single concrete type.
+ SmallVector<EEVT::TypeSet, 1> Types;
/// Operator - The Record for the operator if this is an interior node (not
/// a leaf).
@@ -265,10 +265,14 @@
std::vector<TreePatternNode*> Children;
public:
- TreePatternNode(Record *Op, const std::vector<TreePatternNode*> &Ch)
- : Operator(Op), Val(0), TransformFn(0), Children(Ch) { }
- TreePatternNode(Init *val) // leaf ctor
+ TreePatternNode(Record *Op, const std::vector<TreePatternNode*> &Ch,
+ unsigned NumResults)
+ : Operator(Op), Val(0), TransformFn(0), Children(Ch) {
+ Types.resize(NumResults);
+ }
+ TreePatternNode(Init *val, unsigned NumResults) // leaf ctor
: Operator(0), Val(val), TransformFn(0) {
+ Types.resize(NumResults);
}
~TreePatternNode();
@@ -278,14 +282,24 @@
bool isLeaf() const { return Val != 0; }
// Type accessors.
- MVT::SimpleValueType getType() const { return Type.getConcrete(); }
- const EEVT::TypeSet &getExtType() const { return Type; }
- EEVT::TypeSet &getExtType() { return Type; }
- void setType(const EEVT::TypeSet &T) { Type = T; }
-
- bool hasTypeSet() const { return Type.isConcrete(); }
- bool isTypeCompletelyUnknown() const { return Type.isCompletelyUnknown(); }
- bool isTypeDynamicallyResolved() const { return Type.isDynamicallyResolved();}
+ unsigned getNumTypes() const { return Types.size(); }
+ MVT::SimpleValueType getType(unsigned ResNo) const {
+ return Types[ResNo].getConcrete();
+ }
+ const SmallVectorImpl<EEVT::TypeSet> &getExtTypes() const { return Types; }
+ const EEVT::TypeSet &getExtType(unsigned ResNo) const { return Types[ResNo]; }
+ EEVT::TypeSet &getExtType(unsigned ResNo) { return Types[ResNo]; }
+ void setType(unsigned ResNo, const EEVT::TypeSet &T) { Types[ResNo] = T; }
+
+ bool hasTypeSet(unsigned ResNo) const {
+ return Types[ResNo].isConcrete();
+ }
+ bool isTypeCompletelyUnknown(unsigned ResNo) const {
+ return Types[ResNo].isCompletelyUnknown();
+ }
+ bool isTypeDynamicallyResolved(unsigned ResNo) const {
+ return Types[ResNo].isDynamicallyResolved();
+ }
Init *getLeafValue() const { assert(isLeaf()); return Val; }
Record *getOperator() const { assert(!isLeaf()); return Operator; }
@@ -378,18 +392,22 @@
/// information. If N already contains a conflicting type, then throw an
/// exception. This returns true if any information was updated.
///
- bool UpdateNodeType(const EEVT::TypeSet &InTy, TreePattern &TP) {
- return Type.MergeInTypeInfo(InTy, TP);
+ bool UpdateNodeType(unsigned ResNo, const EEVT::TypeSet &InTy,
+ TreePattern &TP) {
+ return Types[ResNo].MergeInTypeInfo(InTy, TP);
}
- bool UpdateNodeType(MVT::SimpleValueType InTy, TreePattern &TP) {
- return Type.MergeInTypeInfo(EEVT::TypeSet(InTy, TP), TP);
+ bool UpdateNodeType(unsigned ResNo, MVT::SimpleValueType InTy,
+ TreePattern &TP) {
+ return Types[ResNo].MergeInTypeInfo(EEVT::TypeSet(InTy, TP), TP);
}
/// ContainsUnresolvedType - Return true if this tree contains any
/// unresolved types.
bool ContainsUnresolvedType() const {
- if (!hasTypeSet()) return true;
+ for (unsigned i = 0, e = Types.size(); i != e; ++i)
+ if (!Types[i].isConcrete()) return true;
+
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
if (getChild(i)->ContainsUnresolvedType()) return true;
return false;
@@ -679,6 +697,11 @@
assert(PatternFragments.count(R) && "Invalid pattern fragment request!");
return PatternFragments.find(R)->second;
}
+ TreePattern *getPatternFragmentIfRead(Record *R) const {
+ if (!PatternFragments.count(R)) return 0;
+ return PatternFragments.find(R)->second;
+ }
+
typedef std::map<Record*, TreePattern*, RecordPtrCmp>::const_iterator
pf_iterator;
pf_iterator pf_begin() const { return PatternFragments.begin(); }
Modified: llvm/trunk/utils/TableGen/DAGISelEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/DAGISelEmitter.cpp?rev=98999&r1=98998&r2=98999&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/DAGISelEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/DAGISelEmitter.cpp Fri Mar 19 16:37:09 2010
@@ -25,7 +25,6 @@
/// patterns before small ones. This is used to determine the size of a
/// pattern.
static unsigned getPatternSize(TreePatternNode *P, CodeGenDAGPatterns &CGP) {
- assert(P->hasTypeSet() && "Not a valid pattern node to size!");
unsigned Size = 3; // The node itself.
// If the root node is a ConstantSDNode, increases its size.
// e.g. (set R32:$dst, 0).
@@ -49,7 +48,8 @@
// Count children in the count if they are also nodes.
for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) {
TreePatternNode *Child = P->getChild(i);
- if (!Child->isLeaf() && Child->getType() != MVT::Other)
+ if (!Child->isLeaf() && Child->getNumTypes() &&
+ Child->getType(0) != MVT::Other)
Size += getPatternSize(Child, CGP);
else if (Child->isLeaf()) {
if (dynamic_cast<IntInit*>(Child->getLeafValue()))
Modified: llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp?rev=98999&r1=98998&r2=98999&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp (original)
+++ llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp Fri Mar 19 16:37:09 2010
@@ -409,8 +409,10 @@
// need to do a type check. Emit the check, apply the tyep to NodeNoTypes and
// reinfer any correlated types.
bool DoTypeCheck = false;
- if (NodeNoTypes->getExtType() != N->getExtType()) {
- NodeNoTypes->setType(N->getExtType());
+ if (NodeNoTypes->getNumTypes() != 0 &&
+ NodeNoTypes->getExtType(0) != N->getExtType(0)) {
+ assert(NodeNoTypes->getNumTypes() == 1 && "FIXME: Handle multiple results");
+ NodeNoTypes->setType(0, N->getExtType(0));
InferPossibleTypes();
DoTypeCheck = true;
}
@@ -442,8 +444,10 @@
for (unsigned i = 0, e = N->getPredicateFns().size(); i != e; ++i)
AddMatcher(new CheckPredicateMatcher(N->getPredicateFns()[i]));
- if (DoTypeCheck)
- AddMatcher(new CheckTypeMatcher(N->getType()));
+ if (DoTypeCheck) {
+ assert(N->getNumTypes() == 1);
+ AddMatcher(new CheckTypeMatcher(N->getType(0)));
+ }
}
/// EmitMatcherCode - Generate the code that matches the predicate of this
@@ -567,7 +571,7 @@
assert(N->isLeaf() && "Must be a leaf");
if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
- AddMatcher(new EmitIntegerMatcher(II->getValue(), N->getType()));
+ AddMatcher(new EmitIntegerMatcher(II->getValue(), N->getType(0)));
ResultOps.push_back(NextRecordedOperandNo++);
return;
}
@@ -575,13 +579,13 @@
// If this is an explicit register reference, handle it.
if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) {
if (DI->getDef()->isSubClassOf("Register")) {
- AddMatcher(new EmitRegisterMatcher(DI->getDef(), N->getType()));
+ AddMatcher(new EmitRegisterMatcher(DI->getDef(), N->getType(0)));
ResultOps.push_back(NextRecordedOperandNo++);
return;
}
if (DI->getDef()->getName() == "zero_reg") {
- AddMatcher(new EmitRegisterMatcher(0, N->getType()));
+ AddMatcher(new EmitRegisterMatcher(0, N->getType(0)));
ResultOps.push_back(NextRecordedOperandNo++);
return;
}
@@ -708,10 +712,11 @@
// Determine the result types.
SmallVector<MVT::SimpleValueType, 4> ResultVTs;
- if (N->getType() != MVT::isVoid) {
+ if (N->getNumTypes()) {
// FIXME2: If the node has multiple results, we should add them. For now,
// preserve existing behavior?!
- ResultVTs.push_back(N->getType());
+ assert(N->getNumTypes() == 1);
+ ResultVTs.push_back(N->getType(0));
}
// If this is the root instruction of a pattern that has physical registers in
@@ -723,7 +728,7 @@
// If the root came from an implicit def in the instruction handling stuff,
// don't re-add it.
Record *HandledReg = 0;
- if (NumResults == 0 && N->getType() != MVT::isVoid &&
+ if (NumResults == 0 && N->getNumTypes() != 0 &&
!II.ImplicitDefs.empty())
HandledReg = II.ImplicitDefs[0];
Modified: llvm/trunk/utils/TableGen/FastISelEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/FastISelEmitter.cpp?rev=98999&r1=98998&r2=98999&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/FastISelEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/FastISelEmitter.cpp Fri Mar 19 16:37:09 2010
@@ -70,13 +70,16 @@
for (unsigned i = 0, e = InstPatNode->getNumChildren(); i != e; ++i) {
TreePatternNode *Op = InstPatNode->getChild(i);
// For now, filter out any operand with a predicate.
- if (!Op->getPredicateFns().empty())
- return false;
// For now, filter out any operand with multiple values.
- assert(Op->hasTypeSet() && "Type infererence not done?");
+ if (!Op->getPredicateFns().empty() ||
+ Op->getNumTypes() != 1)
+ return false;
+
+ assert(Op->hasTypeSet(0) && "Type infererence not done?");
// For now, all the operands must have the same type.
- if (Op->getType() != VT)
+ if (Op->getType(0) != VT)
return false;
+
if (!Op->isLeaf()) {
if (Op->getOperator()->getName() == "imm") {
Operands.push_back("i");
@@ -295,10 +298,14 @@
Record *InstPatOp = InstPatNode->getOperator();
std::string OpcodeName = getOpcodeName(InstPatOp, CGP);
- MVT::SimpleValueType RetVT = InstPatNode->getType();
+ assert(InstPatNode->getNumTypes() <= 1);
+ MVT::SimpleValueType RetVT = MVT::isVoid;
+ if (InstPatNode->getNumTypes()) RetVT = InstPatNode->getType(0);
MVT::SimpleValueType VT = RetVT;
- if (InstPatNode->getNumChildren())
- VT = InstPatNode->getChild(0)->getType();
+ if (InstPatNode->getNumChildren()) {
+ assert(InstPatNode->getChild(0)->getNumTypes() == 1);
+ VT = InstPatNode->getChild(0)->getType(0);
+ }
// For now, filter out instructions which just set a register to
// an Operand or an immediate, like MOV32ri.
More information about the llvm-commits
mailing list