2005-09-07 23:44:43 +00:00
|
|
|
//===- DAGISelEmitter.cpp - Generate an instruction selector --------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by Chris Lattner and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This tablegen backend emits a DAG instruction selector.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "DAGISelEmitter.h"
|
|
|
|
#include "Record.h"
|
|
|
|
#include "llvm/ADT/StringExtras.h"
|
|
|
|
#include "llvm/Support/Debug.h"
|
2005-09-25 19:04:43 +00:00
|
|
|
#include <algorithm>
|
2005-09-07 23:44:43 +00:00
|
|
|
#include <set>
|
|
|
|
using namespace llvm;
|
|
|
|
|
2005-10-14 06:12:03 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Helpers for working with extended types.
|
|
|
|
|
|
|
|
/// FilterVTs - Filter a list of VT's according to a predicate.
|
|
|
|
///
|
|
|
|
template<typename T>
|
|
|
|
static std::vector<MVT::ValueType>
|
|
|
|
FilterVTs(const std::vector<MVT::ValueType> &InVTs, T Filter) {
|
|
|
|
std::vector<MVT::ValueType> Result;
|
|
|
|
for (unsigned i = 0, e = InVTs.size(); i != e; ++i)
|
|
|
|
if (Filter(InVTs[i]))
|
|
|
|
Result.push_back(InVTs[i]);
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2005-12-30 00:12:56 +00:00
|
|
|
template<typename T>
|
|
|
|
static std::vector<unsigned char>
|
|
|
|
FilterEVTs(const std::vector<unsigned char> &InVTs, T Filter) {
|
|
|
|
std::vector<unsigned char> Result;
|
|
|
|
for (unsigned i = 0, e = InVTs.size(); i != e; ++i)
|
|
|
|
if (Filter((MVT::ValueType)InVTs[i]))
|
|
|
|
Result.push_back(InVTs[i]);
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::vector<unsigned char>
|
|
|
|
ConvertVTs(const std::vector<MVT::ValueType> &InVTs) {
|
|
|
|
std::vector<unsigned char> Result;
|
|
|
|
for (unsigned i = 0, e = InVTs.size(); i != e; ++i)
|
|
|
|
Result.push_back(InVTs[i]);
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool LHSIsSubsetOfRHS(const std::vector<unsigned char> &LHS,
|
|
|
|
const std::vector<unsigned char> &RHS) {
|
|
|
|
if (LHS.size() > RHS.size()) return false;
|
|
|
|
for (unsigned i = 0, e = LHS.size(); i != e; ++i)
|
2005-12-30 16:41:48 +00:00
|
|
|
if (std::find(RHS.begin(), RHS.end(), LHS[i]) == RHS.end())
|
2005-12-30 00:12:56 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isExtIntegerVT - Return true if the specified extended value type vector
|
|
|
|
/// contains isInt or an integer value type.
|
|
|
|
static bool isExtIntegerInVTs(std::vector<unsigned char> EVTs) {
|
|
|
|
assert(!EVTs.empty() && "Cannot check for integer in empty ExtVT list!");
|
|
|
|
return EVTs[0] == MVT::isInt || !(FilterEVTs(EVTs, MVT::isInteger).empty());
|
2005-10-14 06:12:03 +00:00
|
|
|
}
|
|
|
|
|
2005-12-30 00:12:56 +00:00
|
|
|
/// isExtFloatingPointVT - Return true if the specified extended value type
|
|
|
|
/// vector contains isFP or a FP value type.
|
|
|
|
static bool isExtFloatingPointInVTs(std::vector<unsigned char> EVTs) {
|
|
|
|
assert(!EVTs.empty() && "Cannot check for integer in empty ExtVT list!");
|
2006-01-28 19:06:51 +00:00
|
|
|
return EVTs[0] == MVT::isFP ||
|
|
|
|
!(FilterEVTs(EVTs, MVT::isFloatingPoint).empty());
|
2005-10-14 06:12:03 +00:00
|
|
|
}
|
|
|
|
|
2005-09-08 21:27:15 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SDTypeConstraint implementation
|
|
|
|
//
|
|
|
|
|
|
|
|
SDTypeConstraint::SDTypeConstraint(Record *R) {
|
|
|
|
OperandNo = R->getValueAsInt("OperandNum");
|
|
|
|
|
|
|
|
if (R->isSubClassOf("SDTCisVT")) {
|
|
|
|
ConstraintType = SDTCisVT;
|
|
|
|
x.SDTCisVT_Info.VT = getValueType(R->getValueAsDef("VT"));
|
2005-12-09 22:57:42 +00:00
|
|
|
} else if (R->isSubClassOf("SDTCisPtrTy")) {
|
|
|
|
ConstraintType = SDTCisPtrTy;
|
2005-09-08 21:27:15 +00:00
|
|
|
} else if (R->isSubClassOf("SDTCisInt")) {
|
|
|
|
ConstraintType = SDTCisInt;
|
|
|
|
} else if (R->isSubClassOf("SDTCisFP")) {
|
|
|
|
ConstraintType = SDTCisFP;
|
|
|
|
} else if (R->isSubClassOf("SDTCisSameAs")) {
|
|
|
|
ConstraintType = SDTCisSameAs;
|
|
|
|
x.SDTCisSameAs_Info.OtherOperandNum = R->getValueAsInt("OtherOperandNum");
|
|
|
|
} else if (R->isSubClassOf("SDTCisVTSmallerThanOp")) {
|
|
|
|
ConstraintType = SDTCisVTSmallerThanOp;
|
|
|
|
x.SDTCisVTSmallerThanOp_Info.OtherOperandNum =
|
|
|
|
R->getValueAsInt("OtherOperandNum");
|
2005-10-14 04:53:53 +00:00
|
|
|
} else if (R->isSubClassOf("SDTCisOpSmallerThanOp")) {
|
|
|
|
ConstraintType = SDTCisOpSmallerThanOp;
|
|
|
|
x.SDTCisOpSmallerThanOp_Info.BigOperandNum =
|
|
|
|
R->getValueAsInt("BigOperandNum");
|
2005-09-08 21:27:15 +00:00
|
|
|
} else {
|
|
|
|
std::cerr << "Unrecognized SDTypeConstraint '" << R->getName() << "'!\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
/// getOperandNum - Return the node corresponding to operand #OpNo in tree
|
|
|
|
/// N, which has NumResults results.
|
|
|
|
TreePatternNode *SDTypeConstraint::getOperandNum(unsigned OpNo,
|
|
|
|
TreePatternNode *N,
|
|
|
|
unsigned NumResults) const {
|
2005-12-04 08:18:16 +00:00
|
|
|
assert(NumResults <= 1 &&
|
|
|
|
"We only work with nodes with zero or one result so far!");
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
|
|
|
|
if (OpNo < NumResults)
|
|
|
|
return N; // FIXME: need value #
|
|
|
|
else
|
|
|
|
return N->getChild(OpNo-NumResults);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ApplyTypeConstraint - Given a node in a pattern, apply this type
|
|
|
|
/// constraint to the nodes operands. This returns true if it makes a
|
|
|
|
/// change, false otherwise. If a type contradiction is found, throw an
|
|
|
|
/// exception.
|
|
|
|
bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
|
|
|
|
const SDNodeInfo &NodeInfo,
|
|
|
|
TreePattern &TP) const {
|
|
|
|
unsigned NumResults = NodeInfo.getNumResults();
|
2005-12-04 08:18:16 +00:00
|
|
|
assert(NumResults <= 1 &&
|
|
|
|
"We only work with nodes with zero or one result so far!");
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
|
|
|
|
// Check that the number of operands is sane.
|
|
|
|
if (NodeInfo.getNumOperands() >= 0) {
|
|
|
|
if (N->getNumChildren() != (unsigned)NodeInfo.getNumOperands())
|
|
|
|
TP.error(N->getOperator()->getName() + " node requires exactly " +
|
|
|
|
itostr(NodeInfo.getNumOperands()) + " operands!");
|
|
|
|
}
|
2005-10-14 04:11:13 +00:00
|
|
|
|
|
|
|
const CodeGenTarget &CGT = TP.getDAGISelEmitter().getTargetInfo();
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
|
|
|
|
TreePatternNode *NodeToApply = getOperandNum(OperandNo, N, NumResults);
|
|
|
|
|
|
|
|
switch (ConstraintType) {
|
|
|
|
default: assert(0 && "Unknown constraint type!");
|
|
|
|
case SDTCisVT:
|
|
|
|
// Operand must be a particular type.
|
|
|
|
return NodeToApply->UpdateNodeType(x.SDTCisVT_Info.VT, TP);
|
2005-12-09 22:57:42 +00:00
|
|
|
case SDTCisPtrTy: {
|
|
|
|
// Operand must be same as target pointer type.
|
|
|
|
return NodeToApply->UpdateNodeType(CGT.getPointerType(), TP);
|
|
|
|
}
|
2005-10-14 04:11:13 +00:00
|
|
|
case SDTCisInt: {
|
|
|
|
// If there is only one integer type supported, this must be it.
|
2005-10-14 05:08:37 +00:00
|
|
|
std::vector<MVT::ValueType> IntVTs =
|
|
|
|
FilterVTs(CGT.getLegalValueTypes(), MVT::isInteger);
|
2005-10-14 04:11:13 +00:00
|
|
|
|
|
|
|
// If we found exactly one supported integer type, apply it.
|
2005-10-14 05:08:37 +00:00
|
|
|
if (IntVTs.size() == 1)
|
|
|
|
return NodeToApply->UpdateNodeType(IntVTs[0], TP);
|
2005-10-14 06:12:03 +00:00
|
|
|
return NodeToApply->UpdateNodeType(MVT::isInt, TP);
|
2005-10-14 04:11:13 +00:00
|
|
|
}
|
|
|
|
case SDTCisFP: {
|
|
|
|
// If there is only one FP type supported, this must be it.
|
2005-10-14 05:08:37 +00:00
|
|
|
std::vector<MVT::ValueType> FPVTs =
|
|
|
|
FilterVTs(CGT.getLegalValueTypes(), MVT::isFloatingPoint);
|
2005-10-14 04:11:13 +00:00
|
|
|
|
|
|
|
// If we found exactly one supported FP type, apply it.
|
2005-10-14 05:08:37 +00:00
|
|
|
if (FPVTs.size() == 1)
|
|
|
|
return NodeToApply->UpdateNodeType(FPVTs[0], TP);
|
2005-10-14 06:12:03 +00:00
|
|
|
return NodeToApply->UpdateNodeType(MVT::isFP, TP);
|
2005-10-14 04:11:13 +00:00
|
|
|
}
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
case SDTCisSameAs: {
|
|
|
|
TreePatternNode *OtherNode =
|
|
|
|
getOperandNum(x.SDTCisSameAs_Info.OtherOperandNum, N, NumResults);
|
2005-12-30 00:12:56 +00:00
|
|
|
return NodeToApply->UpdateNodeType(OtherNode->getExtTypes(), TP) |
|
|
|
|
OtherNode->UpdateNodeType(NodeToApply->getExtTypes(), TP);
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
}
|
|
|
|
case SDTCisVTSmallerThanOp: {
|
|
|
|
// The NodeToApply must be a leaf node that is a VT. OtherOperandNum must
|
|
|
|
// have an integer type that is smaller than the VT.
|
|
|
|
if (!NodeToApply->isLeaf() ||
|
|
|
|
!dynamic_cast<DefInit*>(NodeToApply->getLeafValue()) ||
|
|
|
|
!static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()
|
|
|
|
->isSubClassOf("ValueType"))
|
|
|
|
TP.error(N->getOperator()->getName() + " expects a VT operand!");
|
|
|
|
MVT::ValueType VT =
|
|
|
|
getValueType(static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef());
|
|
|
|
if (!MVT::isInteger(VT))
|
|
|
|
TP.error(N->getOperator()->getName() + " VT operand must be integer!");
|
|
|
|
|
|
|
|
TreePatternNode *OtherNode =
|
|
|
|
getOperandNum(x.SDTCisVTSmallerThanOp_Info.OtherOperandNum, N,NumResults);
|
2005-10-14 06:12:03 +00:00
|
|
|
|
|
|
|
// It must be integer.
|
|
|
|
bool MadeChange = false;
|
|
|
|
MadeChange |= OtherNode->UpdateNodeType(MVT::isInt, TP);
|
|
|
|
|
2005-12-30 00:12:56 +00:00
|
|
|
// This code only handles nodes that have one type set. Assert here so
|
|
|
|
// that we can change this if we ever need to deal with multiple value
|
|
|
|
// types at this point.
|
|
|
|
assert(OtherNode->getExtTypes().size() == 1 && "Node has too many types!");
|
|
|
|
if (OtherNode->hasTypeSet() && OtherNode->getTypeNum(0) <= VT)
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
OtherNode->UpdateNodeType(MVT::Other, TP); // Throw an error.
|
|
|
|
return false;
|
|
|
|
}
|
2005-10-14 04:53:53 +00:00
|
|
|
case SDTCisOpSmallerThanOp: {
|
2005-10-14 06:25:00 +00:00
|
|
|
TreePatternNode *BigOperand =
|
|
|
|
getOperandNum(x.SDTCisOpSmallerThanOp_Info.BigOperandNum, N, NumResults);
|
|
|
|
|
|
|
|
// Both operands must be integer or FP, but we don't care which.
|
|
|
|
bool MadeChange = false;
|
|
|
|
|
2005-12-30 00:12:56 +00:00
|
|
|
// This code does not currently handle nodes which have multiple types,
|
|
|
|
// where some types are integer, and some are fp. Assert that this is not
|
|
|
|
// the case.
|
|
|
|
assert(!(isExtIntegerInVTs(NodeToApply->getExtTypes()) &&
|
|
|
|
isExtFloatingPointInVTs(NodeToApply->getExtTypes())) &&
|
|
|
|
!(isExtIntegerInVTs(BigOperand->getExtTypes()) &&
|
|
|
|
isExtFloatingPointInVTs(BigOperand->getExtTypes())) &&
|
|
|
|
"SDTCisOpSmallerThanOp does not handle mixed int/fp types!");
|
|
|
|
if (isExtIntegerInVTs(NodeToApply->getExtTypes()))
|
2005-10-14 06:25:00 +00:00
|
|
|
MadeChange |= BigOperand->UpdateNodeType(MVT::isInt, TP);
|
2005-12-30 00:12:56 +00:00
|
|
|
else if (isExtFloatingPointInVTs(NodeToApply->getExtTypes()))
|
2005-10-14 06:25:00 +00:00
|
|
|
MadeChange |= BigOperand->UpdateNodeType(MVT::isFP, TP);
|
2005-12-30 00:12:56 +00:00
|
|
|
if (isExtIntegerInVTs(BigOperand->getExtTypes()))
|
2005-10-14 06:25:00 +00:00
|
|
|
MadeChange |= NodeToApply->UpdateNodeType(MVT::isInt, TP);
|
2005-12-30 00:12:56 +00:00
|
|
|
else if (isExtFloatingPointInVTs(BigOperand->getExtTypes()))
|
2005-10-14 06:25:00 +00:00
|
|
|
MadeChange |= NodeToApply->UpdateNodeType(MVT::isFP, TP);
|
|
|
|
|
|
|
|
std::vector<MVT::ValueType> VTs = CGT.getLegalValueTypes();
|
|
|
|
|
2005-12-30 00:12:56 +00:00
|
|
|
if (isExtIntegerInVTs(NodeToApply->getExtTypes())) {
|
2005-10-14 06:25:00 +00:00
|
|
|
VTs = FilterVTs(VTs, MVT::isInteger);
|
2005-12-30 00:12:56 +00:00
|
|
|
} else if (isExtFloatingPointInVTs(NodeToApply->getExtTypes())) {
|
2005-10-14 06:25:00 +00:00
|
|
|
VTs = FilterVTs(VTs, MVT::isFloatingPoint);
|
|
|
|
} else {
|
|
|
|
VTs.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (VTs.size()) {
|
|
|
|
default: // Too many VT's to pick from.
|
|
|
|
case 0: break; // No info yet.
|
|
|
|
case 1:
|
|
|
|
// Only one VT of this flavor. Cannot ever satisify the constraints.
|
|
|
|
return NodeToApply->UpdateNodeType(MVT::Other, TP); // throw
|
|
|
|
case 2:
|
|
|
|
// If we have exactly two possible types, the little operand must be the
|
|
|
|
// small one, the big operand should be the big one. Common with
|
|
|
|
// float/double for example.
|
|
|
|
assert(VTs[0] < VTs[1] && "Should be sorted!");
|
|
|
|
MadeChange |= NodeToApply->UpdateNodeType(VTs[0], TP);
|
|
|
|
MadeChange |= BigOperand->UpdateNodeType(VTs[1], TP);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return MadeChange;
|
2005-10-14 04:53:53 +00:00
|
|
|
}
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-09-08 21:03:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SDNodeInfo implementation
|
|
|
|
//
|
|
|
|
SDNodeInfo::SDNodeInfo(Record *R) : Def(R) {
|
|
|
|
EnumName = R->getValueAsString("Opcode");
|
|
|
|
SDClassName = R->getValueAsString("SDClass");
|
2005-09-08 21:27:15 +00:00
|
|
|
Record *TypeProfile = R->getValueAsDef("TypeProfile");
|
|
|
|
NumResults = TypeProfile->getValueAsInt("NumResults");
|
|
|
|
NumOperands = TypeProfile->getValueAsInt("NumOperands");
|
|
|
|
|
2005-09-28 18:28:29 +00:00
|
|
|
// Parse the properties.
|
|
|
|
Properties = 0;
|
2005-10-28 22:49:02 +00:00
|
|
|
std::vector<Record*> PropList = R->getValueAsListOfDefs("Properties");
|
2005-10-28 22:43:25 +00:00
|
|
|
for (unsigned i = 0, e = PropList.size(); i != e; ++i) {
|
|
|
|
if (PropList[i]->getName() == "SDNPCommutative") {
|
2005-09-28 18:28:29 +00:00
|
|
|
Properties |= 1 << SDNPCommutative;
|
2005-10-28 22:43:25 +00:00
|
|
|
} else if (PropList[i]->getName() == "SDNPAssociative") {
|
2005-09-28 20:58:06 +00:00
|
|
|
Properties |= 1 << SDNPAssociative;
|
2005-12-04 08:18:16 +00:00
|
|
|
} else if (PropList[i]->getName() == "SDNPHasChain") {
|
|
|
|
Properties |= 1 << SDNPHasChain;
|
2006-01-09 18:27:06 +00:00
|
|
|
} else if (PropList[i]->getName() == "SDNPOutFlag") {
|
|
|
|
Properties |= 1 << SDNPOutFlag;
|
|
|
|
} else if (PropList[i]->getName() == "SDNPInFlag") {
|
|
|
|
Properties |= 1 << SDNPInFlag;
|
|
|
|
} else if (PropList[i]->getName() == "SDNPOptInFlag") {
|
|
|
|
Properties |= 1 << SDNPOptInFlag;
|
2005-09-28 18:28:29 +00:00
|
|
|
} else {
|
2005-10-28 22:43:25 +00:00
|
|
|
std::cerr << "Unknown SD Node property '" << PropList[i]->getName()
|
2005-09-28 18:28:29 +00:00
|
|
|
<< "' on node '" << R->getName() << "'!\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-09-08 21:27:15 +00:00
|
|
|
// Parse the type constraints.
|
2005-10-28 22:49:02 +00:00
|
|
|
std::vector<Record*> ConstraintList =
|
|
|
|
TypeProfile->getValueAsListOfDefs("Constraints");
|
|
|
|
TypeConstraints.assign(ConstraintList.begin(), ConstraintList.end());
|
2005-09-08 21:03:01 +00:00
|
|
|
}
|
2005-09-07 23:44:43 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// TreePatternNode implementation
|
|
|
|
//
|
|
|
|
|
|
|
|
TreePatternNode::~TreePatternNode() {
|
|
|
|
#if 0 // FIXME: implement refcounted tree nodes!
|
|
|
|
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
|
|
|
|
delete getChild(i);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
/// UpdateNodeType - Set the node type of N to VT if VT contains
|
|
|
|
/// information. If N already contains a conflicting type, then throw an
|
|
|
|
/// exception. This returns true if any information was updated.
|
|
|
|
///
|
2005-12-30 00:12:56 +00:00
|
|
|
bool TreePatternNode::UpdateNodeType(const std::vector<unsigned char> &ExtVTs,
|
|
|
|
TreePattern &TP) {
|
|
|
|
assert(!ExtVTs.empty() && "Cannot update node type with empty type vector!");
|
|
|
|
|
|
|
|
if (ExtVTs[0] == MVT::isUnknown || LHSIsSubsetOfRHS(getExtTypes(), ExtVTs))
|
|
|
|
return false;
|
|
|
|
if (isTypeCompletelyUnknown() || LHSIsSubsetOfRHS(ExtVTs, getExtTypes())) {
|
|
|
|
setTypes(ExtVTs);
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-12-30 00:12:56 +00:00
|
|
|
if (ExtVTs[0] == MVT::isInt && isExtIntegerInVTs(getExtTypes())) {
|
|
|
|
assert(hasTypeSet() && "should be handled above!");
|
|
|
|
std::vector<unsigned char> FVTs = FilterEVTs(getExtTypes(), MVT::isInteger);
|
|
|
|
if (getExtTypes() == FVTs)
|
|
|
|
return false;
|
|
|
|
setTypes(FVTs);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (ExtVTs[0] == MVT::isFP && isExtFloatingPointInVTs(getExtTypes())) {
|
|
|
|
assert(hasTypeSet() && "should be handled above!");
|
2006-01-28 19:06:51 +00:00
|
|
|
std::vector<unsigned char> FVTs =
|
|
|
|
FilterEVTs(getExtTypes(), MVT::isFloatingPoint);
|
2005-12-30 00:12:56 +00:00
|
|
|
if (getExtTypes() == FVTs)
|
|
|
|
return false;
|
|
|
|
setTypes(FVTs);
|
|
|
|
return true;
|
|
|
|
}
|
2005-10-14 06:12:03 +00:00
|
|
|
|
|
|
|
// If we know this is an int or fp type, and we are told it is a specific one,
|
|
|
|
// take the advice.
|
2005-12-30 00:12:56 +00:00
|
|
|
//
|
|
|
|
// Similarly, we should probably set the type here to the intersection of
|
|
|
|
// {isInt|isFP} and ExtVTs
|
|
|
|
if ((getExtTypeNum(0) == MVT::isInt && isExtIntegerInVTs(ExtVTs)) ||
|
|
|
|
(getExtTypeNum(0) == MVT::isFP && isExtFloatingPointInVTs(ExtVTs))) {
|
|
|
|
setTypes(ExtVTs);
|
2005-10-14 06:12:03 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-10-26 16:59:37 +00:00
|
|
|
if (isLeaf()) {
|
|
|
|
dump();
|
2005-12-17 01:19:28 +00:00
|
|
|
std::cerr << " ";
|
2005-10-26 16:59:37 +00:00
|
|
|
TP.error("Type inference contradiction found in node!");
|
|
|
|
} else {
|
|
|
|
TP.error("Type inference contradiction found in node " +
|
|
|
|
getOperator()->getName() + "!");
|
|
|
|
}
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
return true; // unreachable
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
void TreePatternNode::print(std::ostream &OS) const {
|
|
|
|
if (isLeaf()) {
|
|
|
|
OS << *getLeafValue();
|
|
|
|
} else {
|
|
|
|
OS << "(" << getOperator()->getName();
|
|
|
|
}
|
|
|
|
|
2005-12-30 00:12:56 +00:00
|
|
|
// FIXME: At some point we should handle printing all the value types for
|
|
|
|
// nodes that are multiply typed.
|
|
|
|
switch (getExtTypeNum(0)) {
|
2005-10-14 06:12:03 +00:00
|
|
|
case MVT::Other: OS << ":Other"; break;
|
|
|
|
case MVT::isInt: OS << ":isInt"; break;
|
|
|
|
case MVT::isFP : OS << ":isFP"; break;
|
|
|
|
case MVT::isUnknown: ; /*OS << ":?";*/ break;
|
2005-12-30 00:12:56 +00:00
|
|
|
default: OS << ":" << getTypeNum(0); break;
|
2005-10-14 06:12:03 +00:00
|
|
|
}
|
2005-09-07 23:44:43 +00:00
|
|
|
|
|
|
|
if (!isLeaf()) {
|
|
|
|
if (getNumChildren() != 0) {
|
|
|
|
OS << " ";
|
|
|
|
getChild(0)->print(OS);
|
|
|
|
for (unsigned i = 1, e = getNumChildren(); i != e; ++i) {
|
|
|
|
OS << ", ";
|
|
|
|
getChild(i)->print(OS);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
OS << ")";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!PredicateFn.empty())
|
2005-09-13 21:51:00 +00:00
|
|
|
OS << "<<P:" << PredicateFn << ">>";
|
2005-09-14 22:55:26 +00:00
|
|
|
if (TransformFn)
|
|
|
|
OS << "<<X:" << TransformFn->getName() << ">>";
|
2005-09-07 23:44:43 +00:00
|
|
|
if (!getName().empty())
|
|
|
|
OS << ":$" << getName();
|
|
|
|
|
|
|
|
}
|
|
|
|
void TreePatternNode::dump() const {
|
|
|
|
print(std::cerr);
|
|
|
|
}
|
|
|
|
|
2005-09-29 19:28:10 +00:00
|
|
|
/// isIsomorphicTo - Return true if this node is recursively isomorphic to
|
|
|
|
/// the specified node. For this comparison, all of the state of the node
|
|
|
|
/// is considered, except for the assigned name. Nodes with differing names
|
|
|
|
/// that are otherwise identical are considered isomorphic.
|
|
|
|
bool TreePatternNode::isIsomorphicTo(const TreePatternNode *N) const {
|
|
|
|
if (N == this) return true;
|
2005-12-30 00:12:56 +00:00
|
|
|
if (N->isLeaf() != isLeaf() || getExtTypes() != N->getExtTypes() ||
|
2005-09-29 19:28:10 +00:00
|
|
|
getPredicateFn() != N->getPredicateFn() ||
|
|
|
|
getTransformFn() != N->getTransformFn())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (isLeaf()) {
|
|
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue()))
|
|
|
|
if (DefInit *NDI = dynamic_cast<DefInit*>(N->getLeafValue()))
|
|
|
|
return DI->getDef() == NDI->getDef();
|
|
|
|
return getLeafValue() == N->getLeafValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (N->getOperator() != getOperator() ||
|
|
|
|
N->getNumChildren() != getNumChildren()) return false;
|
|
|
|
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
|
|
|
|
if (!getChild(i)->isIsomorphicTo(N->getChild(i)))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
/// clone - Make a copy of this tree and all of its children.
|
|
|
|
///
|
|
|
|
TreePatternNode *TreePatternNode::clone() const {
|
|
|
|
TreePatternNode *New;
|
|
|
|
if (isLeaf()) {
|
|
|
|
New = new TreePatternNode(getLeafValue());
|
|
|
|
} 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->setName(getName());
|
2005-12-30 00:12:56 +00:00
|
|
|
New->setTypes(getExtTypes());
|
2005-09-07 23:44:43 +00:00
|
|
|
New->setPredicateFn(getPredicateFn());
|
2005-09-13 21:51:00 +00:00
|
|
|
New->setTransformFn(getTransformFn());
|
2005-09-07 23:44:43 +00:00
|
|
|
return New;
|
|
|
|
}
|
|
|
|
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
/// SubstituteFormalArguments - Replace the formal arguments in this tree
|
|
|
|
/// with actual values specified by ArgMap.
|
2005-09-07 23:44:43 +00:00
|
|
|
void TreePatternNode::
|
|
|
|
SubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) {
|
|
|
|
if (isLeaf()) return;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = getNumChildren(); i != e; ++i) {
|
|
|
|
TreePatternNode *Child = getChild(i);
|
|
|
|
if (Child->isLeaf()) {
|
|
|
|
Init *Val = Child->getLeafValue();
|
|
|
|
if (dynamic_cast<DefInit*>(Val) &&
|
|
|
|
static_cast<DefInit*>(Val)->getDef()->getName() == "node") {
|
|
|
|
// We found a use of a formal argument, replace it with its value.
|
|
|
|
Child = ArgMap[Child->getName()];
|
|
|
|
assert(Child && "Couldn't find formal argument!");
|
|
|
|
setChild(i, Child);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
getChild(i)->SubstituteFormalArguments(ArgMap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// InlinePatternFragments - If this pattern refers to any pattern
|
|
|
|
/// fragments, inline them into place, giving us a pattern without any
|
|
|
|
/// PatFrag references.
|
|
|
|
TreePatternNode *TreePatternNode::InlinePatternFragments(TreePattern &TP) {
|
|
|
|
if (isLeaf()) return this; // nothing to do.
|
|
|
|
Record *Op = getOperator();
|
|
|
|
|
|
|
|
if (!Op->isSubClassOf("PatFrag")) {
|
|
|
|
// Just recursively inline children nodes.
|
|
|
|
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
|
|
|
|
setChild(i, getChild(i)->InlinePatternFragments(TP));
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, we found a reference to a fragment. First, look up its
|
|
|
|
// TreePattern record.
|
|
|
|
TreePattern *Frag = TP.getDAGISelEmitter().getPatternFragment(Op);
|
|
|
|
|
|
|
|
// Verify that we are passing the right number of operands.
|
|
|
|
if (Frag->getNumArgs() != Children.size())
|
|
|
|
TP.error("'" + Op->getName() + "' fragment requires " +
|
|
|
|
utostr(Frag->getNumArgs()) + " operands!");
|
|
|
|
|
2005-09-09 01:15:01 +00:00
|
|
|
TreePatternNode *FragTree = Frag->getOnlyTree()->clone();
|
2005-09-07 23:44:43 +00:00
|
|
|
|
|
|
|
// Resolve formal arguments to their actual value.
|
|
|
|
if (Frag->getNumArgs()) {
|
|
|
|
// Compute the map of formal to actual arguments.
|
|
|
|
std::map<std::string, TreePatternNode*> ArgMap;
|
|
|
|
for (unsigned i = 0, e = Frag->getNumArgs(); i != e; ++i)
|
|
|
|
ArgMap[Frag->getArgName(i)] = getChild(i)->InlinePatternFragments(TP);
|
|
|
|
|
|
|
|
FragTree->SubstituteFormalArguments(ArgMap);
|
|
|
|
}
|
|
|
|
|
2005-09-08 17:45:12 +00:00
|
|
|
FragTree->setName(getName());
|
2005-12-30 00:12:56 +00:00
|
|
|
FragTree->UpdateNodeType(getExtTypes(), TP);
|
2005-09-08 17:45:12 +00:00
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
// Get a new copy of this fragment to stitch into here.
|
|
|
|
//delete this; // FIXME: implement refcounting!
|
|
|
|
return FragTree;
|
|
|
|
}
|
|
|
|
|
2005-10-14 04:11:13 +00:00
|
|
|
/// getIntrinsicType - Check to see if the specified record has an intrinsic
|
|
|
|
/// type which should be applied to it. This infer the type of register
|
|
|
|
/// references from the register file information, for example.
|
|
|
|
///
|
2005-12-30 00:12:56 +00:00
|
|
|
static std::vector<unsigned char> getIntrinsicType(Record *R, bool NotRegisters,
|
2005-10-14 06:12:03 +00:00
|
|
|
TreePattern &TP) {
|
2005-12-30 00:12:56 +00:00
|
|
|
// Some common return values
|
|
|
|
std::vector<unsigned char> Unknown(1, MVT::isUnknown);
|
|
|
|
std::vector<unsigned char> Other(1, MVT::Other);
|
|
|
|
|
2005-10-14 04:11:13 +00:00
|
|
|
// Check to see if this is a register or a register class...
|
|
|
|
if (R->isSubClassOf("RegisterClass")) {
|
2005-12-30 00:12:56 +00:00
|
|
|
if (NotRegisters)
|
|
|
|
return Unknown;
|
2005-12-01 04:51:06 +00:00
|
|
|
const CodeGenRegisterClass &RC =
|
|
|
|
TP.getDAGISelEmitter().getTargetInfo().getRegisterClass(R);
|
2005-12-30 00:12:56 +00:00
|
|
|
return ConvertVTs(RC.getValueTypes());
|
2005-10-14 04:11:13 +00:00
|
|
|
} else if (R->isSubClassOf("PatFrag")) {
|
|
|
|
// Pattern fragment types will be resolved when they are inlined.
|
2005-12-30 00:12:56 +00:00
|
|
|
return Unknown;
|
2005-10-14 04:11:13 +00:00
|
|
|
} else if (R->isSubClassOf("Register")) {
|
2006-01-15 10:04:45 +00:00
|
|
|
if (NotRegisters)
|
|
|
|
return Unknown;
|
2005-12-05 02:36:37 +00:00
|
|
|
// If the register appears in exactly one regclass, and the regclass has one
|
|
|
|
// value type, use it as the known type.
|
|
|
|
const CodeGenTarget &T = TP.getDAGISelEmitter().getTargetInfo();
|
|
|
|
if (const CodeGenRegisterClass *RC = T.getRegisterClassForRegister(R))
|
2005-12-30 00:12:56 +00:00
|
|
|
return ConvertVTs(RC->getValueTypes());
|
|
|
|
return Unknown;
|
2005-10-26 16:59:37 +00:00
|
|
|
} else if (R->isSubClassOf("ValueType") || R->isSubClassOf("CondCode")) {
|
|
|
|
// Using a VTSDNode or CondCodeSDNode.
|
2005-12-30 00:12:56 +00:00
|
|
|
return Other;
|
2005-12-08 02:00:36 +00:00
|
|
|
} else if (R->isSubClassOf("ComplexPattern")) {
|
2006-01-17 07:36:41 +00:00
|
|
|
if (NotRegisters)
|
|
|
|
return Unknown;
|
2005-12-30 00:12:56 +00:00
|
|
|
std::vector<unsigned char>
|
|
|
|
ComplexPat(1, TP.getDAGISelEmitter().getComplexPattern(R).getValueType());
|
|
|
|
return ComplexPat;
|
2005-12-14 02:21:57 +00:00
|
|
|
} else if (R->getName() == "node" || R->getName() == "srcvalue") {
|
2005-10-14 04:11:13 +00:00
|
|
|
// Placeholder.
|
2005-12-30 00:12:56 +00:00
|
|
|
return Unknown;
|
2005-10-14 04:11:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TP.error("Unknown node flavor used in pattern: " + R->getName());
|
2005-12-30 00:12:56 +00:00
|
|
|
return Other;
|
2005-10-14 04:11:13 +00:00
|
|
|
}
|
|
|
|
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
/// ApplyTypeConstraints - Apply all of the type constraints relevent to
|
|
|
|
/// this node and its children in the tree. This returns true if it makes a
|
|
|
|
/// change, false otherwise. If a type contradiction is found, throw an
|
|
|
|
/// exception.
|
2005-10-14 04:11:13 +00:00
|
|
|
bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
|
|
|
|
if (isLeaf()) {
|
2005-11-03 05:46:11 +00:00
|
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) {
|
2005-10-14 04:11:13 +00:00
|
|
|
// If it's a regclass or something else known, include the type.
|
|
|
|
return UpdateNodeType(getIntrinsicType(DI->getDef(), NotRegisters, TP),
|
|
|
|
TP);
|
2005-11-03 05:46:11 +00:00
|
|
|
} else if (IntInit *II = dynamic_cast<IntInit*>(getLeafValue())) {
|
|
|
|
// Int inits are always integers. :)
|
|
|
|
bool MadeChange = UpdateNodeType(MVT::isInt, TP);
|
|
|
|
|
|
|
|
if (hasTypeSet()) {
|
2005-12-30 00:12:56 +00:00
|
|
|
// At some point, it may make sense for this tree pattern to have
|
|
|
|
// multiple types. Assert here that it does not, so we revisit this
|
|
|
|
// code when appropriate.
|
|
|
|
assert(getExtTypes().size() == 1 && "TreePattern has too many types!");
|
|
|
|
|
|
|
|
unsigned Size = MVT::getSizeInBits(getTypeNum(0));
|
2005-11-03 05:46:11 +00:00
|
|
|
// Make sure that the value is representable for this type.
|
|
|
|
if (Size < 32) {
|
|
|
|
int Val = (II->getValue() << (32-Size)) >> (32-Size);
|
|
|
|
if (Val != II->getValue())
|
|
|
|
TP.error("Sign-extended integer value '" + itostr(II->getValue()) +
|
|
|
|
"' is out of range for type 'MVT::" +
|
2005-12-30 00:12:56 +00:00
|
|
|
getEnumName(getTypeNum(0)) + "'!");
|
2005-11-03 05:46:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return MadeChange;
|
|
|
|
}
|
2005-10-14 04:11:13 +00:00
|
|
|
return false;
|
|
|
|
}
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
|
|
|
|
// special handling for set, which isn't really an SDNode.
|
|
|
|
if (getOperator()->getName() == "set") {
|
|
|
|
assert (getNumChildren() == 2 && "Only handle 2 operand set's for now!");
|
2005-10-14 04:11:13 +00:00
|
|
|
bool MadeChange = getChild(0)->ApplyTypeConstraints(TP, NotRegisters);
|
|
|
|
MadeChange |= getChild(1)->ApplyTypeConstraints(TP, NotRegisters);
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
|
|
|
|
// Types of operands must match.
|
2005-12-30 00:12:56 +00:00
|
|
|
MadeChange |= getChild(0)->UpdateNodeType(getChild(1)->getExtTypes(), TP);
|
|
|
|
MadeChange |= getChild(1)->UpdateNodeType(getChild(0)->getExtTypes(), TP);
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
MadeChange |= UpdateNodeType(MVT::isVoid, TP);
|
|
|
|
return MadeChange;
|
2005-09-15 21:42:00 +00:00
|
|
|
} else if (getOperator()->isSubClassOf("SDNode")) {
|
|
|
|
const SDNodeInfo &NI = TP.getDAGISelEmitter().getSDNodeInfo(getOperator());
|
|
|
|
|
|
|
|
bool MadeChange = NI.ApplyTypeConstraints(this, TP);
|
|
|
|
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
|
2005-10-14 04:11:13 +00:00
|
|
|
MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters);
|
2005-12-04 08:18:16 +00:00
|
|
|
// 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);
|
2005-09-15 21:42:00 +00:00
|
|
|
return MadeChange;
|
2005-09-15 22:23:50 +00:00
|
|
|
} else if (getOperator()->isSubClassOf("Instruction")) {
|
2005-09-15 21:57:35 +00:00
|
|
|
const DAGInstruction &Inst =
|
|
|
|
TP.getDAGISelEmitter().getInstruction(getOperator());
|
2005-12-04 08:18:16 +00:00
|
|
|
bool MadeChange = false;
|
|
|
|
unsigned NumResults = Inst.getNumResults();
|
2005-09-15 21:57:35 +00:00
|
|
|
|
2005-12-04 08:18:16 +00:00
|
|
|
assert(NumResults <= 1 &&
|
|
|
|
"Only supports zero or one result instrs!");
|
2005-09-15 22:23:50 +00:00
|
|
|
// Apply the result type to the node
|
2005-12-04 08:18:16 +00:00
|
|
|
if (NumResults == 0) {
|
|
|
|
MadeChange = UpdateNodeType(MVT::isVoid, TP);
|
|
|
|
} else {
|
|
|
|
Record *ResultNode = Inst.getResult(0);
|
|
|
|
assert(ResultNode->isSubClassOf("RegisterClass") &&
|
|
|
|
"Operands should be register classes!");
|
2005-12-01 00:06:14 +00:00
|
|
|
|
2005-12-04 08:18:16 +00:00
|
|
|
const CodeGenRegisterClass &RC =
|
|
|
|
TP.getDAGISelEmitter().getTargetInfo().getRegisterClass(ResultNode);
|
2005-12-30 00:12:56 +00:00
|
|
|
MadeChange = UpdateNodeType(ConvertVTs(RC.getValueTypes()), TP);
|
2005-12-04 08:18:16 +00:00
|
|
|
}
|
2005-09-15 22:23:50 +00:00
|
|
|
|
|
|
|
if (getNumChildren() != Inst.getNumOperands())
|
|
|
|
TP.error("Instruction '" + getOperator()->getName() + " expects " +
|
|
|
|
utostr(Inst.getNumOperands()) + " operands, not " +
|
|
|
|
utostr(getNumChildren()) + " operands!");
|
|
|
|
for (unsigned i = 0, e = getNumChildren(); i != e; ++i) {
|
2005-12-01 00:06:14 +00:00
|
|
|
Record *OperandNode = Inst.getOperand(i);
|
|
|
|
MVT::ValueType VT;
|
|
|
|
if (OperandNode->isSubClassOf("RegisterClass")) {
|
|
|
|
const CodeGenRegisterClass &RC =
|
|
|
|
TP.getDAGISelEmitter().getTargetInfo().getRegisterClass(OperandNode);
|
2005-12-30 00:12:56 +00:00
|
|
|
//VT = RC.getValueTypeNum(0);
|
|
|
|
MadeChange |=getChild(i)->UpdateNodeType(ConvertVTs(RC.getValueTypes()),
|
|
|
|
TP);
|
2005-12-01 00:06:14 +00:00
|
|
|
} else if (OperandNode->isSubClassOf("Operand")) {
|
|
|
|
VT = getValueType(OperandNode->getValueAsDef("Type"));
|
2005-12-30 00:12:56 +00:00
|
|
|
MadeChange |= getChild(i)->UpdateNodeType(VT, TP);
|
2005-12-01 00:06:14 +00:00
|
|
|
} else {
|
|
|
|
assert(0 && "Unknown operand type!");
|
|
|
|
abort();
|
|
|
|
}
|
2005-10-14 04:11:13 +00:00
|
|
|
MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters);
|
2005-09-15 22:23:50 +00:00
|
|
|
}
|
|
|
|
return MadeChange;
|
|
|
|
} else {
|
|
|
|
assert(getOperator()->isSubClassOf("SDNodeXForm") && "Unknown node type!");
|
|
|
|
|
|
|
|
// Node transforms always take one operand, and take and return the same
|
|
|
|
// type.
|
|
|
|
if (getNumChildren() != 1)
|
|
|
|
TP.error("Node transform '" + getOperator()->getName() +
|
|
|
|
"' requires one operand!");
|
2005-12-30 00:12:56 +00:00
|
|
|
bool MadeChange = UpdateNodeType(getChild(0)->getExtTypes(), TP);
|
|
|
|
MadeChange |= getChild(0)->UpdateNodeType(getExtTypes(), TP);
|
2005-09-15 22:23:50 +00:00
|
|
|
return MadeChange;
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
/// canPatternMatch - If it is impossible for this pattern to match on this
|
|
|
|
/// target, fill in Reason and return false. Otherwise, return true. This is
|
|
|
|
/// used as a santity check for .td files (to prevent people from writing stuff
|
|
|
|
/// that can never possibly work), and to prevent the pattern permuter from
|
|
|
|
/// generating stuff that is useless.
|
2005-09-28 20:58:06 +00:00
|
|
|
bool TreePatternNode::canPatternMatch(std::string &Reason, DAGISelEmitter &ISE){
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
if (isLeaf()) return true;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
|
|
|
|
if (!getChild(i)->canPatternMatch(Reason, ISE))
|
|
|
|
return false;
|
2005-12-08 02:00:36 +00:00
|
|
|
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
// If this node is a commutative operator, check that the LHS isn't an
|
|
|
|
// immediate.
|
|
|
|
const SDNodeInfo &NodeInfo = ISE.getSDNodeInfo(getOperator());
|
|
|
|
if (NodeInfo.hasProperty(SDNodeInfo::SDNPCommutative)) {
|
|
|
|
// Scan all of the operands of the node and make sure that only the last one
|
|
|
|
// is a constant node.
|
|
|
|
for (unsigned i = 0, e = getNumChildren()-1; i != e; ++i)
|
|
|
|
if (!getChild(i)->isLeaf() &&
|
|
|
|
getChild(i)->getOperator()->getName() == "imm") {
|
|
|
|
Reason = "Immediate value must be on the RHS of commutative operators!";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// TreePattern implementation
|
|
|
|
//
|
|
|
|
|
2005-10-21 01:19:59 +00:00
|
|
|
TreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
|
2005-09-13 21:20:49 +00:00
|
|
|
DAGISelEmitter &ise) : TheRecord(TheRec), ISE(ise) {
|
2005-10-21 01:19:59 +00:00
|
|
|
isInputPattern = isInput;
|
2005-09-15 22:23:50 +00:00
|
|
|
for (unsigned i = 0, e = RawPat->getSize(); i != e; ++i)
|
|
|
|
Trees.push_back(ParseTreePattern((DagInit*)RawPat->getElement(i)));
|
|
|
|
}
|
2005-09-07 23:44:43 +00:00
|
|
|
|
2005-10-21 01:19:59 +00:00
|
|
|
TreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
|
2005-09-15 22:23:50 +00:00
|
|
|
DAGISelEmitter &ise) : TheRecord(TheRec), ISE(ise) {
|
2005-10-21 01:19:59 +00:00
|
|
|
isInputPattern = isInput;
|
2005-09-15 22:23:50 +00:00
|
|
|
Trees.push_back(ParseTreePattern(Pat));
|
2005-09-07 23:44:43 +00:00
|
|
|
}
|
|
|
|
|
2005-10-21 01:19:59 +00:00
|
|
|
TreePattern::TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,
|
2005-09-15 22:23:50 +00:00
|
|
|
DAGISelEmitter &ise) : TheRecord(TheRec), ISE(ise) {
|
2005-10-21 01:19:59 +00:00
|
|
|
isInputPattern = isInput;
|
2005-09-15 22:23:50 +00:00
|
|
|
Trees.push_back(Pat);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
void TreePattern::error(const std::string &Msg) const {
|
2005-09-14 20:53:42 +00:00
|
|
|
dump();
|
2005-09-13 21:20:49 +00:00
|
|
|
throw "In " + TheRecord->getName() + ": " + Msg;
|
2005-09-07 23:44:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TreePatternNode *TreePattern::ParseTreePattern(DagInit *Dag) {
|
|
|
|
Record *Operator = Dag->getNodeType();
|
|
|
|
|
|
|
|
if (Operator->isSubClassOf("ValueType")) {
|
|
|
|
// If the operator is a ValueType, then this must be "type cast" of a leaf
|
|
|
|
// node.
|
|
|
|
if (Dag->getNumArgs() != 1)
|
2005-10-14 04:11:13 +00:00
|
|
|
error("Type cast only takes one operand!");
|
2005-09-07 23:44:43 +00:00
|
|
|
|
|
|
|
Init *Arg = Dag->getArg(0);
|
|
|
|
TreePatternNode *New;
|
|
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(Arg)) {
|
2005-09-24 00:40:24 +00:00
|
|
|
Record *R = DI->getDef();
|
|
|
|
if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag")) {
|
|
|
|
Dag->setArg(0, new DagInit(R,
|
|
|
|
std::vector<std::pair<Init*, std::string> >()));
|
2005-11-16 23:14:54 +00:00
|
|
|
return ParseTreePattern(Dag);
|
2005-12-04 08:18:16 +00:00
|
|
|
}
|
2005-09-07 23:44:43 +00:00
|
|
|
New = new TreePatternNode(DI);
|
|
|
|
} else if (DagInit *DI = dynamic_cast<DagInit*>(Arg)) {
|
|
|
|
New = ParseTreePattern(DI);
|
2005-11-02 06:49:14 +00:00
|
|
|
} else if (IntInit *II = dynamic_cast<IntInit*>(Arg)) {
|
|
|
|
New = new TreePatternNode(II);
|
|
|
|
if (!Dag->getArgName(0).empty())
|
|
|
|
error("Constant int argument should not have a name!");
|
2005-09-07 23:44:43 +00:00
|
|
|
} else {
|
|
|
|
Arg->dump();
|
|
|
|
error("Unknown leaf value for tree pattern!");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
// Apply the type cast.
|
|
|
|
New->UpdateNodeType(getValueType(Operator), *this);
|
2005-11-16 23:14:54 +00:00
|
|
|
New->setName(Dag->getArgName(0));
|
2005-09-07 23:44:43 +00:00
|
|
|
return New;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Verify that this is something that makes sense for an operator.
|
|
|
|
if (!Operator->isSubClassOf("PatFrag") && !Operator->isSubClassOf("SDNode") &&
|
2005-09-15 21:42:00 +00:00
|
|
|
!Operator->isSubClassOf("Instruction") &&
|
|
|
|
!Operator->isSubClassOf("SDNodeXForm") &&
|
2005-09-07 23:44:43 +00:00
|
|
|
Operator->getName() != "set")
|
|
|
|
error("Unrecognized node '" + Operator->getName() + "'!");
|
|
|
|
|
2005-10-21 01:19:59 +00:00
|
|
|
// Check to see if this is something that is illegal in an input pattern.
|
|
|
|
if (isInputPattern && (Operator->isSubClassOf("Instruction") ||
|
|
|
|
Operator->isSubClassOf("SDNodeXForm")))
|
|
|
|
error("Cannot use '" + Operator->getName() + "' in an input pattern!");
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
std::vector<TreePatternNode*> Children;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
|
|
|
|
Init *Arg = Dag->getArg(i);
|
|
|
|
if (DagInit *DI = dynamic_cast<DagInit*>(Arg)) {
|
|
|
|
Children.push_back(ParseTreePattern(DI));
|
2005-11-16 23:14:54 +00:00
|
|
|
if (Children.back()->getName().empty())
|
|
|
|
Children.back()->setName(Dag->getArgName(i));
|
2005-09-07 23:44:43 +00:00
|
|
|
} else if (DefInit *DefI = dynamic_cast<DefInit*>(Arg)) {
|
|
|
|
Record *R = DefI->getDef();
|
|
|
|
// Direct reference to a leaf DagNode or PatFrag? Turn it into a
|
|
|
|
// TreePatternNode if its own.
|
|
|
|
if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag")) {
|
|
|
|
Dag->setArg(i, new DagInit(R,
|
|
|
|
std::vector<std::pair<Init*, std::string> >()));
|
|
|
|
--i; // Revisit this node...
|
|
|
|
} else {
|
|
|
|
TreePatternNode *Node = new TreePatternNode(DefI);
|
|
|
|
Node->setName(Dag->getArgName(i));
|
|
|
|
Children.push_back(Node);
|
|
|
|
|
|
|
|
// Input argument?
|
|
|
|
if (R->getName() == "node") {
|
|
|
|
if (Dag->getArgName(i).empty())
|
|
|
|
error("'node' argument requires a name to match with operand list");
|
|
|
|
Args.push_back(Dag->getArgName(i));
|
|
|
|
}
|
|
|
|
}
|
2005-10-19 04:30:56 +00:00
|
|
|
} else if (IntInit *II = dynamic_cast<IntInit*>(Arg)) {
|
|
|
|
TreePatternNode *Node = new TreePatternNode(II);
|
|
|
|
if (!Dag->getArgName(i).empty())
|
|
|
|
error("Constant int argument should not have a name!");
|
|
|
|
Children.push_back(Node);
|
2005-09-07 23:44:43 +00:00
|
|
|
} else {
|
2005-10-19 04:30:56 +00:00
|
|
|
std::cerr << '"';
|
2005-09-07 23:44:43 +00:00
|
|
|
Arg->dump();
|
2005-10-19 04:30:56 +00:00
|
|
|
std::cerr << "\": ";
|
2005-09-07 23:44:43 +00:00
|
|
|
error("Unknown leaf value for tree pattern!");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return new TreePatternNode(Operator, Children);
|
|
|
|
}
|
|
|
|
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
/// InferAllTypes - Infer/propagate as many types throughout the expression
|
|
|
|
/// patterns as possible. Return true if all types are infered, false
|
|
|
|
/// otherwise. Throw an exception if a type contradiction is found.
|
|
|
|
bool TreePattern::InferAllTypes() {
|
|
|
|
bool MadeChange = true;
|
|
|
|
while (MadeChange) {
|
|
|
|
MadeChange = false;
|
|
|
|
for (unsigned i = 0, e = Trees.size(); i != e; ++i)
|
2005-10-14 04:11:13 +00:00
|
|
|
MadeChange |= Trees[i]->ApplyTypeConstraints(*this, false);
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool HasUnresolvedTypes = false;
|
|
|
|
for (unsigned i = 0, e = Trees.size(); i != e; ++i)
|
|
|
|
HasUnresolvedTypes |= Trees[i]->ContainsUnresolvedType();
|
|
|
|
return !HasUnresolvedTypes;
|
|
|
|
}
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
void TreePattern::print(std::ostream &OS) const {
|
|
|
|
OS << getRecord()->getName();
|
|
|
|
if (!Args.empty()) {
|
|
|
|
OS << "(" << Args[0];
|
|
|
|
for (unsigned i = 1, e = Args.size(); i != e; ++i)
|
|
|
|
OS << ", " << Args[i];
|
|
|
|
OS << ")";
|
|
|
|
}
|
|
|
|
OS << ": ";
|
|
|
|
|
|
|
|
if (Trees.size() > 1)
|
|
|
|
OS << "[\n";
|
|
|
|
for (unsigned i = 0, e = Trees.size(); i != e; ++i) {
|
|
|
|
OS << "\t";
|
|
|
|
Trees[i]->print(OS);
|
|
|
|
OS << "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Trees.size() > 1)
|
|
|
|
OS << "]\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
void TreePattern::dump() const { print(std::cerr); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// DAGISelEmitter implementation
|
|
|
|
//
|
|
|
|
|
2005-09-08 21:03:01 +00:00
|
|
|
// Parse all of the SDNode definitions for the target, populating SDNodes.
|
|
|
|
void DAGISelEmitter::ParseNodeInfo() {
|
|
|
|
std::vector<Record*> Nodes = Records.getAllDerivedDefinitions("SDNode");
|
|
|
|
while (!Nodes.empty()) {
|
|
|
|
SDNodes.insert(std::make_pair(Nodes.back(), Nodes.back()));
|
|
|
|
Nodes.pop_back();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-13 21:51:00 +00:00
|
|
|
/// ParseNodeTransforms - Parse all SDNodeXForm instances into the SDNodeXForms
|
|
|
|
/// map, and emit them to the file as functions.
|
|
|
|
void DAGISelEmitter::ParseNodeTransforms(std::ostream &OS) {
|
|
|
|
OS << "\n// Node transformations.\n";
|
|
|
|
std::vector<Record*> Xforms = Records.getAllDerivedDefinitions("SDNodeXForm");
|
|
|
|
while (!Xforms.empty()) {
|
|
|
|
Record *XFormNode = Xforms.back();
|
|
|
|
Record *SDNode = XFormNode->getValueAsDef("Opcode");
|
|
|
|
std::string Code = XFormNode->getValueAsCode("XFormFunction");
|
|
|
|
SDNodeXForms.insert(std::make_pair(XFormNode,
|
|
|
|
std::make_pair(SDNode, Code)));
|
|
|
|
|
2005-09-13 22:03:37 +00:00
|
|
|
if (!Code.empty()) {
|
2005-09-13 21:51:00 +00:00
|
|
|
std::string ClassName = getSDNodeInfo(SDNode).getSDClassName();
|
|
|
|
const char *C2 = ClassName == "SDNode" ? "N" : "inN";
|
|
|
|
|
2005-09-13 22:03:37 +00:00
|
|
|
OS << "inline SDOperand Transform_" << XFormNode->getName()
|
2005-09-13 21:51:00 +00:00
|
|
|
<< "(SDNode *" << C2 << ") {\n";
|
|
|
|
if (ClassName != "SDNode")
|
|
|
|
OS << " " << ClassName << " *N = cast<" << ClassName << ">(inN);\n";
|
|
|
|
OS << Code << "\n}\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
Xforms.pop_back();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-08 02:00:36 +00:00
|
|
|
void DAGISelEmitter::ParseComplexPatterns() {
|
|
|
|
std::vector<Record*> AMs = Records.getAllDerivedDefinitions("ComplexPattern");
|
|
|
|
while (!AMs.empty()) {
|
|
|
|
ComplexPatterns.insert(std::make_pair(AMs.back(), AMs.back()));
|
|
|
|
AMs.pop_back();
|
|
|
|
}
|
|
|
|
}
|
2005-09-13 21:51:00 +00:00
|
|
|
|
|
|
|
|
2005-09-15 02:38:02 +00:00
|
|
|
/// ParsePatternFragments - Parse all of the PatFrag definitions in the .td
|
|
|
|
/// file, building up the PatternFragments map. After we've collected them all,
|
|
|
|
/// inline fragments together as necessary, so that there are no references left
|
|
|
|
/// inside a pattern fragment to a pattern fragment.
|
2005-09-07 23:44:43 +00:00
|
|
|
///
|
|
|
|
/// This also emits all of the predicate functions to the output file.
|
|
|
|
///
|
2005-09-15 02:38:02 +00:00
|
|
|
void DAGISelEmitter::ParsePatternFragments(std::ostream &OS) {
|
2005-09-07 23:44:43 +00:00
|
|
|
std::vector<Record*> Fragments = Records.getAllDerivedDefinitions("PatFrag");
|
|
|
|
|
|
|
|
// First step, parse all of the fragments and emit predicate functions.
|
|
|
|
OS << "\n// Predicate functions.\n";
|
|
|
|
for (unsigned i = 0, e = Fragments.size(); i != e; ++i) {
|
2005-09-15 22:23:50 +00:00
|
|
|
DagInit *Tree = Fragments[i]->getValueAsDag("Fragment");
|
2005-10-21 01:19:59 +00:00
|
|
|
TreePattern *P = new TreePattern(Fragments[i], Tree, true, *this);
|
2005-09-07 23:44:43 +00:00
|
|
|
PatternFragments[Fragments[i]] = P;
|
2005-09-13 21:20:49 +00:00
|
|
|
|
|
|
|
// Validate the argument list, converting it to map, to discard duplicates.
|
|
|
|
std::vector<std::string> &Args = P->getArgList();
|
|
|
|
std::set<std::string> OperandsMap(Args.begin(), Args.end());
|
|
|
|
|
|
|
|
if (OperandsMap.count(""))
|
|
|
|
P->error("Cannot have unnamed 'node' values in pattern fragment!");
|
|
|
|
|
|
|
|
// Parse the operands list.
|
|
|
|
DagInit *OpsList = Fragments[i]->getValueAsDag("Operands");
|
|
|
|
if (OpsList->getNodeType()->getName() != "ops")
|
|
|
|
P->error("Operands list should start with '(ops ... '!");
|
|
|
|
|
|
|
|
// Copy over the arguments.
|
|
|
|
Args.clear();
|
|
|
|
for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) {
|
|
|
|
if (!dynamic_cast<DefInit*>(OpsList->getArg(j)) ||
|
|
|
|
static_cast<DefInit*>(OpsList->getArg(j))->
|
|
|
|
getDef()->getName() != "node")
|
|
|
|
P->error("Operands list should all be 'node' values.");
|
|
|
|
if (OpsList->getArgName(j).empty())
|
|
|
|
P->error("Operands list should have names for each operand!");
|
|
|
|
if (!OperandsMap.count(OpsList->getArgName(j)))
|
|
|
|
P->error("'" + OpsList->getArgName(j) +
|
|
|
|
"' does not occur in pattern or was multiply specified!");
|
|
|
|
OperandsMap.erase(OpsList->getArgName(j));
|
|
|
|
Args.push_back(OpsList->getArgName(j));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!OperandsMap.empty())
|
|
|
|
P->error("Operands list does not contain an entry for operand '" +
|
|
|
|
*OperandsMap.begin() + "'!");
|
2005-09-07 23:44:43 +00:00
|
|
|
|
|
|
|
// If there is a code init for this fragment, emit the predicate code and
|
|
|
|
// keep track of the fact that this fragment uses it.
|
2005-09-13 21:51:00 +00:00
|
|
|
std::string Code = Fragments[i]->getValueAsCode("Predicate");
|
|
|
|
if (!Code.empty()) {
|
2005-09-09 01:15:01 +00:00
|
|
|
assert(!P->getOnlyTree()->isLeaf() && "Can't be a leaf!");
|
2005-09-07 23:44:43 +00:00
|
|
|
std::string ClassName =
|
2005-09-09 01:15:01 +00:00
|
|
|
getSDNodeInfo(P->getOnlyTree()->getOperator()).getSDClassName();
|
2005-09-07 23:44:43 +00:00
|
|
|
const char *C2 = ClassName == "SDNode" ? "N" : "inN";
|
|
|
|
|
2005-09-13 22:03:37 +00:00
|
|
|
OS << "inline bool Predicate_" << Fragments[i]->getName()
|
2005-09-07 23:44:43 +00:00
|
|
|
<< "(SDNode *" << C2 << ") {\n";
|
|
|
|
if (ClassName != "SDNode")
|
|
|
|
OS << " " << ClassName << " *N = cast<" << ClassName << ">(inN);\n";
|
2005-09-13 21:51:00 +00:00
|
|
|
OS << Code << "\n}\n";
|
2005-09-09 01:15:01 +00:00
|
|
|
P->getOnlyTree()->setPredicateFn("Predicate_"+Fragments[i]->getName());
|
2005-09-07 23:44:43 +00:00
|
|
|
}
|
2005-09-13 21:59:15 +00:00
|
|
|
|
|
|
|
// If there is a node transformation corresponding to this, keep track of
|
|
|
|
// it.
|
|
|
|
Record *Transform = Fragments[i]->getValueAsDef("OperandTransform");
|
|
|
|
if (!getSDNodeTransform(Transform).second.empty()) // not noop xform?
|
2005-09-14 22:55:26 +00:00
|
|
|
P->getOnlyTree()->setTransformFn(Transform);
|
2005-09-07 23:44:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
OS << "\n\n";
|
|
|
|
|
|
|
|
// Now that we've parsed all of the tree fragments, do a closure on them so
|
|
|
|
// that there are not references to PatFrags left inside of them.
|
|
|
|
for (std::map<Record*, TreePattern*>::iterator I = PatternFragments.begin(),
|
|
|
|
E = PatternFragments.end(); I != E; ++I) {
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
TreePattern *ThePat = I->second;
|
|
|
|
ThePat->InlinePatternFragments();
|
2005-09-13 21:20:49 +00:00
|
|
|
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
// Infer as many types as possible. Don't worry about it if we don't infer
|
|
|
|
// all of them, some may depend on the inputs of the pattern.
|
|
|
|
try {
|
|
|
|
ThePat->InferAllTypes();
|
|
|
|
} catch (...) {
|
|
|
|
// If this pattern fragment is not supported by this target (no types can
|
|
|
|
// satisfy its constraints), just ignore it. If the bogus pattern is
|
|
|
|
// actually used by instructions, the type consistency error will be
|
|
|
|
// reported there.
|
|
|
|
}
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
// If debugging, print out the pattern fragment result.
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
DEBUG(ThePat->dump());
|
2005-09-07 23:44:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-14 20:53:42 +00:00
|
|
|
/// HandleUse - Given "Pat" a leaf in the pattern, check to see if it is an
|
2005-09-14 23:05:13 +00:00
|
|
|
/// instruction input. Return true if this is a real use.
|
|
|
|
static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
|
2005-12-23 22:11:47 +00:00
|
|
|
std::map<std::string, TreePatternNode*> &InstInputs,
|
|
|
|
std::vector<Record*> &InstImpInputs) {
|
2005-09-14 20:53:42 +00:00
|
|
|
// No name -> not interesting.
|
2005-09-14 22:06:36 +00:00
|
|
|
if (Pat->getName().empty()) {
|
|
|
|
if (Pat->isLeaf()) {
|
|
|
|
DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue());
|
|
|
|
if (DI && DI->getDef()->isSubClassOf("RegisterClass"))
|
|
|
|
I->error("Input " + DI->getDef()->getName() + " must be named!");
|
2005-12-23 22:11:47 +00:00
|
|
|
else if (DI && DI->getDef()->isSubClassOf("Register"))
|
|
|
|
InstImpInputs.push_back(DI->getDef());
|
2005-09-14 22:06:36 +00:00
|
|
|
}
|
2005-09-14 23:05:13 +00:00
|
|
|
return false;
|
2005-09-14 22:06:36 +00:00
|
|
|
}
|
2005-09-14 20:53:42 +00:00
|
|
|
|
|
|
|
Record *Rec;
|
|
|
|
if (Pat->isLeaf()) {
|
|
|
|
DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue());
|
|
|
|
if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!");
|
|
|
|
Rec = DI->getDef();
|
|
|
|
} else {
|
|
|
|
assert(Pat->getNumChildren() == 0 && "can't be a use with children!");
|
|
|
|
Rec = Pat->getOperator();
|
|
|
|
}
|
|
|
|
|
2005-12-14 02:21:57 +00:00
|
|
|
// SRCVALUE nodes are ignored.
|
|
|
|
if (Rec->getName() == "srcvalue")
|
|
|
|
return false;
|
|
|
|
|
2005-09-14 20:53:42 +00:00
|
|
|
TreePatternNode *&Slot = InstInputs[Pat->getName()];
|
|
|
|
if (!Slot) {
|
|
|
|
Slot = Pat;
|
|
|
|
} else {
|
|
|
|
Record *SlotRec;
|
|
|
|
if (Slot->isLeaf()) {
|
2005-09-16 00:29:46 +00:00
|
|
|
SlotRec = dynamic_cast<DefInit*>(Slot->getLeafValue())->getDef();
|
2005-09-14 20:53:42 +00:00
|
|
|
} else {
|
|
|
|
assert(Slot->getNumChildren() == 0 && "can't be a use with children!");
|
|
|
|
SlotRec = Slot->getOperator();
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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");
|
2005-12-30 00:12:56 +00:00
|
|
|
if (Slot->getExtTypes() != Pat->getExtTypes())
|
2005-09-14 20:53:42 +00:00
|
|
|
I->error("All $" + Pat->getName() + " inputs must agree with each other");
|
|
|
|
}
|
2005-09-14 23:05:13 +00:00
|
|
|
return true;
|
2005-09-14 20:53:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// FindPatternInputsAndOutputs - Scan the specified TreePatternNode (which is
|
|
|
|
/// part of "I", the instruction), computing the set of inputs and outputs of
|
|
|
|
/// the pattern. Report errors if we see anything naughty.
|
|
|
|
void DAGISelEmitter::
|
|
|
|
FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
|
|
|
|
std::map<std::string, TreePatternNode*> &InstInputs,
|
2005-12-17 01:19:28 +00:00
|
|
|
std::map<std::string, Record*> &InstResults,
|
2005-12-23 22:11:47 +00:00
|
|
|
std::vector<Record*> &InstImpInputs,
|
2005-12-17 01:19:28 +00:00
|
|
|
std::vector<Record*> &InstImpResults) {
|
2005-09-14 20:53:42 +00:00
|
|
|
if (Pat->isLeaf()) {
|
2005-12-23 22:11:47 +00:00
|
|
|
bool isUse = HandleUse(I, Pat, InstInputs, InstImpInputs);
|
2005-09-14 23:05:13 +00:00
|
|
|
if (!isUse && Pat->getTransformFn())
|
|
|
|
I->error("Cannot specify a transform function for a non-input value!");
|
2005-09-14 20:53:42 +00:00
|
|
|
return;
|
|
|
|
} else if (Pat->getOperator()->getName() != "set") {
|
|
|
|
// 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) {
|
2005-12-30 00:12:56 +00:00
|
|
|
if (Pat->getChild(i)->getExtTypeNum(0) == MVT::isVoid)
|
2005-09-14 20:53:42 +00:00
|
|
|
I->error("Cannot have void nodes inside of patterns!");
|
2005-12-17 01:19:28 +00:00
|
|
|
FindPatternInputsAndOutputs(I, Pat->getChild(i), InstInputs, InstResults,
|
2005-12-23 22:11:47 +00:00
|
|
|
InstImpInputs, InstImpResults);
|
2005-09-14 20:53:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// If this is a non-leaf node with no children, treat it basically as if
|
|
|
|
// it were a leaf. This handles nodes like (imm).
|
2005-09-14 23:05:13 +00:00
|
|
|
bool isUse = false;
|
2005-09-14 20:53:42 +00:00
|
|
|
if (Pat->getNumChildren() == 0)
|
2005-12-23 22:11:47 +00:00
|
|
|
isUse = HandleUse(I, Pat, InstInputs, InstImpInputs);
|
2005-09-14 20:53:42 +00:00
|
|
|
|
2005-09-14 23:05:13 +00:00
|
|
|
if (!isUse && Pat->getTransformFn())
|
|
|
|
I->error("Cannot specify a transform function for a non-input value!");
|
2005-09-14 20:53:42 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, this is a set, validate and collect instruction results.
|
|
|
|
if (Pat->getNumChildren() == 0)
|
|
|
|
I->error("set requires operands!");
|
|
|
|
else if (Pat->getNumChildren() & 1)
|
|
|
|
I->error("set requires an even number of operands");
|
|
|
|
|
2005-09-14 23:05:13 +00:00
|
|
|
if (Pat->getTransformFn())
|
|
|
|
I->error("Cannot specify a transform function on a set node!");
|
|
|
|
|
2005-09-14 20:53:42 +00:00
|
|
|
// Check the set destinations.
|
|
|
|
unsigned NumValues = Pat->getNumChildren()/2;
|
|
|
|
for (unsigned i = 0; i != NumValues; ++i) {
|
|
|
|
TreePatternNode *Dest = Pat->getChild(i);
|
|
|
|
if (!Dest->isLeaf())
|
2005-12-12 19:37:43 +00:00
|
|
|
I->error("set destination should be a register!");
|
2005-09-14 20:53:42 +00:00
|
|
|
|
|
|
|
DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue());
|
|
|
|
if (!Val)
|
2005-12-12 19:37:43 +00:00
|
|
|
I->error("set destination should be a register!");
|
2005-09-14 20:53:42 +00:00
|
|
|
|
2005-12-17 01:19:28 +00:00
|
|
|
if (Val->getDef()->isSubClassOf("RegisterClass")) {
|
|
|
|
if (Dest->getName().empty())
|
|
|
|
I->error("set destination must have a name!");
|
|
|
|
if (InstResults.count(Dest->getName()))
|
|
|
|
I->error("cannot set '" + Dest->getName() +"' multiple times");
|
|
|
|
InstResults[Dest->getName()] = Val->getDef();
|
2005-12-23 22:11:47 +00:00
|
|
|
} else if (Val->getDef()->isSubClassOf("Register")) {
|
2005-12-17 01:19:28 +00:00
|
|
|
InstImpResults.push_back(Val->getDef());
|
|
|
|
} else {
|
|
|
|
I->error("set destination should be a register!");
|
|
|
|
}
|
|
|
|
|
2005-09-14 20:53:42 +00:00
|
|
|
// Verify and collect info from the computation.
|
|
|
|
FindPatternInputsAndOutputs(I, Pat->getChild(i+NumValues),
|
2005-12-23 22:11:47 +00:00
|
|
|
InstInputs, InstResults,
|
|
|
|
InstImpInputs, InstImpResults);
|
2005-09-14 20:53:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-15 02:38:02 +00:00
|
|
|
/// ParseInstructions - Parse all of the instructions, inlining and resolving
|
|
|
|
/// any fragments involved. This populates the Instructions list with fully
|
|
|
|
/// resolved instructions.
|
|
|
|
void DAGISelEmitter::ParseInstructions() {
|
2005-09-07 23:44:43 +00:00
|
|
|
std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction");
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = Instrs.size(); i != e; ++i) {
|
2005-10-19 01:27:22 +00:00
|
|
|
ListInit *LI = 0;
|
2005-09-07 23:44:43 +00:00
|
|
|
|
2005-10-19 01:27:22 +00:00
|
|
|
if (dynamic_cast<ListInit*>(Instrs[i]->getValueInit("Pattern")))
|
|
|
|
LI = Instrs[i]->getValueAsListInit("Pattern");
|
|
|
|
|
|
|
|
// If there is no pattern, only collect minimal information about the
|
|
|
|
// instruction for its operand list. We have to assume that there is one
|
|
|
|
// result, as we have no detailed info.
|
|
|
|
if (!LI || LI->getSize() == 0) {
|
2005-12-01 00:06:14 +00:00
|
|
|
std::vector<Record*> Results;
|
|
|
|
std::vector<Record*> Operands;
|
2005-10-19 01:27:22 +00:00
|
|
|
|
|
|
|
CodeGenInstruction &InstInfo =Target.getInstruction(Instrs[i]->getName());
|
2005-12-04 08:18:16 +00:00
|
|
|
|
2005-12-22 02:35:21 +00:00
|
|
|
if (InstInfo.OperandList.size() != 0) {
|
|
|
|
// FIXME: temporary hack...
|
2005-12-26 09:11:45 +00:00
|
|
|
if (InstInfo.noResults) {
|
2005-12-22 02:35:21 +00:00
|
|
|
// These produce no results
|
|
|
|
for (unsigned j = 0, e = InstInfo.OperandList.size(); j < e; ++j)
|
|
|
|
Operands.push_back(InstInfo.OperandList[j].Rec);
|
|
|
|
} else {
|
|
|
|
// Assume the first operand is the result.
|
|
|
|
Results.push_back(InstInfo.OperandList[0].Rec);
|
2005-10-19 01:27:22 +00:00
|
|
|
|
2005-12-22 02:35:21 +00:00
|
|
|
// The rest are inputs.
|
|
|
|
for (unsigned j = 1, e = InstInfo.OperandList.size(); j < e; ++j)
|
|
|
|
Operands.push_back(InstInfo.OperandList[j].Rec);
|
|
|
|
}
|
2005-12-04 08:18:16 +00:00
|
|
|
}
|
2005-10-19 01:27:22 +00:00
|
|
|
|
|
|
|
// Create and insert the instruction.
|
2005-12-17 01:19:28 +00:00
|
|
|
std::vector<Record*> ImpResults;
|
|
|
|
std::vector<Record*> ImpOperands;
|
2005-10-19 01:27:22 +00:00
|
|
|
Instructions.insert(std::make_pair(Instrs[i],
|
2005-12-23 22:11:47 +00:00
|
|
|
DAGInstruction(0, Results, Operands, ImpResults,
|
|
|
|
ImpOperands)));
|
2005-10-19 01:27:22 +00:00
|
|
|
continue; // no pattern.
|
|
|
|
}
|
2005-09-07 23:44:43 +00:00
|
|
|
|
|
|
|
// Parse the instruction.
|
2005-10-21 01:19:59 +00:00
|
|
|
TreePattern *I = new TreePattern(Instrs[i], LI, true, *this);
|
2005-09-07 23:44:43 +00:00
|
|
|
// Inline pattern fragments into it.
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
I->InlinePatternFragments();
|
|
|
|
|
2005-09-08 23:26:30 +00:00
|
|
|
// Infer as many types as possible. If we cannot infer all of them, we can
|
|
|
|
// never do anything with this instruction pattern: report it to the user.
|
2005-09-15 21:42:00 +00:00
|
|
|
if (!I->InferAllTypes())
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
I->error("Could not infer all types in pattern!");
|
2005-09-09 01:11:44 +00:00
|
|
|
|
2005-09-14 20:53:42 +00:00
|
|
|
// InstInputs - Keep track of all of the inputs of the instruction, along
|
|
|
|
// with the record they are declared as.
|
|
|
|
std::map<std::string, TreePatternNode*> InstInputs;
|
|
|
|
|
|
|
|
// InstResults - Keep track of all the virtual registers that are 'set'
|
2005-09-14 02:11:12 +00:00
|
|
|
// in the instruction, including what reg class they are.
|
2005-09-14 20:53:42 +00:00
|
|
|
std::map<std::string, Record*> InstResults;
|
2005-12-23 22:11:47 +00:00
|
|
|
|
|
|
|
std::vector<Record*> InstImpInputs;
|
2005-12-17 01:19:28 +00:00
|
|
|
std::vector<Record*> InstImpResults;
|
2005-09-14 20:53:42 +00:00
|
|
|
|
2005-09-14 00:09:24 +00:00
|
|
|
// Verify that the top-level forms in the instruction are of void type, and
|
2005-09-14 20:53:42 +00:00
|
|
|
// fill in the InstResults map.
|
2005-09-14 00:09:24 +00:00
|
|
|
for (unsigned j = 0, e = I->getNumTrees(); j != e; ++j) {
|
|
|
|
TreePatternNode *Pat = I->getTree(j);
|
2005-12-30 00:12:56 +00:00
|
|
|
if (Pat->getExtTypeNum(0) != MVT::isVoid)
|
2005-09-09 01:11:44 +00:00
|
|
|
I->error("Top-level forms in instruction pattern should have"
|
|
|
|
" void types");
|
2005-09-14 20:53:42 +00:00
|
|
|
|
|
|
|
// Find inputs and outputs, and verify the structure of the uses/defs.
|
2005-12-17 01:19:28 +00:00
|
|
|
FindPatternInputsAndOutputs(I, Pat, InstInputs, InstResults,
|
2005-12-23 22:11:47 +00:00
|
|
|
InstImpInputs, InstImpResults);
|
2005-09-14 00:09:24 +00:00
|
|
|
}
|
2005-09-14 02:11:12 +00:00
|
|
|
|
2005-09-14 20:53:42 +00:00
|
|
|
// Now that we have inputs and outputs of the pattern, inspect the operands
|
|
|
|
// list for the instruction. This determines the order that operands are
|
|
|
|
// added to the machine instruction the node corresponds to.
|
|
|
|
unsigned NumResults = InstResults.size();
|
2005-09-14 18:19:25 +00:00
|
|
|
|
|
|
|
// Parse the operands list from the (ops) list, validating it.
|
|
|
|
std::vector<std::string> &Args = I->getArgList();
|
|
|
|
assert(Args.empty() && "Args list should still be empty here!");
|
|
|
|
CodeGenInstruction &CGI = Target.getInstruction(Instrs[i]->getName());
|
|
|
|
|
|
|
|
// Check that all of the results occur first in the list.
|
2005-12-01 00:06:14 +00:00
|
|
|
std::vector<Record*> Results;
|
2005-09-14 18:19:25 +00:00
|
|
|
for (unsigned i = 0; i != NumResults; ++i) {
|
2005-09-14 21:04:12 +00:00
|
|
|
if (i == CGI.OperandList.size())
|
2005-09-14 20:53:42 +00:00
|
|
|
I->error("'" + InstResults.begin()->first +
|
|
|
|
"' set but does not appear in operand list!");
|
2005-09-14 18:19:25 +00:00
|
|
|
const std::string &OpName = CGI.OperandList[i].Name;
|
|
|
|
|
2005-09-14 20:53:42 +00:00
|
|
|
// Check that it exists in InstResults.
|
|
|
|
Record *R = InstResults[OpName];
|
2005-09-14 18:19:25 +00:00
|
|
|
if (R == 0)
|
|
|
|
I->error("Operand $" + OpName + " should be a set destination: all "
|
|
|
|
"outputs must occur before inputs in operand list!");
|
|
|
|
|
|
|
|
if (CGI.OperandList[i].Rec != R)
|
|
|
|
I->error("Operand $" + OpName + " class mismatch!");
|
|
|
|
|
2005-09-15 21:51:12 +00:00
|
|
|
// Remember the return type.
|
2005-12-01 00:06:14 +00:00
|
|
|
Results.push_back(CGI.OperandList[i].Rec);
|
2005-09-15 21:51:12 +00:00
|
|
|
|
2005-09-14 18:19:25 +00:00
|
|
|
// Okay, this one checks out.
|
2005-09-14 20:53:42 +00:00
|
|
|
InstResults.erase(OpName);
|
2005-09-14 18:19:25 +00:00
|
|
|
}
|
2005-09-14 02:11:12 +00:00
|
|
|
|
2005-09-14 21:59:34 +00:00
|
|
|
// Loop over the inputs next. Make a copy of InstInputs so we can destroy
|
|
|
|
// the copy while we're checking the inputs.
|
|
|
|
std::map<std::string, TreePatternNode*> InstInputsCheck(InstInputs);
|
2005-09-14 22:55:26 +00:00
|
|
|
|
|
|
|
std::vector<TreePatternNode*> ResultNodeOperands;
|
2005-12-01 00:06:14 +00:00
|
|
|
std::vector<Record*> Operands;
|
2005-09-14 20:53:42 +00:00
|
|
|
for (unsigned i = NumResults, e = CGI.OperandList.size(); i != e; ++i) {
|
|
|
|
const std::string &OpName = CGI.OperandList[i].Name;
|
|
|
|
if (OpName.empty())
|
|
|
|
I->error("Operand #" + utostr(i) + " in operands list has no name!");
|
|
|
|
|
2005-09-14 21:59:34 +00:00
|
|
|
if (!InstInputsCheck.count(OpName))
|
2005-09-14 20:53:42 +00:00
|
|
|
I->error("Operand $" + OpName +
|
|
|
|
" does not appear in the instruction pattern");
|
2005-09-14 21:59:34 +00:00
|
|
|
TreePatternNode *InVal = InstInputsCheck[OpName];
|
2005-09-14 22:55:26 +00:00
|
|
|
InstInputsCheck.erase(OpName); // It occurred, remove from map.
|
2005-12-01 00:06:14 +00:00
|
|
|
|
|
|
|
if (InVal->isLeaf() &&
|
|
|
|
dynamic_cast<DefInit*>(InVal->getLeafValue())) {
|
|
|
|
Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef();
|
2005-12-08 02:00:36 +00:00
|
|
|
if (CGI.OperandList[i].Rec != InRec &&
|
|
|
|
!InRec->isSubClassOf("ComplexPattern"))
|
2006-01-28 19:06:51 +00:00
|
|
|
I->error("Operand $" + OpName + "'s register class disagrees"
|
|
|
|
" between the operand and pattern");
|
2005-12-01 00:06:14 +00:00
|
|
|
}
|
|
|
|
Operands.push_back(CGI.OperandList[i].Rec);
|
2005-09-14 22:55:26 +00:00
|
|
|
|
2005-09-14 23:01:59 +00:00
|
|
|
// Construct the result for the dest-pattern operand list.
|
|
|
|
TreePatternNode *OpNode = InVal->clone();
|
|
|
|
|
|
|
|
// No predicate is useful on the result.
|
|
|
|
OpNode->setPredicateFn("");
|
|
|
|
|
|
|
|
// Promote the xform function to be an explicit node if set.
|
|
|
|
if (Record *Xform = OpNode->getTransformFn()) {
|
|
|
|
OpNode->setTransformFn(0);
|
|
|
|
std::vector<TreePatternNode*> Children;
|
|
|
|
Children.push_back(OpNode);
|
|
|
|
OpNode = new TreePatternNode(Xform, Children);
|
|
|
|
}
|
|
|
|
|
|
|
|
ResultNodeOperands.push_back(OpNode);
|
2005-09-14 20:53:42 +00:00
|
|
|
}
|
|
|
|
|
2005-09-14 21:59:34 +00:00
|
|
|
if (!InstInputsCheck.empty())
|
|
|
|
I->error("Input operand $" + InstInputsCheck.begin()->first +
|
|
|
|
" occurs in pattern but not in operands list!");
|
2005-09-14 22:55:26 +00:00
|
|
|
|
|
|
|
TreePatternNode *ResultPattern =
|
|
|
|
new TreePatternNode(I->getRecord(), ResultNodeOperands);
|
2005-09-15 22:23:50 +00:00
|
|
|
|
|
|
|
// Create and insert the instruction.
|
2005-12-23 22:11:47 +00:00
|
|
|
DAGInstruction TheInst(I, Results, Operands, InstImpResults, InstImpInputs);
|
2005-09-15 22:23:50 +00:00
|
|
|
Instructions.insert(std::make_pair(I->getRecord(), TheInst));
|
|
|
|
|
|
|
|
// Use a temporary tree pattern to infer all types and make sure that the
|
|
|
|
// constructed result is correct. This depends on the instruction already
|
|
|
|
// being inserted into the Instructions map.
|
2005-10-21 01:19:59 +00:00
|
|
|
TreePattern Temp(I->getRecord(), ResultPattern, false, *this);
|
2005-09-15 22:23:50 +00:00
|
|
|
Temp.InferAllTypes();
|
|
|
|
|
|
|
|
DAGInstruction &TheInsertedInst = Instructions.find(I->getRecord())->second;
|
|
|
|
TheInsertedInst.setResultPattern(Temp.getOnlyTree());
|
2005-09-14 22:55:26 +00:00
|
|
|
|
Implement a complete type inference system for dag patterns, based on the
constraints defined in the DAG node definitions in the .td files. This
allows us to infer (and check!) the types for all nodes in the current
ppc .td file. For example, instead of:
Inst pattern EQV: (set GPRC:i32:$rT, (xor (xor GPRC:i32:$rA, GPRC:i32:$rB), (imm)<<Predicate_immAllOnes>>))
we now fully infer:
Inst pattern EQV: (set:void GPRC:i32:$rT, (xor:i32 (xor:i32 GPRC:i32:$rA, GPRC:i32:$rB), (imm:i32)<<Predicate_immAllOnes>>))
from: (set GPRC:$rT, (not (xor GPRC:$rA, GPRC:$rB)))
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23284 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-08 23:22:48 +00:00
|
|
|
DEBUG(I->dump());
|
2005-09-07 23:44:43 +00:00
|
|
|
}
|
2005-09-14 00:09:24 +00:00
|
|
|
|
2005-09-14 20:53:42 +00:00
|
|
|
// If we can, convert the instructions to be patterns that are matched!
|
2005-09-15 21:57:35 +00:00
|
|
|
for (std::map<Record*, DAGInstruction>::iterator II = Instructions.begin(),
|
|
|
|
E = Instructions.end(); II != E; ++II) {
|
2005-12-04 08:18:16 +00:00
|
|
|
DAGInstruction &TheInst = II->second;
|
|
|
|
TreePattern *I = TheInst.getPattern();
|
2005-10-19 01:27:22 +00:00
|
|
|
if (I == 0) continue; // No pattern.
|
2005-12-05 23:08:55 +00:00
|
|
|
|
2005-09-14 00:09:24 +00:00
|
|
|
if (I->getNumTrees() != 1) {
|
|
|
|
std::cerr << "CANNOT HANDLE: " << I->getRecord()->getName() << " yet!";
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
TreePatternNode *Pattern = I->getTree(0);
|
2005-12-04 08:18:16 +00:00
|
|
|
TreePatternNode *SrcPattern;
|
2005-12-17 01:19:28 +00:00
|
|
|
if (Pattern->getOperator()->getName() == "set") {
|
2005-12-04 08:18:16 +00:00
|
|
|
if (Pattern->getNumChildren() != 2)
|
|
|
|
continue; // Not a set of a single value (not handled so far)
|
|
|
|
|
|
|
|
SrcPattern = Pattern->getChild(1)->clone();
|
2005-12-17 01:19:28 +00:00
|
|
|
} else{
|
|
|
|
// Not a set (store or something?)
|
|
|
|
SrcPattern = Pattern;
|
2005-12-04 08:18:16 +00:00
|
|
|
}
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
|
|
|
|
std::string Reason;
|
|
|
|
if (!SrcPattern->canPatternMatch(Reason, *this))
|
|
|
|
I->error("Instruction can never match: " + Reason);
|
|
|
|
|
2005-12-14 22:02:59 +00:00
|
|
|
Record *Instr = II->first;
|
2005-12-04 08:18:16 +00:00
|
|
|
TreePatternNode *DstPattern = TheInst.getResultPattern();
|
2005-12-14 22:02:59 +00:00
|
|
|
PatternsToMatch.
|
|
|
|
push_back(PatternToMatch(Instr->getValueAsListInit("Predicates"),
|
|
|
|
SrcPattern, DstPattern));
|
2005-09-14 00:09:24 +00:00
|
|
|
}
|
2005-09-07 23:44:43 +00:00
|
|
|
}
|
|
|
|
|
2005-09-15 02:38:02 +00:00
|
|
|
void DAGISelEmitter::ParsePatterns() {
|
2005-09-15 21:42:00 +00:00
|
|
|
std::vector<Record*> Patterns = Records.getAllDerivedDefinitions("Pattern");
|
2005-09-15 02:38:02 +00:00
|
|
|
|
2005-09-15 21:42:00 +00:00
|
|
|
for (unsigned i = 0, e = Patterns.size(); i != e; ++i) {
|
2005-09-15 22:23:50 +00:00
|
|
|
DagInit *Tree = Patterns[i]->getValueAsDag("PatternToMatch");
|
2005-10-21 01:19:59 +00:00
|
|
|
TreePattern *Pattern = new TreePattern(Patterns[i], Tree, true, *this);
|
2005-09-15 02:38:02 +00:00
|
|
|
|
2005-09-15 21:42:00 +00:00
|
|
|
// Inline pattern fragments into it.
|
|
|
|
Pattern->InlinePatternFragments();
|
|
|
|
|
|
|
|
// Infer as many types as possible. If we cannot infer all of them, we can
|
|
|
|
// never do anything with this pattern: report it to the user.
|
|
|
|
if (!Pattern->InferAllTypes())
|
|
|
|
Pattern->error("Could not infer all types in pattern!");
|
2005-11-17 17:43:52 +00:00
|
|
|
|
|
|
|
// Validate that the input pattern is correct.
|
|
|
|
{
|
|
|
|
std::map<std::string, TreePatternNode*> InstInputs;
|
|
|
|
std::map<std::string, Record*> InstResults;
|
2005-12-23 22:11:47 +00:00
|
|
|
std::vector<Record*> InstImpInputs;
|
2005-12-17 01:19:28 +00:00
|
|
|
std::vector<Record*> InstImpResults;
|
2005-11-17 17:43:52 +00:00
|
|
|
FindPatternInputsAndOutputs(Pattern, Pattern->getOnlyTree(),
|
2005-12-17 01:19:28 +00:00
|
|
|
InstInputs, InstResults,
|
2005-12-23 22:11:47 +00:00
|
|
|
InstImpInputs, InstImpResults);
|
2005-11-17 17:43:52 +00:00
|
|
|
}
|
2005-09-15 21:42:00 +00:00
|
|
|
|
|
|
|
ListInit *LI = Patterns[i]->getValueAsListInit("ResultInstrs");
|
|
|
|
if (LI->getSize() == 0) continue; // no pattern.
|
|
|
|
|
|
|
|
// Parse the instruction.
|
2005-10-21 01:19:59 +00:00
|
|
|
TreePattern *Result = new TreePattern(Patterns[i], LI, false, *this);
|
2005-09-15 21:42:00 +00:00
|
|
|
|
|
|
|
// Inline pattern fragments into it.
|
|
|
|
Result->InlinePatternFragments();
|
|
|
|
|
|
|
|
// Infer as many types as possible. If we cannot infer all of them, we can
|
|
|
|
// never do anything with this pattern: report it to the user.
|
|
|
|
if (!Result->InferAllTypes())
|
2005-09-15 21:57:35 +00:00
|
|
|
Result->error("Could not infer all types in pattern result!");
|
2005-09-15 21:42:00 +00:00
|
|
|
|
|
|
|
if (Result->getNumTrees() != 1)
|
|
|
|
Result->error("Cannot handle instructions producing instructions "
|
|
|
|
"with temporaries yet!");
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
|
|
|
|
std::string Reason;
|
|
|
|
if (!Pattern->getOnlyTree()->canPatternMatch(Reason, *this))
|
|
|
|
Pattern->error("Pattern can never match: " + Reason);
|
|
|
|
|
2005-12-14 22:02:59 +00:00
|
|
|
PatternsToMatch.
|
|
|
|
push_back(PatternToMatch(Patterns[i]->getValueAsListInit("Predicates"),
|
|
|
|
Pattern->getOnlyTree(),
|
|
|
|
Result->getOnlyTree()));
|
2005-09-15 21:42:00 +00:00
|
|
|
}
|
2005-09-29 19:28:10 +00:00
|
|
|
}
|
2005-09-15 02:38:02 +00:00
|
|
|
|
2005-09-29 19:28:10 +00:00
|
|
|
/// CombineChildVariants - Given a bunch of permutations of each child of the
|
|
|
|
/// 'operator' node, put them together in all possible ways.
|
|
|
|
static void CombineChildVariants(TreePatternNode *Orig,
|
2005-09-29 22:36:54 +00:00
|
|
|
const std::vector<std::vector<TreePatternNode*> > &ChildVariants,
|
2005-09-29 19:28:10 +00:00
|
|
|
std::vector<TreePatternNode*> &OutVariants,
|
|
|
|
DAGISelEmitter &ISE) {
|
2005-09-29 22:36:54 +00:00
|
|
|
// Make sure that each operand has at least one variant to choose from.
|
|
|
|
for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i)
|
|
|
|
if (ChildVariants[i].empty())
|
|
|
|
return;
|
|
|
|
|
2005-09-29 19:28:10 +00:00
|
|
|
// The end result is an all-pairs construction of the resultant pattern.
|
|
|
|
std::vector<unsigned> Idxs;
|
|
|
|
Idxs.resize(ChildVariants.size());
|
|
|
|
bool NotDone = true;
|
|
|
|
while (NotDone) {
|
|
|
|
// Create the variant and add it to the output list.
|
|
|
|
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);
|
|
|
|
|
|
|
|
// Copy over properties.
|
|
|
|
R->setName(Orig->getName());
|
|
|
|
R->setPredicateFn(Orig->getPredicateFn());
|
|
|
|
R->setTransformFn(Orig->getTransformFn());
|
2005-12-30 00:12:56 +00:00
|
|
|
R->setTypes(Orig->getExtTypes());
|
2005-09-29 19:28:10 +00:00
|
|
|
|
|
|
|
// If this pattern cannot every match, do not include it as a variant.
|
|
|
|
std::string ErrString;
|
|
|
|
if (!R->canPatternMatch(ErrString, ISE)) {
|
|
|
|
delete R;
|
|
|
|
} else {
|
|
|
|
bool AlreadyExists = false;
|
|
|
|
|
|
|
|
// Scan to see if this pattern has already been emitted. We can get
|
|
|
|
// duplication due to things like commuting:
|
|
|
|
// (and GPRC:$a, GPRC:$b) -> (and GPRC:$b, GPRC:$a)
|
|
|
|
// which are the same pattern. Ignore the dups.
|
|
|
|
for (unsigned i = 0, e = OutVariants.size(); i != e; ++i)
|
|
|
|
if (R->isIsomorphicTo(OutVariants[i])) {
|
|
|
|
AlreadyExists = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (AlreadyExists)
|
|
|
|
delete R;
|
|
|
|
else
|
|
|
|
OutVariants.push_back(R);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Increment indices to the next permutation.
|
|
|
|
NotDone = false;
|
|
|
|
// Look for something we can increment without causing a wrap-around.
|
|
|
|
for (unsigned IdxsIdx = 0; IdxsIdx != Idxs.size(); ++IdxsIdx) {
|
|
|
|
if (++Idxs[IdxsIdx] < ChildVariants[IdxsIdx].size()) {
|
|
|
|
NotDone = true; // Found something to increment.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
Idxs[IdxsIdx] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-29 22:36:54 +00:00
|
|
|
/// CombineChildVariants - A helper function for binary operators.
|
|
|
|
///
|
|
|
|
static void CombineChildVariants(TreePatternNode *Orig,
|
|
|
|
const std::vector<TreePatternNode*> &LHS,
|
|
|
|
const std::vector<TreePatternNode*> &RHS,
|
|
|
|
std::vector<TreePatternNode*> &OutVariants,
|
|
|
|
DAGISelEmitter &ISE) {
|
|
|
|
std::vector<std::vector<TreePatternNode*> > ChildVariants;
|
|
|
|
ChildVariants.push_back(LHS);
|
|
|
|
ChildVariants.push_back(RHS);
|
|
|
|
CombineChildVariants(Orig, ChildVariants, OutVariants, ISE);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void GatherChildrenOfAssociativeOpcode(TreePatternNode *N,
|
|
|
|
std::vector<TreePatternNode *> &Children) {
|
|
|
|
assert(N->getNumChildren()==2 &&"Associative but doesn't have 2 children!");
|
|
|
|
Record *Operator = N->getOperator();
|
|
|
|
|
|
|
|
// Only permit raw nodes.
|
|
|
|
if (!N->getName().empty() || !N->getPredicateFn().empty() ||
|
|
|
|
N->getTransformFn()) {
|
|
|
|
Children.push_back(N);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (N->getChild(0)->isLeaf() || N->getChild(0)->getOperator() != Operator)
|
|
|
|
Children.push_back(N->getChild(0));
|
|
|
|
else
|
|
|
|
GatherChildrenOfAssociativeOpcode(N->getChild(0), Children);
|
|
|
|
|
|
|
|
if (N->getChild(1)->isLeaf() || N->getChild(1)->getOperator() != Operator)
|
|
|
|
Children.push_back(N->getChild(1));
|
|
|
|
else
|
|
|
|
GatherChildrenOfAssociativeOpcode(N->getChild(1), Children);
|
|
|
|
}
|
|
|
|
|
2005-09-29 19:28:10 +00:00
|
|
|
/// GenerateVariantsOf - Given a pattern N, generate all permutations we can of
|
|
|
|
/// the (potentially recursive) pattern by using algebraic laws.
|
|
|
|
///
|
|
|
|
static void GenerateVariantsOf(TreePatternNode *N,
|
|
|
|
std::vector<TreePatternNode*> &OutVariants,
|
|
|
|
DAGISelEmitter &ISE) {
|
|
|
|
// We cannot permute leaves.
|
|
|
|
if (N->isLeaf()) {
|
|
|
|
OutVariants.push_back(N);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Look up interesting info about the node.
|
|
|
|
const SDNodeInfo &NodeInfo = ISE.getSDNodeInfo(N->getOperator());
|
|
|
|
|
|
|
|
// If this node is associative, reassociate.
|
2005-09-29 22:36:54 +00:00
|
|
|
if (NodeInfo.hasProperty(SDNodeInfo::SDNPAssociative)) {
|
|
|
|
// Reassociate by pulling together all of the linked operators
|
|
|
|
std::vector<TreePatternNode*> MaximalChildren;
|
|
|
|
GatherChildrenOfAssociativeOpcode(N, MaximalChildren);
|
|
|
|
|
|
|
|
// Only handle child sizes of 3. Otherwise we'll end up trying too many
|
|
|
|
// permutations.
|
|
|
|
if (MaximalChildren.size() == 3) {
|
|
|
|
// Find the variants of all of our maximal children.
|
|
|
|
std::vector<TreePatternNode*> AVariants, BVariants, CVariants;
|
|
|
|
GenerateVariantsOf(MaximalChildren[0], AVariants, ISE);
|
|
|
|
GenerateVariantsOf(MaximalChildren[1], BVariants, ISE);
|
|
|
|
GenerateVariantsOf(MaximalChildren[2], CVariants, ISE);
|
|
|
|
|
|
|
|
// There are only two ways we can permute the tree:
|
|
|
|
// (A op B) op C and A op (B op C)
|
|
|
|
// Within these forms, we can also permute A/B/C.
|
|
|
|
|
|
|
|
// Generate legal pair permutations of A/B/C.
|
|
|
|
std::vector<TreePatternNode*> ABVariants;
|
|
|
|
std::vector<TreePatternNode*> BAVariants;
|
|
|
|
std::vector<TreePatternNode*> ACVariants;
|
|
|
|
std::vector<TreePatternNode*> CAVariants;
|
|
|
|
std::vector<TreePatternNode*> BCVariants;
|
|
|
|
std::vector<TreePatternNode*> CBVariants;
|
|
|
|
CombineChildVariants(N, AVariants, BVariants, ABVariants, ISE);
|
|
|
|
CombineChildVariants(N, BVariants, AVariants, BAVariants, ISE);
|
|
|
|
CombineChildVariants(N, AVariants, CVariants, ACVariants, ISE);
|
|
|
|
CombineChildVariants(N, CVariants, AVariants, CAVariants, ISE);
|
|
|
|
CombineChildVariants(N, BVariants, CVariants, BCVariants, ISE);
|
|
|
|
CombineChildVariants(N, CVariants, BVariants, CBVariants, ISE);
|
|
|
|
|
|
|
|
// Combine those into the result: (x op x) op x
|
|
|
|
CombineChildVariants(N, ABVariants, CVariants, OutVariants, ISE);
|
|
|
|
CombineChildVariants(N, BAVariants, CVariants, OutVariants, ISE);
|
|
|
|
CombineChildVariants(N, ACVariants, BVariants, OutVariants, ISE);
|
|
|
|
CombineChildVariants(N, CAVariants, BVariants, OutVariants, ISE);
|
|
|
|
CombineChildVariants(N, BCVariants, AVariants, OutVariants, ISE);
|
|
|
|
CombineChildVariants(N, CBVariants, AVariants, OutVariants, ISE);
|
|
|
|
|
|
|
|
// Combine those into the result: x op (x op x)
|
|
|
|
CombineChildVariants(N, CVariants, ABVariants, OutVariants, ISE);
|
|
|
|
CombineChildVariants(N, CVariants, BAVariants, OutVariants, ISE);
|
|
|
|
CombineChildVariants(N, BVariants, ACVariants, OutVariants, ISE);
|
|
|
|
CombineChildVariants(N, BVariants, CAVariants, OutVariants, ISE);
|
|
|
|
CombineChildVariants(N, AVariants, BCVariants, OutVariants, ISE);
|
|
|
|
CombineChildVariants(N, AVariants, CBVariants, OutVariants, ISE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2005-09-29 19:28:10 +00:00
|
|
|
|
|
|
|
// Compute permutations of all children.
|
|
|
|
std::vector<std::vector<TreePatternNode*> > ChildVariants;
|
|
|
|
ChildVariants.resize(N->getNumChildren());
|
|
|
|
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i)
|
|
|
|
GenerateVariantsOf(N->getChild(i), ChildVariants[i], ISE);
|
|
|
|
|
|
|
|
// Build all permutations based on how the children were formed.
|
|
|
|
CombineChildVariants(N, ChildVariants, OutVariants, ISE);
|
|
|
|
|
|
|
|
// If this node is commutative, consider the commuted order.
|
|
|
|
if (NodeInfo.hasProperty(SDNodeInfo::SDNPCommutative)) {
|
|
|
|
assert(N->getNumChildren()==2 &&"Commutative but doesn't have 2 children!");
|
2005-09-29 22:36:54 +00:00
|
|
|
// Consider the commuted order.
|
|
|
|
CombineChildVariants(N, ChildVariants[1], ChildVariants[0],
|
|
|
|
OutVariants, ISE);
|
2005-09-29 19:28:10 +00:00
|
|
|
}
|
2005-09-15 02:38:02 +00:00
|
|
|
}
|
|
|
|
|
2005-09-29 19:28:10 +00:00
|
|
|
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
// GenerateVariants - Generate variants. For example, commutative patterns can
|
|
|
|
// match multiple ways. Add them to PatternsToMatch as well.
|
|
|
|
void DAGISelEmitter::GenerateVariants() {
|
2005-09-29 19:28:10 +00:00
|
|
|
|
|
|
|
DEBUG(std::cerr << "Generating instruction variants.\n");
|
|
|
|
|
|
|
|
// Loop over all of the patterns we've collected, checking to see if we can
|
|
|
|
// generate variants of the instruction, through the exploitation of
|
|
|
|
// identities. This permits the target to provide agressive matching without
|
|
|
|
// the .td file having to contain tons of variants of instructions.
|
|
|
|
//
|
|
|
|
// Note that this loop adds new patterns to the PatternsToMatch list, but we
|
|
|
|
// intentionally do not reconsider these. Any variants of added patterns have
|
|
|
|
// already been added.
|
|
|
|
//
|
|
|
|
for (unsigned i = 0, e = PatternsToMatch.size(); i != e; ++i) {
|
|
|
|
std::vector<TreePatternNode*> Variants;
|
2005-12-14 22:02:59 +00:00
|
|
|
GenerateVariantsOf(PatternsToMatch[i].getSrcPattern(), Variants, *this);
|
2005-09-29 19:28:10 +00:00
|
|
|
|
|
|
|
assert(!Variants.empty() && "Must create at least original variant!");
|
|
|
|
Variants.erase(Variants.begin()); // Remove the original pattern.
|
|
|
|
|
|
|
|
if (Variants.empty()) // No variants for this pattern.
|
|
|
|
continue;
|
|
|
|
|
|
|
|
DEBUG(std::cerr << "FOUND VARIANTS OF: ";
|
2005-12-14 22:02:59 +00:00
|
|
|
PatternsToMatch[i].getSrcPattern()->dump();
|
2005-09-29 19:28:10 +00:00
|
|
|
std::cerr << "\n");
|
|
|
|
|
|
|
|
for (unsigned v = 0, e = Variants.size(); v != e; ++v) {
|
|
|
|
TreePatternNode *Variant = Variants[v];
|
|
|
|
|
|
|
|
DEBUG(std::cerr << " VAR#" << v << ": ";
|
|
|
|
Variant->dump();
|
|
|
|
std::cerr << "\n");
|
|
|
|
|
|
|
|
// Scan to see if an instruction or explicit pattern already matches this.
|
|
|
|
bool AlreadyExists = false;
|
|
|
|
for (unsigned p = 0, e = PatternsToMatch.size(); p != e; ++p) {
|
|
|
|
// Check to see if this variant already exists.
|
2005-12-14 22:02:59 +00:00
|
|
|
if (Variant->isIsomorphicTo(PatternsToMatch[p].getSrcPattern())) {
|
2005-09-29 19:28:10 +00:00
|
|
|
DEBUG(std::cerr << " *** ALREADY EXISTS, ignoring variant.\n");
|
|
|
|
AlreadyExists = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If we already have it, ignore the variant.
|
|
|
|
if (AlreadyExists) continue;
|
|
|
|
|
|
|
|
// Otherwise, add it to the list of patterns we have.
|
2005-12-14 22:02:59 +00:00
|
|
|
PatternsToMatch.
|
|
|
|
push_back(PatternToMatch(PatternsToMatch[i].getPredicates(),
|
|
|
|
Variant, PatternsToMatch[i].getDstPattern()));
|
2005-09-29 19:28:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG(std::cerr << "\n");
|
|
|
|
}
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
}
|
|
|
|
|
2005-09-28 20:58:06 +00:00
|
|
|
|
2005-12-08 02:00:36 +00:00
|
|
|
// NodeIsComplexPattern - return true if N is a leaf node and a subclass of
|
|
|
|
// ComplexPattern.
|
|
|
|
static bool NodeIsComplexPattern(TreePatternNode *N)
|
|
|
|
{
|
|
|
|
return (N->isLeaf() &&
|
|
|
|
dynamic_cast<DefInit*>(N->getLeafValue()) &&
|
|
|
|
static_cast<DefInit*>(N->getLeafValue())->getDef()->
|
|
|
|
isSubClassOf("ComplexPattern"));
|
|
|
|
}
|
|
|
|
|
|
|
|
// NodeGetComplexPattern - return the pointer to the ComplexPattern if N
|
|
|
|
// is a leaf node and a subclass of ComplexPattern, else it returns NULL.
|
|
|
|
static const ComplexPattern *NodeGetComplexPattern(TreePatternNode *N,
|
|
|
|
DAGISelEmitter &ISE)
|
|
|
|
{
|
|
|
|
if (N->isLeaf() &&
|
|
|
|
dynamic_cast<DefInit*>(N->getLeafValue()) &&
|
|
|
|
static_cast<DefInit*>(N->getLeafValue())->getDef()->
|
|
|
|
isSubClassOf("ComplexPattern")) {
|
|
|
|
return &ISE.getComplexPattern(static_cast<DefInit*>(N->getLeafValue())
|
|
|
|
->getDef());
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-09-28 17:57:56 +00:00
|
|
|
/// getPatternSize - Return the 'size' of this pattern. We want to match large
|
|
|
|
/// patterns before small ones. This is used to determine the size of a
|
|
|
|
/// pattern.
|
2005-12-08 02:00:36 +00:00
|
|
|
static unsigned getPatternSize(TreePatternNode *P, DAGISelEmitter &ISE) {
|
2006-01-06 22:19:44 +00:00
|
|
|
assert(isExtIntegerInVTs(P->getExtTypes()) ||
|
|
|
|
isExtFloatingPointInVTs(P->getExtTypes()) ||
|
|
|
|
P->getExtTypeNum(0) == MVT::isVoid ||
|
|
|
|
P->getExtTypeNum(0) == MVT::Flag &&
|
|
|
|
"Not a valid pattern node to size!");
|
2006-01-06 02:30:23 +00:00
|
|
|
unsigned Size = 2; // The node itself.
|
2006-02-01 06:06:31 +00:00
|
|
|
// If the root node is a ConstantSDNode, increases its size.
|
|
|
|
// e.g. (set R32:$dst, 0).
|
|
|
|
if (P->isLeaf() && dynamic_cast<IntInit*>(P->getLeafValue()))
|
|
|
|
Size++;
|
2005-12-08 02:00:36 +00:00
|
|
|
|
|
|
|
// FIXME: This is a hack to statically increase the priority of patterns
|
|
|
|
// which maps a sub-dag to a complex pattern. e.g. favors LEA over ADD.
|
|
|
|
// Later we can allow complexity / cost for each pattern to be (optionally)
|
|
|
|
// specified. To get best possible pattern match we'll need to dynamically
|
|
|
|
// calculate the complexity of all patterns a dag can potentially map to.
|
|
|
|
const ComplexPattern *AM = NodeGetComplexPattern(P, ISE);
|
|
|
|
if (AM)
|
2006-01-06 22:19:44 +00:00
|
|
|
Size += AM->getNumOperands() * 2;
|
2006-02-03 18:06:02 +00:00
|
|
|
|
|
|
|
// If this node has some predicate function that must match, it adds to the
|
|
|
|
// complexity of this node.
|
|
|
|
if (!P->getPredicateFn().empty())
|
|
|
|
++Size;
|
|
|
|
|
2005-09-28 17:57:56 +00:00
|
|
|
// 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);
|
2005-12-30 00:12:56 +00:00
|
|
|
if (!Child->isLeaf() && Child->getExtTypeNum(0) != MVT::Other)
|
2005-12-08 02:00:36 +00:00
|
|
|
Size += getPatternSize(Child, ISE);
|
|
|
|
else if (Child->isLeaf()) {
|
|
|
|
if (dynamic_cast<IntInit*>(Child->getLeafValue()))
|
2006-02-03 18:06:02 +00:00
|
|
|
Size += 3; // Matches a ConstantSDNode (+2) and a specific value (+1).
|
2006-01-06 22:19:44 +00:00
|
|
|
else if (NodeIsComplexPattern(Child))
|
|
|
|
Size += getPatternSize(Child, ISE);
|
2006-02-03 18:06:02 +00:00
|
|
|
else if (!Child->getPredicateFn().empty())
|
|
|
|
++Size;
|
2005-10-19 04:41:05 +00:00
|
|
|
}
|
2005-09-28 17:57:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return Size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getResultPatternCost - Compute the number of instructions for this pattern.
|
|
|
|
/// This is a temporary hack. We should really include the instruction
|
|
|
|
/// latencies in this calculation.
|
|
|
|
static unsigned getResultPatternCost(TreePatternNode *P) {
|
|
|
|
if (P->isLeaf()) return 0;
|
|
|
|
|
|
|
|
unsigned Cost = P->getOperator()->isSubClassOf("Instruction");
|
|
|
|
for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i)
|
|
|
|
Cost += getResultPatternCost(P->getChild(i));
|
|
|
|
return Cost;
|
|
|
|
}
|
|
|
|
|
|
|
|
// PatternSortingPredicate - return true if we prefer to match LHS before RHS.
|
|
|
|
// In particular, we want to match maximal patterns first and lowest cost within
|
|
|
|
// a particular complexity first.
|
|
|
|
struct PatternSortingPredicate {
|
2005-12-08 02:00:36 +00:00
|
|
|
PatternSortingPredicate(DAGISelEmitter &ise) : ISE(ise) {};
|
|
|
|
DAGISelEmitter &ISE;
|
|
|
|
|
2005-12-14 22:02:59 +00:00
|
|
|
bool operator()(PatternToMatch *LHS,
|
|
|
|
PatternToMatch *RHS) {
|
|
|
|
unsigned LHSSize = getPatternSize(LHS->getSrcPattern(), ISE);
|
|
|
|
unsigned RHSSize = getPatternSize(RHS->getSrcPattern(), ISE);
|
2005-09-28 17:57:56 +00:00
|
|
|
if (LHSSize > RHSSize) return true; // LHS -> bigger -> less cost
|
|
|
|
if (LHSSize < RHSSize) return false;
|
|
|
|
|
|
|
|
// If the patterns have equal complexity, compare generated instruction cost
|
2005-12-14 22:02:59 +00:00
|
|
|
return getResultPatternCost(LHS->getDstPattern()) <
|
|
|
|
getResultPatternCost(RHS->getDstPattern());
|
2005-09-28 17:57:56 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
/// getRegisterValueType - Look up and return the first ValueType of specified
|
|
|
|
/// RegisterClass record
|
|
|
|
static MVT::ValueType getRegisterValueType(Record *R, const CodeGenTarget &T) {
|
|
|
|
if (const CodeGenRegisterClass *RC = T.getRegisterClassForRegister(R))
|
|
|
|
return RC->getValueTypeNum(0);
|
|
|
|
return MVT::Other;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// RemoveAllTypes - A quick recursive walk over a pattern which removes all
|
|
|
|
/// type information from it.
|
|
|
|
static void RemoveAllTypes(TreePatternNode *N) {
|
2005-12-30 00:12:56 +00:00
|
|
|
N->removeTypes();
|
2005-12-09 22:45:35 +00:00
|
|
|
if (!N->isLeaf())
|
|
|
|
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i)
|
|
|
|
RemoveAllTypes(N->getChild(i));
|
|
|
|
}
|
|
|
|
|
|
|
|
Record *DAGISelEmitter::getSDNodeNamed(const std::string &Name) const {
|
|
|
|
Record *N = Records.getDef(Name);
|
|
|
|
assert(N && N->isSubClassOf("SDNode") && "Bad argument");
|
|
|
|
return N;
|
|
|
|
}
|
|
|
|
|
2006-01-09 18:27:06 +00:00
|
|
|
/// NodeHasProperty - return true if TreePatternNode has the specified
|
|
|
|
/// property.
|
|
|
|
static bool NodeHasProperty(TreePatternNode *N, SDNodeInfo::SDNP Property,
|
|
|
|
DAGISelEmitter &ISE)
|
2005-12-23 22:11:47 +00:00
|
|
|
{
|
|
|
|
if (N->isLeaf()) return false;
|
|
|
|
Record *Operator = N->getOperator();
|
|
|
|
if (!Operator->isSubClassOf("SDNode")) return false;
|
|
|
|
|
|
|
|
const SDNodeInfo &NodeInfo = ISE.getSDNodeInfo(Operator);
|
2006-01-09 18:27:06 +00:00
|
|
|
return NodeInfo.hasProperty(Property);
|
2005-12-23 22:11:47 +00:00
|
|
|
}
|
|
|
|
|
2006-01-09 18:27:06 +00:00
|
|
|
static bool PatternHasProperty(TreePatternNode *N, SDNodeInfo::SDNP Property,
|
|
|
|
DAGISelEmitter &ISE)
|
2005-12-23 22:11:47 +00:00
|
|
|
{
|
2006-01-09 18:27:06 +00:00
|
|
|
if (NodeHasProperty(N, Property, ISE))
|
2005-12-23 22:11:47 +00:00
|
|
|
return true;
|
2006-01-09 18:27:06 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
|
|
|
|
TreePatternNode *Child = N->getChild(i);
|
|
|
|
if (PatternHasProperty(Child, Property, ISE))
|
|
|
|
return true;
|
2005-12-23 22:11:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
class PatternCodeEmitter {
|
|
|
|
private:
|
|
|
|
DAGISelEmitter &ISE;
|
|
|
|
|
2005-12-14 22:02:59 +00:00
|
|
|
// Predicates.
|
|
|
|
ListInit *Predicates;
|
|
|
|
// Instruction selector pattern.
|
|
|
|
TreePatternNode *Pattern;
|
|
|
|
// Matched instruction.
|
|
|
|
TreePatternNode *Instruction;
|
2006-01-28 20:31:24 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
// Node to name mapping
|
2006-01-12 19:35:54 +00:00
|
|
|
std::map<std::string, std::string> VariableMap;
|
|
|
|
// Node to operator mapping
|
|
|
|
std::map<std::string, Record*> OperatorMap;
|
2005-12-09 22:45:35 +00:00
|
|
|
// Names of all the folded nodes which produce chains.
|
2005-12-19 07:18:51 +00:00
|
|
|
std::vector<std::pair<std::string, unsigned> > FoldedChains;
|
2006-01-19 01:55:45 +00:00
|
|
|
std::set<std::string> Duplicates;
|
2005-12-09 22:45:35 +00:00
|
|
|
|
2006-01-28 20:31:24 +00:00
|
|
|
/// GeneratedCode - This is the buffer that we emit code to. The first bool
|
|
|
|
/// indicates whether this is an exit predicate (something that should be
|
|
|
|
/// tested, and if true, the match fails) [when true] or normal code to emit
|
|
|
|
/// [when false].
|
|
|
|
std::vector<std::pair<bool, std::string> > &GeneratedCode;
|
2006-02-07 00:37:41 +00:00
|
|
|
/// GeneratedDecl - This is the set of all SDOperand declarations needed for
|
|
|
|
/// the set of patterns for each top-level opcode.
|
2006-02-09 07:16:09 +00:00
|
|
|
std::set<std::pair<bool, std::string> > &GeneratedDecl;
|
2006-01-28 20:31:24 +00:00
|
|
|
|
2006-02-03 06:22:41 +00:00
|
|
|
std::string ChainName;
|
2006-02-05 06:43:12 +00:00
|
|
|
bool DoReplace;
|
2006-01-28 20:31:24 +00:00
|
|
|
unsigned TmpNo;
|
|
|
|
|
|
|
|
void emitCheck(const std::string &S) {
|
|
|
|
if (!S.empty())
|
|
|
|
GeneratedCode.push_back(std::make_pair(true, S));
|
|
|
|
}
|
|
|
|
void emitCode(const std::string &S) {
|
|
|
|
if (!S.empty())
|
|
|
|
GeneratedCode.push_back(std::make_pair(false, S));
|
|
|
|
}
|
2006-02-09 07:16:09 +00:00
|
|
|
void emitDecl(const std::string &S, bool isSDNode=false) {
|
2006-02-07 00:37:41 +00:00
|
|
|
assert(!S.empty() && "Invalid declaration");
|
2006-02-09 07:16:09 +00:00
|
|
|
GeneratedDecl.insert(std::make_pair(isSDNode, S));
|
2006-02-07 00:37:41 +00:00
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
public:
|
2005-12-14 22:02:59 +00:00
|
|
|
PatternCodeEmitter(DAGISelEmitter &ise, ListInit *preds,
|
|
|
|
TreePatternNode *pattern, TreePatternNode *instr,
|
2006-02-07 00:37:41 +00:00
|
|
|
std::vector<std::pair<bool, std::string> > &gc,
|
2006-02-09 07:16:09 +00:00
|
|
|
std::set<std::pair<bool, std::string> > &gd,
|
2006-02-07 00:37:41 +00:00
|
|
|
bool dorep)
|
2006-01-28 20:31:24 +00:00
|
|
|
: ISE(ise), Predicates(preds), Pattern(pattern), Instruction(instr),
|
2006-02-07 00:37:41 +00:00
|
|
|
GeneratedCode(gc), GeneratedDecl(gd), DoReplace(dorep), TmpNo(0) {}
|
2005-12-21 05:31:05 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
/// EmitMatchCode - Emit a matcher for N, going to the label for PatternNo
|
|
|
|
/// if the match fails. At this point, we already know that the opcode for N
|
|
|
|
/// matches, and the SDNode for the result has the RootName specified name.
|
2006-02-05 06:43:12 +00:00
|
|
|
void EmitMatchCode(TreePatternNode *N, TreePatternNode *P,
|
|
|
|
const std::string &RootName, const std::string &ParentName,
|
|
|
|
const std::string &ChainSuffix, bool &FoundChain) {
|
|
|
|
bool isRoot = (P == NULL);
|
2005-12-14 22:02:59 +00:00
|
|
|
// Emit instruction predicates. Each predicate is just a string for now.
|
|
|
|
if (isRoot) {
|
2006-01-28 20:31:24 +00:00
|
|
|
std::string PredicateCheck;
|
2005-12-14 22:02:59 +00:00
|
|
|
for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) {
|
|
|
|
if (DefInit *Pred = dynamic_cast<DefInit*>(Predicates->getElement(i))) {
|
|
|
|
Record *Def = Pred->getDef();
|
2006-01-28 20:31:24 +00:00
|
|
|
if (!Def->isSubClassOf("Predicate")) {
|
2005-12-14 22:02:59 +00:00
|
|
|
Def->dump();
|
|
|
|
assert(0 && "Unknown predicate type!");
|
|
|
|
}
|
2006-01-28 20:31:24 +00:00
|
|
|
if (!PredicateCheck.empty())
|
2006-01-28 20:43:52 +00:00
|
|
|
PredicateCheck += " || ";
|
|
|
|
PredicateCheck += "(" + Def->getValueAsString("CondString") + ")";
|
2005-12-14 22:02:59 +00:00
|
|
|
}
|
|
|
|
}
|
2006-01-28 20:31:24 +00:00
|
|
|
|
|
|
|
emitCheck(PredicateCheck);
|
2005-12-14 22:02:59 +00:00
|
|
|
}
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
if (N->isLeaf()) {
|
|
|
|
if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCheck("cast<ConstantSDNode>(" + RootName +
|
2006-01-28 20:43:52 +00:00
|
|
|
")->getSignExtended() == " + itostr(II->getValue()));
|
2005-12-09 22:45:35 +00:00
|
|
|
return;
|
|
|
|
} else if (!NodeIsComplexPattern(N)) {
|
|
|
|
assert(0 && "Cannot match this as a leaf value!");
|
|
|
|
abort();
|
|
|
|
}
|
2005-11-02 06:49:14 +00:00
|
|
|
}
|
2005-09-24 00:40:24 +00:00
|
|
|
|
2006-01-28 19:06:51 +00:00
|
|
|
// If this node has a name associated with it, capture it in VariableMap. If
|
2005-12-09 22:45:35 +00:00
|
|
|
// we already saw this in the pattern, emit code to verify dagness.
|
|
|
|
if (!N->getName().empty()) {
|
|
|
|
std::string &VarMapEntry = VariableMap[N->getName()];
|
|
|
|
if (VarMapEntry.empty()) {
|
|
|
|
VarMapEntry = RootName;
|
|
|
|
} else {
|
|
|
|
// If we get here, this is a second reference to a specific name. Since
|
|
|
|
// we already have checked that the first reference is valid, we don't
|
|
|
|
// have to recursively match it, just check that it's the same as the
|
|
|
|
// previously named thing.
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck(VarMapEntry + " == " + RootName);
|
2005-12-09 22:45:35 +00:00
|
|
|
return;
|
|
|
|
}
|
2006-01-12 19:35:54 +00:00
|
|
|
|
|
|
|
if (!N->isLeaf())
|
|
|
|
OperatorMap[N->getName()] = N->getOperator();
|
2005-09-24 00:40:24 +00:00
|
|
|
}
|
2005-12-04 08:18:16 +00:00
|
|
|
|
2005-12-09 00:48:42 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
// Emit code to load the child nodes and match their contents recursively.
|
|
|
|
unsigned OpNo = 0;
|
2006-02-05 06:43:12 +00:00
|
|
|
bool NodeHasChain = NodeHasProperty (N, SDNodeInfo::SDNPHasChain, ISE);
|
|
|
|
bool HasChain = PatternHasProperty(N, SDNodeInfo::SDNPHasChain, ISE);
|
|
|
|
bool HasOutFlag = PatternHasProperty(N, SDNodeInfo::SDNPOutFlag, ISE);
|
2006-01-26 19:13:45 +00:00
|
|
|
bool EmittedUseCheck = false;
|
|
|
|
bool EmittedSlctedCheck = false;
|
2005-12-12 19:37:43 +00:00
|
|
|
if (HasChain) {
|
Prevent folding of a node with multiple uses if the node already folds a load!
Here is an example where the load ended up being done twice:
%A = global uint 0
uint %test(uint %B, ubyte %C) {
%tmp = load uint *%A;
%X = shl uint %tmp, ubyte %C
%Cv = sub ubyte 32, %C
%Y = shr uint %B, ubyte %Cv
%Z = or uint %Y, %X
store uint %Z, uint* %A
ret uint %Z
}
==>
subl $4, %esp
movl %ebx, (%esp)
movl 8(%esp), %edx
movl A, %eax
movb 12(%esp), %bl
movb %bl, %cl
shldl %cl, %edx, %eax
movb %bl, %cl
shldl %cl, %edx, A
movl (%esp), %ebx
addl $4, %esp
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25471 91177308-0d34-0410-b5e6-96231b3b80d8
2006-01-20 01:11:03 +00:00
|
|
|
if (NodeHasChain)
|
|
|
|
OpNo = 1;
|
2005-12-09 22:45:35 +00:00
|
|
|
if (!isRoot) {
|
2005-12-10 00:09:17 +00:00
|
|
|
const SDNodeInfo &CInfo = ISE.getSDNodeInfo(N->getOperator());
|
2006-01-28 20:31:24 +00:00
|
|
|
// Multiple uses of actual result?
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck(RootName + ".hasOneUse()");
|
2006-01-26 19:13:45 +00:00
|
|
|
EmittedUseCheck = true;
|
|
|
|
// hasOneUse() check is not strong enough. If the original node has
|
|
|
|
// already been selected, it may have been replaced with another.
|
2006-01-28 20:31:24 +00:00
|
|
|
for (unsigned j = 0; j != CInfo.getNumResults(); j++)
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck("!CodeGenMap.count(" + RootName + ".getValue(" + utostr(j) +
|
2006-01-28 20:31:24 +00:00
|
|
|
"))");
|
|
|
|
|
2006-01-26 19:13:45 +00:00
|
|
|
EmittedSlctedCheck = true;
|
2006-02-05 06:43:12 +00:00
|
|
|
if (NodeHasChain) {
|
|
|
|
// FIXME: Don't fold if 1) the parent node writes a flag, 2) the node
|
|
|
|
// has a chain use.
|
|
|
|
// This a workaround for this problem:
|
|
|
|
//
|
|
|
|
// [ch, r : ld]
|
|
|
|
// ^ ^
|
|
|
|
// | |
|
|
|
|
// [XX]--/ \- [flag : cmp]
|
|
|
|
// ^ ^
|
|
|
|
// | |
|
|
|
|
// \---[br flag]-
|
|
|
|
//
|
|
|
|
// cmp + br should be considered as a single node as they are flagged
|
|
|
|
// together. So, if the ld is folded into the cmp, the XX node in the
|
|
|
|
// graph is now both an operand and a use of the ld/cmp/br node.
|
|
|
|
if (NodeHasProperty(P, SDNodeInfo::SDNPOutFlag, ISE))
|
|
|
|
emitCheck(ParentName + ".Val->isOnlyUse(" + RootName + ".Val)");
|
|
|
|
|
|
|
|
// If the immediate use can somehow reach this node through another
|
|
|
|
// path, then can't fold it either or it will create a cycle.
|
|
|
|
// e.g. In the following diagram, XX can reach ld through YY. If
|
|
|
|
// ld is folded into XX, then YY is both a predecessor and a successor
|
|
|
|
// of XX.
|
|
|
|
//
|
|
|
|
// [ld]
|
|
|
|
// ^ ^
|
|
|
|
// | |
|
|
|
|
// / \---
|
|
|
|
// / [YY]
|
|
|
|
// | ^
|
|
|
|
// [XX]-------|
|
|
|
|
const SDNodeInfo &PInfo = ISE.getSDNodeInfo(P->getOperator());
|
|
|
|
if (PInfo.getNumOperands() > 1 ||
|
|
|
|
PInfo.hasProperty(SDNodeInfo::SDNPHasChain) ||
|
|
|
|
PInfo.hasProperty(SDNodeInfo::SDNPInFlag) ||
|
|
|
|
PInfo.hasProperty(SDNodeInfo::SDNPOptInFlag))
|
|
|
|
emitCheck("(" + ParentName + ".getNumOperands() == 1 || !" +
|
|
|
|
"isNonImmUse(" + ParentName + ".Val, " + RootName +
|
|
|
|
".Val))");
|
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2006-02-05 06:43:12 +00:00
|
|
|
|
2006-01-27 22:13:45 +00:00
|
|
|
if (NodeHasChain) {
|
2006-02-03 06:22:41 +00:00
|
|
|
if (FoundChain)
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck("Chain.Val == " + RootName + ".Val");
|
2006-02-03 06:22:41 +00:00
|
|
|
else
|
|
|
|
FoundChain = true;
|
|
|
|
ChainName = "Chain" + ChainSuffix;
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl(ChainName);
|
|
|
|
emitCode(ChainName + " = " + RootName +
|
2006-02-03 06:22:41 +00:00
|
|
|
".getOperand(0);");
|
2006-01-06 00:41:12 +00:00
|
|
|
}
|
2005-12-09 00:48:42 +00:00
|
|
|
}
|
|
|
|
|
2006-01-26 00:22:25 +00:00
|
|
|
// Don't fold any node which reads or writes a flag and has multiple uses.
|
2006-02-05 06:43:12 +00:00
|
|
|
// FIXME: We really need to separate the concepts of flag and "glue". Those
|
2006-01-26 00:22:25 +00:00
|
|
|
// real flag results, e.g. X86CMP output, can have multiple uses.
|
2006-02-05 06:43:12 +00:00
|
|
|
// FIXME: If the optional incoming flag does not exist. Then it is ok to
|
|
|
|
// fold it.
|
2006-01-26 19:13:45 +00:00
|
|
|
if (!isRoot &&
|
2006-01-26 00:22:25 +00:00
|
|
|
(PatternHasProperty(N, SDNodeInfo::SDNPInFlag, ISE) ||
|
|
|
|
PatternHasProperty(N, SDNodeInfo::SDNPOptInFlag, ISE) ||
|
|
|
|
PatternHasProperty(N, SDNodeInfo::SDNPOutFlag, ISE))) {
|
2006-01-26 19:13:45 +00:00
|
|
|
const SDNodeInfo &CInfo = ISE.getSDNodeInfo(N->getOperator());
|
|
|
|
if (!EmittedUseCheck) {
|
2006-01-28 20:31:24 +00:00
|
|
|
// Multiple uses of actual result?
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck(RootName + ".hasOneUse()");
|
2006-01-26 00:22:25 +00:00
|
|
|
}
|
2006-01-26 19:13:45 +00:00
|
|
|
if (!EmittedSlctedCheck)
|
|
|
|
// hasOneUse() check is not strong enough. If the original node has
|
|
|
|
// already been selected, it may have been replaced with another.
|
2006-01-28 20:31:24 +00:00
|
|
|
for (unsigned j = 0; j < CInfo.getNumResults(); j++)
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck("!CodeGenMap.count(" + RootName + ".getValue(" + utostr(j) +
|
2006-01-28 20:31:24 +00:00
|
|
|
"))");
|
2006-01-26 00:22:25 +00:00
|
|
|
}
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i, ++OpNo) {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl(RootName + utostr(OpNo));
|
|
|
|
emitCode(RootName + utostr(OpNo) + " = " +
|
2006-01-28 20:31:24 +00:00
|
|
|
RootName + ".getOperand(" +utostr(OpNo) + ");");
|
2005-12-09 22:45:35 +00:00
|
|
|
TreePatternNode *Child = N->getChild(i);
|
2005-09-23 23:16:51 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
if (!Child->isLeaf()) {
|
|
|
|
// If it's not a leaf, recursively match.
|
|
|
|
const SDNodeInfo &CInfo = ISE.getSDNodeInfo(Child->getOperator());
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck(RootName + utostr(OpNo) + ".getOpcode() == " +
|
2006-01-28 20:31:24 +00:00
|
|
|
CInfo.getEnumName());
|
2006-02-05 06:43:12 +00:00
|
|
|
EmitMatchCode(Child, N, RootName + utostr(OpNo), RootName,
|
|
|
|
ChainSuffix + utostr(OpNo), FoundChain);
|
2006-01-28 20:31:24 +00:00
|
|
|
if (NodeHasProperty(Child, SDNodeInfo::SDNPHasChain, ISE))
|
2005-12-19 07:18:51 +00:00
|
|
|
FoldedChains.push_back(std::make_pair(RootName + utostr(OpNo),
|
|
|
|
CInfo.getNumResults()));
|
2005-12-09 22:45:35 +00:00
|
|
|
} else {
|
2006-01-28 19:06:51 +00:00
|
|
|
// If this child has a name associated with it, capture it in VarMap. If
|
2005-12-09 22:45:35 +00:00
|
|
|
// we already saw this in the pattern, emit code to verify dagness.
|
|
|
|
if (!Child->getName().empty()) {
|
|
|
|
std::string &VarMapEntry = VariableMap[Child->getName()];
|
|
|
|
if (VarMapEntry.empty()) {
|
|
|
|
VarMapEntry = RootName + utostr(OpNo);
|
|
|
|
} else {
|
2006-01-27 22:22:28 +00:00
|
|
|
// If we get here, this is a second reference to a specific name.
|
|
|
|
// Since we already have checked that the first reference is valid,
|
|
|
|
// we don't have to recursively match it, just check that it's the
|
|
|
|
// same as the previously named thing.
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck(VarMapEntry + " == " + RootName + utostr(OpNo));
|
2006-01-19 01:55:45 +00:00
|
|
|
Duplicates.insert(RootName + utostr(OpNo));
|
2005-12-09 22:45:35 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-09-24 00:40:24 +00:00
|
|
|
}
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
// Handle leaves of various types.
|
|
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) {
|
|
|
|
Record *LeafRec = DI->getDef();
|
|
|
|
if (LeafRec->isSubClassOf("RegisterClass")) {
|
|
|
|
// Handle register references. Nothing to do here.
|
|
|
|
} else if (LeafRec->isSubClassOf("Register")) {
|
2005-12-22 02:24:50 +00:00
|
|
|
// Handle register references.
|
2005-12-09 22:45:35 +00:00
|
|
|
} else if (LeafRec->isSubClassOf("ComplexPattern")) {
|
|
|
|
// Handle complex pattern. Nothing to do here.
|
2005-12-14 02:21:57 +00:00
|
|
|
} else if (LeafRec->getName() == "srcvalue") {
|
|
|
|
// Place holder for SRCVALUE nodes. Nothing to do here.
|
2005-12-09 22:45:35 +00:00
|
|
|
} else if (LeafRec->isSubClassOf("ValueType")) {
|
|
|
|
// Make sure this is the specified value type.
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCheck("cast<VTSDNode>(" + RootName + utostr(OpNo) +
|
2006-01-28 20:43:52 +00:00
|
|
|
")->getVT() == MVT::" + LeafRec->getName());
|
2005-12-09 22:45:35 +00:00
|
|
|
} else if (LeafRec->isSubClassOf("CondCode")) {
|
|
|
|
// Make sure this is the specified cond code.
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCheck("cast<CondCodeSDNode>(" + RootName + utostr(OpNo) +
|
2006-01-28 20:43:52 +00:00
|
|
|
")->get() == ISD::" + LeafRec->getName());
|
2005-12-09 22:45:35 +00:00
|
|
|
} else {
|
|
|
|
Child->dump();
|
2005-12-22 02:24:50 +00:00
|
|
|
std::cerr << " ";
|
2005-12-09 22:45:35 +00:00
|
|
|
assert(0 && "Unknown leaf type!");
|
2005-12-09 00:48:42 +00:00
|
|
|
}
|
2006-01-28 19:06:51 +00:00
|
|
|
} else if (IntInit *II =
|
|
|
|
dynamic_cast<IntInit*>(Child->getLeafValue())) {
|
2006-01-29 04:25:26 +00:00
|
|
|
emitCheck("isa<ConstantSDNode>(" + RootName + utostr(OpNo) + ")");
|
|
|
|
unsigned CTmp = TmpNo++;
|
2006-01-29 05:22:37 +00:00
|
|
|
emitCode("int64_t CN"+utostr(CTmp)+" = cast<ConstantSDNode>("+
|
2006-01-29 04:25:26 +00:00
|
|
|
RootName + utostr(OpNo) + ")->getSignExtended();");
|
|
|
|
|
|
|
|
emitCheck("CN" + utostr(CTmp) + " == " +itostr(II->getValue()));
|
2005-10-19 04:41:05 +00:00
|
|
|
} else {
|
|
|
|
Child->dump();
|
|
|
|
assert(0 && "Unknown leaf type!");
|
|
|
|
}
|
2005-09-23 21:33:23 +00:00
|
|
|
}
|
|
|
|
}
|
2005-12-04 08:18:16 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
// If there is a node predicate for this, emit the call.
|
2006-01-28 20:31:24 +00:00
|
|
|
if (!N->getPredicateFn().empty())
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck(N->getPredicateFn() + "(" + RootName + ".Val)");
|
Teach tblgen to accept register source operands in patterns, e.g.
def SHL8rCL : I<0xD2, MRM4r, (ops R8 :$dst, R8 :$src),
"shl{b} {%cl, $dst|$dst, %CL}",
[(set R8:$dst, (shl R8:$src, CL))]>, Imp<[CL],[]>;
This generates a CopyToReg operand and added its 2nd result to the shl as
a flag operand.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24557 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-01 00:18:45 +00:00
|
|
|
}
|
2005-12-08 02:00:36 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
/// EmitResultCode - Emit the action for a pattern. Now that it has matched
|
|
|
|
/// we actually have to build a DAG!
|
|
|
|
std::pair<unsigned, unsigned>
|
|
|
|
EmitResultCode(TreePatternNode *N, bool isRoot = false) {
|
|
|
|
// This is something selected from the pattern we matched.
|
|
|
|
if (!N->getName().empty()) {
|
|
|
|
assert(!isRoot && "Root of pattern cannot be a leaf!");
|
|
|
|
std::string &Val = VariableMap[N->getName()];
|
|
|
|
assert(!Val.empty() &&
|
|
|
|
"Variable referenced but not defined and not caught earlier!");
|
|
|
|
if (Val[0] == 'T' && Val[1] == 'm' && Val[2] == 'p') {
|
|
|
|
// Already selected this operand, just return the tmpval.
|
|
|
|
return std::make_pair(1, atoi(Val.c_str()+3));
|
2005-09-28 16:58:06 +00:00
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
|
|
|
|
const ComplexPattern *CP;
|
|
|
|
unsigned ResNo = TmpNo++;
|
|
|
|
unsigned NumRes = 1;
|
|
|
|
if (!N->isLeaf() && N->getOperator()->getName() == "imm") {
|
2005-12-30 00:12:56 +00:00
|
|
|
assert(N->getExtTypes().size() == 1 && "Multiple types not handled!");
|
2006-01-29 20:01:35 +00:00
|
|
|
std::string CastType;
|
2005-12-30 00:12:56 +00:00
|
|
|
switch (N->getTypeNum(0)) {
|
2006-01-28 20:31:24 +00:00
|
|
|
default: assert(0 && "Unknown type for constant node!");
|
2006-01-29 20:01:35 +00:00
|
|
|
case MVT::i1: CastType = "bool"; break;
|
|
|
|
case MVT::i8: CastType = "unsigned char"; break;
|
|
|
|
case MVT::i16: CastType = "unsigned short"; break;
|
|
|
|
case MVT::i32: CastType = "unsigned"; break;
|
|
|
|
case MVT::i64: CastType = "uint64_t"; break;
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2006-01-29 20:01:35 +00:00
|
|
|
emitCode(CastType + " Tmp" + utostr(ResNo) + "C = (" + CastType +
|
2006-01-29 05:17:22 +00:00
|
|
|
")cast<ConstantSDNode>(" + Val + ")->getValue();");
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
|
|
|
emitCode("Tmp" + utostr(ResNo) +
|
2006-01-28 20:31:24 +00:00
|
|
|
" = CurDAG->getTargetConstant(Tmp" + utostr(ResNo) +
|
|
|
|
"C, MVT::" + getEnumName(N->getTypeNum(0)) + ");");
|
2006-01-12 07:54:57 +00:00
|
|
|
} else if (!N->isLeaf() && N->getOperator()->getName() == "texternalsym"){
|
2006-01-12 19:35:54 +00:00
|
|
|
Record *Op = OperatorMap[N->getName()];
|
|
|
|
// Transform ExternalSymbol to TargetExternalSymbol
|
|
|
|
if (Op && Op->getName() == "externalsym") {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
|
|
|
emitCode("Tmp" + utostr(ResNo) + " = CurDAG->getTarget"
|
2006-01-28 20:31:24 +00:00
|
|
|
"ExternalSymbol(cast<ExternalSymbolSDNode>(" +
|
|
|
|
Val + ")->getSymbol(), MVT::" +
|
|
|
|
getEnumName(N->getTypeNum(0)) + ");");
|
|
|
|
} else {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
|
|
|
emitCode("Tmp" + utostr(ResNo) + " = " + Val + ";");
|
2006-01-28 20:31:24 +00:00
|
|
|
}
|
2006-01-12 07:54:57 +00:00
|
|
|
} else if (!N->isLeaf() && N->getOperator()->getName() == "tglobaladdr") {
|
2006-01-12 19:35:54 +00:00
|
|
|
Record *Op = OperatorMap[N->getName()];
|
|
|
|
// Transform GlobalAddress to TargetGlobalAddress
|
|
|
|
if (Op && Op->getName() == "globaladdr") {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
|
|
|
emitCode("Tmp" + utostr(ResNo) + " = CurDAG->getTarget"
|
2006-01-28 20:31:24 +00:00
|
|
|
"GlobalAddress(cast<GlobalAddressSDNode>(" + Val +
|
|
|
|
")->getGlobal(), MVT::" + getEnumName(N->getTypeNum(0)) +
|
|
|
|
");");
|
|
|
|
} else {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
|
|
|
emitCode("Tmp" + utostr(ResNo) + " = " + Val + ";");
|
2006-01-28 20:31:24 +00:00
|
|
|
}
|
2006-01-03 22:55:16 +00:00
|
|
|
} else if (!N->isLeaf() && N->getOperator()->getName() == "texternalsym"){
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
|
|
|
emitCode("Tmp" + utostr(ResNo) + " = " + Val + ";");
|
2006-01-12 07:54:57 +00:00
|
|
|
} else if (!N->isLeaf() && N->getOperator()->getName() == "tconstpool") {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
|
|
|
emitCode("Tmp" + utostr(ResNo) + " = " + Val + ";");
|
2005-12-09 22:45:35 +00:00
|
|
|
} else if (N->isLeaf() && (CP = NodeGetComplexPattern(N, ISE))) {
|
|
|
|
std::string Fn = CP->getSelectFunc();
|
|
|
|
NumRes = CP->getNumOperands();
|
2006-02-07 00:37:41 +00:00
|
|
|
for (unsigned i = 0; i < NumRes; ++i)
|
|
|
|
emitDecl("Tmp" + utostr(i+ResNo));
|
2006-01-28 20:31:24 +00:00
|
|
|
|
2006-02-07 00:37:41 +00:00
|
|
|
std::string Code = Fn + "(" + Val;
|
2006-01-04 03:23:30 +00:00
|
|
|
for (unsigned i = 0; i < NumRes; i++)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", Tmp" + utostr(i + ResNo);
|
|
|
|
emitCheck(Code + ")");
|
2006-02-04 08:50:49 +00:00
|
|
|
|
2006-02-05 05:22:18 +00:00
|
|
|
for (unsigned i = 0; i < NumRes; ++i)
|
2006-02-09 00:37:58 +00:00
|
|
|
emitCode("Select(Tmp" + utostr(i+ResNo) + ", Tmp" +
|
2006-02-05 05:22:18 +00:00
|
|
|
utostr(i+ResNo) + ");");
|
2006-02-04 08:50:49 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
TmpNo = ResNo + NumRes;
|
|
|
|
} else {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
2006-02-09 00:37:58 +00:00
|
|
|
emitCode("Select(Tmp" + utostr(ResNo) + ", " + Val + ");");
|
2005-12-08 02:00:36 +00:00
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
// Add Tmp<ResNo> to VariableMap, so that we don't multiply select this
|
|
|
|
// value if used multiple times by this pattern result.
|
|
|
|
Val = "Tmp"+utostr(ResNo);
|
|
|
|
return std::make_pair(NumRes, ResNo);
|
2005-09-24 00:40:24 +00:00
|
|
|
}
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
if (N->isLeaf()) {
|
|
|
|
// If this is an explicit register reference, handle it.
|
|
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) {
|
|
|
|
unsigned ResNo = TmpNo++;
|
|
|
|
if (DI->getDef()->isSubClassOf("Register")) {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
|
|
|
emitCode("Tmp" + utostr(ResNo) + " = CurDAG->getRegister(" +
|
2006-01-28 20:31:24 +00:00
|
|
|
ISE.getQualifiedName(DI->getDef()) + ", MVT::" +
|
|
|
|
getEnumName(N->getTypeNum(0)) + ");");
|
2005-12-09 22:45:35 +00:00
|
|
|
return std::make_pair(1, ResNo);
|
|
|
|
}
|
|
|
|
} else if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
|
|
|
|
unsigned ResNo = TmpNo++;
|
2005-12-30 00:12:56 +00:00
|
|
|
assert(N->getExtTypes().size() == 1 && "Multiple types not handled!");
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
|
|
|
emitCode("Tmp" + utostr(ResNo) +
|
2006-01-28 20:31:24 +00:00
|
|
|
" = CurDAG->getTargetConstant(" + itostr(II->getValue()) +
|
|
|
|
", MVT::" + getEnumName(N->getTypeNum(0)) + ");");
|
2005-12-08 02:00:36 +00:00
|
|
|
return std::make_pair(1, ResNo);
|
2005-10-19 02:07:26 +00:00
|
|
|
}
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
N->dump();
|
|
|
|
assert(0 && "Unknown leaf type!");
|
|
|
|
return std::make_pair(1, ~0U);
|
2005-12-09 00:48:42 +00:00
|
|
|
}
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
Record *Op = N->getOperator();
|
|
|
|
if (Op->isSubClassOf("Instruction")) {
|
2005-12-23 22:11:47 +00:00
|
|
|
const CodeGenTarget &CGT = ISE.getTargetInfo();
|
|
|
|
CodeGenInstruction &II = CGT.getInstruction(Op->getName());
|
2005-12-20 07:37:41 +00:00
|
|
|
const DAGInstruction &Inst = ISE.getInstruction(Op);
|
2005-12-23 22:11:47 +00:00
|
|
|
bool HasImpInputs = Inst.getNumImpOperands() > 0;
|
|
|
|
bool HasImpResults = Inst.getNumImpResults() > 0;
|
2006-01-26 00:22:25 +00:00
|
|
|
bool HasOptInFlag = isRoot &&
|
|
|
|
PatternHasProperty(Pattern, SDNodeInfo::SDNPOptInFlag, ISE);
|
2006-01-09 18:27:06 +00:00
|
|
|
bool HasInFlag = isRoot &&
|
2006-01-26 00:22:25 +00:00
|
|
|
PatternHasProperty(Pattern, SDNodeInfo::SDNPInFlag, ISE);
|
|
|
|
bool NodeHasOutFlag = HasImpResults ||
|
2006-01-09 18:27:06 +00:00
|
|
|
(isRoot && PatternHasProperty(Pattern, SDNodeInfo::SDNPOutFlag, ISE));
|
2006-01-19 21:57:10 +00:00
|
|
|
bool NodeHasChain =
|
|
|
|
NodeHasProperty(Pattern, SDNodeInfo::SDNPHasChain, ISE);
|
2006-01-09 18:27:06 +00:00
|
|
|
bool HasChain = II.hasCtrlDep ||
|
|
|
|
(isRoot && PatternHasProperty(Pattern, SDNodeInfo::SDNPHasChain, ISE));
|
|
|
|
|
2006-01-26 00:22:25 +00:00
|
|
|
if (HasInFlag || NodeHasOutFlag || HasOptInFlag || HasImpInputs)
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("InFlag");
|
2006-01-26 00:22:25 +00:00
|
|
|
if (HasOptInFlag)
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("bool HasOptInFlag = false;");
|
2005-12-20 07:37:41 +00:00
|
|
|
|
2006-01-19 21:57:10 +00:00
|
|
|
// How many results is this pattern expected to produce?
|
|
|
|
unsigned NumExpectedResults = 0;
|
|
|
|
for (unsigned i = 0, e = Pattern->getExtTypes().size(); i != e; i++) {
|
|
|
|
MVT::ValueType VT = Pattern->getTypeNum(i);
|
|
|
|
if (VT != MVT::isVoid && VT != MVT::Flag)
|
|
|
|
NumExpectedResults++;
|
|
|
|
}
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
// Determine operand emission order. Complex pattern first.
|
|
|
|
std::vector<std::pair<unsigned, TreePatternNode*> > EmitOrder;
|
|
|
|
std::vector<std::pair<unsigned, TreePatternNode*> >::iterator OI;
|
|
|
|
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
|
|
|
|
TreePatternNode *Child = N->getChild(i);
|
|
|
|
if (i == 0) {
|
|
|
|
EmitOrder.push_back(std::make_pair(i, Child));
|
|
|
|
OI = EmitOrder.begin();
|
|
|
|
} else if (NodeIsComplexPattern(Child)) {
|
|
|
|
OI = EmitOrder.insert(OI, std::make_pair(i, Child));
|
|
|
|
} else {
|
|
|
|
EmitOrder.push_back(std::make_pair(i, Child));
|
|
|
|
}
|
|
|
|
}
|
2005-09-24 00:40:24 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
// Emit all of the operands.
|
|
|
|
std::vector<std::pair<unsigned, unsigned> > NumTemps(EmitOrder.size());
|
|
|
|
for (unsigned i = 0, e = EmitOrder.size(); i != e; ++i) {
|
|
|
|
unsigned OpOrder = EmitOrder[i].first;
|
|
|
|
TreePatternNode *Child = EmitOrder[i].second;
|
|
|
|
std::pair<unsigned, unsigned> NumTemp = EmitResultCode(Child);
|
|
|
|
NumTemps[OpOrder] = NumTemp;
|
2005-12-04 08:18:16 +00:00
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
|
|
|
|
// List all the operands in the right order.
|
|
|
|
std::vector<unsigned> Ops;
|
|
|
|
for (unsigned i = 0, e = NumTemps.size(); i != e; i++) {
|
|
|
|
for (unsigned j = 0; j < NumTemps[i].first; j++)
|
|
|
|
Ops.push_back(NumTemps[i].second + j);
|
2005-12-04 08:18:16 +00:00
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
|
|
|
|
// Emit all the chain and CopyToReg stuff.
|
2006-01-11 22:16:13 +00:00
|
|
|
bool ChainEmitted = HasChain;
|
2005-12-23 22:11:47 +00:00
|
|
|
if (HasChain)
|
2006-02-09 00:37:58 +00:00
|
|
|
emitCode("Select(" + ChainName + ", " + ChainName + ");");
|
2006-01-26 00:22:25 +00:00
|
|
|
if (HasInFlag || HasOptInFlag || HasImpInputs)
|
|
|
|
EmitInFlagSelectCode(Pattern, "N", ChainEmitted, true);
|
2005-12-09 22:45:35 +00:00
|
|
|
|
|
|
|
unsigned NumResults = Inst.getNumResults();
|
|
|
|
unsigned ResNo = TmpNo++;
|
|
|
|
if (!isRoot) {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
2006-01-28 20:31:24 +00:00
|
|
|
std::string Code =
|
2006-02-09 07:16:09 +00:00
|
|
|
"Tmp" + utostr(ResNo) + " = SDOperand(CurDAG->getTargetNode(" +
|
2006-01-28 20:31:24 +00:00
|
|
|
II.Namespace + "::" + II.TheDef->getName();
|
2005-12-30 00:12:56 +00:00
|
|
|
if (N->getTypeNum(0) != MVT::isVoid)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::" + getEnumName(N->getTypeNum(0));
|
2006-01-26 00:22:25 +00:00
|
|
|
if (NodeHasOutFlag)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::Flag";
|
2005-12-17 01:19:28 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
unsigned LastOp = 0;
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
|
|
|
|
LastOp = Ops[i];
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", Tmp" + utostr(LastOp);
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2006-02-09 07:16:09 +00:00
|
|
|
emitCode(Code + "), 0);");
|
2005-12-23 22:11:47 +00:00
|
|
|
if (HasChain) {
|
2005-12-09 22:45:35 +00:00
|
|
|
// Must have at least one result
|
2006-02-03 06:22:41 +00:00
|
|
|
emitCode(ChainName + " = Tmp" + utostr(LastOp) + ".getValue(" +
|
2006-01-28 20:31:24 +00:00
|
|
|
utostr(NumResults) + ");");
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2006-01-26 00:22:25 +00:00
|
|
|
} else if (HasChain || NodeHasOutFlag) {
|
2006-01-24 20:46:50 +00:00
|
|
|
if (HasOptInFlag) {
|
|
|
|
unsigned FlagNo = (unsigned) NodeHasChain + Pattern->getNumChildren();
|
2006-02-09 07:16:09 +00:00
|
|
|
emitDecl("ResNode", true);
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("if (HasOptInFlag)");
|
2006-02-09 07:16:09 +00:00
|
|
|
std::string Code = " ResNode = CurDAG->getTargetNode(" +
|
2006-01-28 20:31:24 +00:00
|
|
|
II.Namespace + "::" + II.TheDef->getName();
|
2006-01-24 20:46:50 +00:00
|
|
|
|
|
|
|
// Output order: results, chain, flags
|
|
|
|
// Result types.
|
|
|
|
if (NumResults > 0) {
|
|
|
|
if (N->getTypeNum(0) != MVT::isVoid)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::" + getEnumName(N->getTypeNum(0));
|
2006-01-24 20:46:50 +00:00
|
|
|
}
|
|
|
|
if (HasChain)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::Other";
|
2006-01-26 00:22:25 +00:00
|
|
|
if (NodeHasOutFlag)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::Flag";
|
2006-01-24 20:46:50 +00:00
|
|
|
|
|
|
|
// Inputs.
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", Tmp" + utostr(Ops[i]);
|
2006-02-03 06:22:41 +00:00
|
|
|
if (HasChain) Code += ", " + ChainName;
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode(Code + ", InFlag);");
|
2006-01-24 20:46:50 +00:00
|
|
|
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("else");
|
2006-02-09 07:16:09 +00:00
|
|
|
Code = " ResNode = CurDAG->getTargetNode(" + II.Namespace + "::" +
|
2006-01-28 20:31:24 +00:00
|
|
|
II.TheDef->getName();
|
2006-01-24 20:46:50 +00:00
|
|
|
|
|
|
|
// Output order: results, chain, flags
|
|
|
|
// Result types.
|
2006-01-28 20:31:24 +00:00
|
|
|
if (NumResults > 0 && N->getTypeNum(0) != MVT::isVoid)
|
|
|
|
Code += ", MVT::" + getEnumName(N->getTypeNum(0));
|
2006-01-24 20:46:50 +00:00
|
|
|
if (HasChain)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::Other";
|
2006-01-26 00:22:25 +00:00
|
|
|
if (NodeHasOutFlag)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::Flag";
|
2006-01-24 20:46:50 +00:00
|
|
|
|
|
|
|
// Inputs.
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", Tmp" + utostr(Ops[i]);
|
2006-02-03 06:22:41 +00:00
|
|
|
if (HasChain) Code += ", " + ChainName + ");";
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode(Code);
|
2006-01-24 20:46:50 +00:00
|
|
|
} else {
|
2006-02-09 07:16:09 +00:00
|
|
|
emitDecl("ResNode", true);
|
|
|
|
std::string Code = "ResNode = CurDAG->getTargetNode(" +
|
2006-01-28 20:31:24 +00:00
|
|
|
II.Namespace + "::" + II.TheDef->getName();
|
2006-01-24 20:46:50 +00:00
|
|
|
|
|
|
|
// Output order: results, chain, flags
|
|
|
|
// Result types.
|
2006-01-28 20:31:24 +00:00
|
|
|
if (NumResults > 0 && N->getTypeNum(0) != MVT::isVoid)
|
|
|
|
Code += ", MVT::" + getEnumName(N->getTypeNum(0));
|
2006-01-24 20:46:50 +00:00
|
|
|
if (HasChain)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::Other";
|
2006-01-26 00:22:25 +00:00
|
|
|
if (NodeHasOutFlag)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::Flag";
|
2006-01-24 20:46:50 +00:00
|
|
|
|
|
|
|
// Inputs.
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", Tmp" + utostr(Ops[i]);
|
2006-02-03 06:22:41 +00:00
|
|
|
if (HasChain) Code += ", " + ChainName;
|
2006-01-28 20:31:24 +00:00
|
|
|
if (HasInFlag || HasImpInputs) Code += ", InFlag";
|
|
|
|
emitCode(Code + ");");
|
2005-12-17 01:19:28 +00:00
|
|
|
}
|
2005-12-19 07:18:51 +00:00
|
|
|
|
|
|
|
unsigned ValNo = 0;
|
2005-12-19 22:40:04 +00:00
|
|
|
for (unsigned i = 0; i < NumResults; i++) {
|
2006-02-09 22:12:27 +00:00
|
|
|
emitCode("SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, " +
|
|
|
|
utostr(ValNo) + ", ResNode, " + utostr(ValNo) + ");");
|
2005-12-19 22:40:04 +00:00
|
|
|
ValNo++;
|
|
|
|
}
|
|
|
|
|
2006-01-26 00:22:25 +00:00
|
|
|
if (NodeHasOutFlag)
|
2006-02-09 07:16:09 +00:00
|
|
|
emitCode("InFlag = SDOperand(ResNode, " +
|
2006-01-28 20:31:24 +00:00
|
|
|
utostr(ValNo + (unsigned)HasChain) + ");");
|
|
|
|
|
|
|
|
if (HasImpResults && EmitCopyFromRegs(N, ChainEmitted)) {
|
2006-02-09 22:12:27 +00:00
|
|
|
emitCode("SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, " +
|
|
|
|
utostr(ValNo) + ", ResNode, " + utostr(ValNo) + ");");
|
2006-01-28 20:31:24 +00:00
|
|
|
ValNo++;
|
2005-12-22 02:24:50 +00:00
|
|
|
}
|
2005-12-20 07:37:41 +00:00
|
|
|
|
2006-02-09 07:16:09 +00:00
|
|
|
// User does not expect the instruction would produce a chain!
|
2006-01-09 18:27:06 +00:00
|
|
|
bool AddedChain = HasChain && !NodeHasChain;
|
2006-02-05 06:43:12 +00:00
|
|
|
if (NodeHasChain) {
|
2006-02-09 22:12:27 +00:00
|
|
|
emitCode("SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, " +
|
|
|
|
utostr(ValNo) + ", ResNode, " + utostr(ValNo) + ");");
|
2006-02-05 06:43:12 +00:00
|
|
|
if (DoReplace)
|
2006-02-09 22:12:27 +00:00
|
|
|
emitCode("if (N.ResNo == 0) AddHandleReplacement(N.Val, "
|
|
|
|
+ utostr(ValNo) + ", " + "ResNode, " + utostr(ValNo) + ");");
|
2006-02-05 06:43:12 +00:00
|
|
|
ValNo++;
|
|
|
|
}
|
|
|
|
|
2005-12-20 07:37:41 +00:00
|
|
|
|
2005-12-22 02:24:50 +00:00
|
|
|
if (FoldedChains.size() > 0) {
|
2006-01-28 20:31:24 +00:00
|
|
|
std::string Code;
|
2005-12-19 07:18:51 +00:00
|
|
|
for (unsigned j = 0, e = FoldedChains.size(); j < e; j++)
|
2006-02-09 22:12:27 +00:00
|
|
|
emitCode("SelectionDAG::InsertISelMapEntry(CodeGenMap, " +
|
|
|
|
FoldedChains[j].first + ".Val, " +
|
|
|
|
utostr(FoldedChains[j].second) + ", ResNode, " +
|
|
|
|
utostr(ValNo) + ");");
|
2006-02-05 06:43:12 +00:00
|
|
|
|
|
|
|
for (unsigned j = 0, e = FoldedChains.size(); j < e; j++) {
|
|
|
|
std::string Code =
|
2006-02-09 22:12:27 +00:00
|
|
|
FoldedChains[j].first + ".Val, " +
|
|
|
|
utostr(FoldedChains[j].second) + ", ";
|
|
|
|
emitCode("AddHandleReplacement(" + Code + "ResNode, " +
|
|
|
|
utostr(ValNo) + ");");
|
2006-02-05 06:43:12 +00:00
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2005-12-19 22:40:04 +00:00
|
|
|
|
2006-01-26 00:22:25 +00:00
|
|
|
if (NodeHasOutFlag)
|
2006-02-09 22:12:27 +00:00
|
|
|
emitCode("SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, " +
|
|
|
|
utostr(ValNo) + ", InFlag.Val, InFlag.ResNo);");
|
2005-12-22 02:24:50 +00:00
|
|
|
|
2006-01-26 00:22:25 +00:00
|
|
|
if (AddedChain && NodeHasOutFlag) {
|
2006-01-19 21:57:10 +00:00
|
|
|
if (NumExpectedResults == 0) {
|
2006-02-09 07:16:09 +00:00
|
|
|
emitCode("Result = SDOperand(ResNode, N.ResNo+1);");
|
2005-12-22 02:24:50 +00:00
|
|
|
} else {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("if (N.ResNo < " + utostr(NumExpectedResults) + ")");
|
2006-02-09 07:16:09 +00:00
|
|
|
emitCode(" Result = SDOperand(ResNode, N.ResNo);");
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("else");
|
2006-02-09 07:16:09 +00:00
|
|
|
emitCode(" Result = SDOperand(ResNode, N.ResNo+1);");
|
2005-12-22 02:24:50 +00:00
|
|
|
}
|
2005-12-20 07:37:41 +00:00
|
|
|
} else {
|
2006-02-09 07:16:09 +00:00
|
|
|
emitCode("Result = SDOperand(ResNode, N.ResNo);");
|
2005-12-20 07:37:41 +00:00
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
} else {
|
|
|
|
// If this instruction is the root, and if there is only one use of it,
|
|
|
|
// use SelectNodeTo instead of getTargetNode to avoid an allocation.
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("if (N.Val->hasOneUse()) {");
|
2006-02-09 00:37:58 +00:00
|
|
|
std::string Code = " Result = CurDAG->SelectNodeTo(N.Val, " +
|
2006-01-28 20:31:24 +00:00
|
|
|
II.Namespace + "::" + II.TheDef->getName();
|
2005-12-30 00:12:56 +00:00
|
|
|
if (N->getTypeNum(0) != MVT::isVoid)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::" + getEnumName(N->getTypeNum(0));
|
2006-01-26 00:22:25 +00:00
|
|
|
if (NodeHasOutFlag)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::Flag";
|
2005-12-09 22:45:35 +00:00
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", Tmp" + utostr(Ops[i]);
|
2006-01-09 18:27:06 +00:00
|
|
|
if (HasInFlag || HasImpInputs)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", InFlag";
|
|
|
|
emitCode(Code + ");");
|
|
|
|
emitCode("} else {");
|
2006-02-09 07:16:09 +00:00
|
|
|
emitDecl("ResNode", true);
|
|
|
|
Code = " ResNode = CurDAG->getTargetNode(" +
|
2006-01-28 20:31:24 +00:00
|
|
|
II.Namespace + "::" + II.TheDef->getName();
|
2005-12-30 00:12:56 +00:00
|
|
|
if (N->getTypeNum(0) != MVT::isVoid)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::" + getEnumName(N->getTypeNum(0));
|
2006-01-26 00:22:25 +00:00
|
|
|
if (NodeHasOutFlag)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", MVT::Flag";
|
2005-12-09 22:45:35 +00:00
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", Tmp" + utostr(Ops[i]);
|
2006-01-09 18:27:06 +00:00
|
|
|
if (HasInFlag || HasImpInputs)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += ", InFlag";
|
|
|
|
emitCode(Code + ");");
|
2006-02-09 22:12:27 +00:00
|
|
|
emitCode(" SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, "
|
|
|
|
"ResNode, 0);");
|
|
|
|
emitCode(" Result = SDOperand(ResNode, 0);");
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("}");
|
2005-12-04 08:18:16 +00:00
|
|
|
}
|
2005-12-20 07:37:41 +00:00
|
|
|
|
2006-02-09 00:37:58 +00:00
|
|
|
if (isRoot)
|
|
|
|
emitCode("return;");
|
2005-12-09 22:45:35 +00:00
|
|
|
return std::make_pair(1, ResNo);
|
|
|
|
} else if (Op->isSubClassOf("SDNodeXForm")) {
|
|
|
|
assert(N->getNumChildren() == 1 && "node xform should have one child!");
|
2005-12-14 22:02:59 +00:00
|
|
|
unsigned OpVal = EmitResultCode(N->getChild(0)).second;
|
2005-12-09 22:45:35 +00:00
|
|
|
unsigned ResNo = TmpNo++;
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Tmp" + utostr(ResNo));
|
|
|
|
emitCode("Tmp" + utostr(ResNo) + " = Transform_" + Op->getName()
|
2006-01-28 20:31:24 +00:00
|
|
|
+ "(Tmp" + utostr(OpVal) + ".Val);");
|
2005-12-09 22:45:35 +00:00
|
|
|
if (isRoot) {
|
2006-02-09 22:12:27 +00:00
|
|
|
emitCode("SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val,"
|
|
|
|
"N.ResNo, Tmp" + utostr(ResNo) + ".Val, Tmp" +
|
|
|
|
utostr(ResNo) + ".ResNo);");
|
2006-02-09 00:37:58 +00:00
|
|
|
emitCode("Result = Tmp" + utostr(ResNo) + ";");
|
|
|
|
emitCode("return;");
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
|
|
|
return std::make_pair(1, ResNo);
|
|
|
|
} else {
|
|
|
|
N->dump();
|
2006-01-11 01:33:49 +00:00
|
|
|
std::cerr << "\n";
|
|
|
|
throw std::string("Unknown node in result pattern!");
|
2005-10-16 01:41:58 +00:00
|
|
|
}
|
2005-09-24 00:40:24 +00:00
|
|
|
}
|
|
|
|
|
2006-01-28 19:06:51 +00:00
|
|
|
/// InsertOneTypeCheck - Insert a type-check for an unresolved type in 'Pat'
|
|
|
|
/// and add it to the tree. 'Pat' and 'Other' are isomorphic trees except that
|
2005-12-09 22:45:35 +00:00
|
|
|
/// 'Pat' may be missing types. If we find an unresolved type to add a check
|
|
|
|
/// for, this returns true otherwise false if Pat has all types.
|
|
|
|
bool InsertOneTypeCheck(TreePatternNode *Pat, TreePatternNode *Other,
|
|
|
|
const std::string &Prefix) {
|
|
|
|
// Did we find one?
|
|
|
|
if (!Pat->hasTypeSet()) {
|
|
|
|
// Move a type over from 'other' to 'pat'.
|
2005-12-30 00:12:56 +00:00
|
|
|
Pat->setTypes(Other->getExtTypes());
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck(Prefix + ".Val->getValueType(0) == MVT::" +
|
2006-01-28 20:31:24 +00:00
|
|
|
getName(Pat->getTypeNum(0)));
|
2005-12-09 22:45:35 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2006-01-09 18:27:06 +00:00
|
|
|
unsigned OpNo =
|
|
|
|
(unsigned) NodeHasProperty(Pat, SDNodeInfo::SDNPHasChain, ISE);
|
2005-12-09 22:45:35 +00:00
|
|
|
for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i, ++OpNo)
|
|
|
|
if (InsertOneTypeCheck(Pat->getChild(i), Other->getChild(i),
|
|
|
|
Prefix + utostr(OpNo)))
|
|
|
|
return true;
|
2005-10-15 21:34:21 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
private:
|
2006-01-26 00:22:25 +00:00
|
|
|
/// EmitInFlagSelectCode - Emit the flag operands for the DAG that is
|
2005-12-09 22:45:35 +00:00
|
|
|
/// being built.
|
2006-01-26 00:22:25 +00:00
|
|
|
void EmitInFlagSelectCode(TreePatternNode *N, const std::string &RootName,
|
|
|
|
bool &ChainEmitted, bool isRoot = false) {
|
2005-12-09 22:45:35 +00:00
|
|
|
const CodeGenTarget &T = ISE.getTargetInfo();
|
2006-01-09 18:27:06 +00:00
|
|
|
unsigned OpNo =
|
|
|
|
(unsigned) NodeHasProperty(N, SDNodeInfo::SDNPHasChain, ISE);
|
2006-01-26 00:22:25 +00:00
|
|
|
bool HasInFlag = NodeHasProperty(N, SDNodeInfo::SDNPInFlag, ISE);
|
|
|
|
bool HasOptInFlag = NodeHasProperty(N, SDNodeInfo::SDNPOptInFlag, ISE);
|
2005-12-09 22:45:35 +00:00
|
|
|
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i, ++OpNo) {
|
|
|
|
TreePatternNode *Child = N->getChild(i);
|
|
|
|
if (!Child->isLeaf()) {
|
2006-01-26 00:22:25 +00:00
|
|
|
EmitInFlagSelectCode(Child, RootName + utostr(OpNo), ChainEmitted);
|
2005-12-09 22:45:35 +00:00
|
|
|
} else {
|
|
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) {
|
2006-01-19 01:55:45 +00:00
|
|
|
if (!Child->getName().empty()) {
|
|
|
|
std::string Name = RootName + utostr(OpNo);
|
|
|
|
if (Duplicates.find(Name) != Duplicates.end())
|
|
|
|
// A duplicate! Do not emit a copy for this node.
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
Record *RR = DI->getDef();
|
|
|
|
if (RR->isSubClassOf("Register")) {
|
|
|
|
MVT::ValueType RVT = getRegisterValueType(RR, T);
|
2005-12-17 01:19:28 +00:00
|
|
|
if (RVT == MVT::Flag) {
|
2006-02-09 00:37:58 +00:00
|
|
|
emitCode("Select(InFlag, " + RootName + utostr(OpNo) + ");");
|
2006-01-11 22:16:13 +00:00
|
|
|
} else {
|
|
|
|
if (!ChainEmitted) {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Chain");
|
|
|
|
emitCode("Chain = CurDAG->getEntryNode();");
|
2006-02-03 06:22:41 +00:00
|
|
|
ChainName = "Chain";
|
2006-01-11 22:16:13 +00:00
|
|
|
ChainEmitted = true;
|
|
|
|
}
|
2006-02-09 00:37:58 +00:00
|
|
|
emitCode("Select(" + RootName + utostr(OpNo) + ", " +
|
|
|
|
RootName + utostr(OpNo) + ");");
|
2006-02-09 22:12:27 +00:00
|
|
|
emitCode("ResNode = CurDAG->getCopyToReg(" + ChainName +
|
2006-02-03 06:22:41 +00:00
|
|
|
", CurDAG->getRegister(" + ISE.getQualifiedName(RR) +
|
2006-02-09 00:37:58 +00:00
|
|
|
", MVT::" + getEnumName(RVT) + "), " +
|
2006-02-09 07:16:09 +00:00
|
|
|
RootName + utostr(OpNo) + ", InFlag).Val;");
|
2006-02-09 22:12:27 +00:00
|
|
|
emitCode(ChainName + " = SDOperand(ResNode, 0);");
|
|
|
|
emitCode("InFlag = SDOperand(ResNode, 1);");
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-01-26 00:22:25 +00:00
|
|
|
|
|
|
|
if (HasInFlag || HasOptInFlag) {
|
2006-01-28 20:31:24 +00:00
|
|
|
std::string Code;
|
2006-01-26 00:22:25 +00:00
|
|
|
if (HasOptInFlag) {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("if (" + RootName + ".getNumOperands() == " + utostr(OpNo+1) +
|
|
|
|
") {");
|
|
|
|
Code = " ";
|
2006-01-26 00:22:25 +00:00
|
|
|
}
|
2006-02-09 00:37:58 +00:00
|
|
|
emitCode(Code + "Select(InFlag, " + RootName +
|
|
|
|
".getOperand(" + utostr(OpNo) + "));");
|
2006-01-26 00:22:25 +00:00
|
|
|
if (HasOptInFlag) {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode(" HasOptInFlag = true;");
|
|
|
|
emitCode("}");
|
2006-01-26 00:22:25 +00:00
|
|
|
}
|
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2005-12-20 07:37:41 +00:00
|
|
|
|
|
|
|
/// EmitCopyFromRegs - Emit code to copy result to physical registers
|
2005-12-23 22:11:47 +00:00
|
|
|
/// as specified by the instruction. It returns true if any copy is
|
|
|
|
/// emitted.
|
2006-01-11 22:16:13 +00:00
|
|
|
bool EmitCopyFromRegs(TreePatternNode *N, bool &ChainEmitted) {
|
2005-12-23 22:11:47 +00:00
|
|
|
bool RetVal = false;
|
2005-12-20 07:37:41 +00:00
|
|
|
Record *Op = N->getOperator();
|
|
|
|
if (Op->isSubClassOf("Instruction")) {
|
|
|
|
const DAGInstruction &Inst = ISE.getInstruction(Op);
|
|
|
|
const CodeGenTarget &CGT = ISE.getTargetInfo();
|
|
|
|
CodeGenInstruction &II = CGT.getInstruction(Op->getName());
|
|
|
|
unsigned NumImpResults = Inst.getNumImpResults();
|
|
|
|
for (unsigned i = 0; i < NumImpResults; i++) {
|
|
|
|
Record *RR = Inst.getImpResult(i);
|
|
|
|
if (RR->isSubClassOf("Register")) {
|
|
|
|
MVT::ValueType RVT = getRegisterValueType(RR, CGT);
|
|
|
|
if (RVT != MVT::Flag) {
|
2006-01-11 22:16:13 +00:00
|
|
|
if (!ChainEmitted) {
|
2006-02-07 00:37:41 +00:00
|
|
|
emitDecl("Chain");
|
|
|
|
emitCode("Chain = CurDAG->getEntryNode();");
|
2006-01-11 22:16:13 +00:00
|
|
|
ChainEmitted = true;
|
2006-02-03 06:22:41 +00:00
|
|
|
ChainName = "Chain";
|
2005-12-20 07:37:41 +00:00
|
|
|
}
|
2006-02-09 07:16:09 +00:00
|
|
|
emitCode("ResNode = CurDAG->getCopyFromReg(" + ChainName + ", " +
|
2006-01-28 20:31:24 +00:00
|
|
|
ISE.getQualifiedName(RR) + ", MVT::" + getEnumName(RVT) +
|
2006-02-09 07:16:09 +00:00
|
|
|
", InFlag).Val;");
|
|
|
|
emitCode(ChainName + " = SDOperand(ResNode, 1);");
|
|
|
|
emitCode("InFlag = SDOperand(ResNode, 2);");
|
2005-12-23 22:11:47 +00:00
|
|
|
RetVal = true;
|
2005-12-20 07:37:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-12-23 22:11:47 +00:00
|
|
|
return RetVal;
|
2005-12-20 07:37:41 +00:00
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
};
|
2005-11-02 06:49:14 +00:00
|
|
|
|
2005-09-23 21:33:23 +00:00
|
|
|
/// EmitCodeForPattern - Given a pattern to match, emit code to the specified
|
|
|
|
/// stream to match the pattern, and generate the code for the match if it
|
2006-01-29 02:43:35 +00:00
|
|
|
/// succeeds. Returns true if the pattern is not guaranteed to match.
|
2006-01-29 04:25:26 +00:00
|
|
|
void DAGISelEmitter::GenerateCodeForPattern(PatternToMatch &Pattern,
|
2006-02-05 06:43:12 +00:00
|
|
|
std::vector<std::pair<bool, std::string> > &GeneratedCode,
|
2006-02-09 07:16:09 +00:00
|
|
|
std::set<std::pair<bool, std::string> > &GeneratedDecl,
|
2006-02-05 06:43:12 +00:00
|
|
|
bool DoReplace) {
|
2005-12-14 22:02:59 +00:00
|
|
|
PatternCodeEmitter Emitter(*this, Pattern.getPredicates(),
|
|
|
|
Pattern.getSrcPattern(), Pattern.getDstPattern(),
|
2006-02-07 00:37:41 +00:00
|
|
|
GeneratedCode, GeneratedDecl, DoReplace);
|
2005-12-09 22:45:35 +00:00
|
|
|
|
2005-09-23 23:16:51 +00:00
|
|
|
// Emit the matcher, capturing named arguments in VariableMap.
|
2005-12-23 22:11:47 +00:00
|
|
|
bool FoundChain = false;
|
2006-02-05 06:43:12 +00:00
|
|
|
Emitter.EmitMatchCode(Pattern.getSrcPattern(), NULL, "N", "", "", FoundChain);
|
2005-12-09 22:45:35 +00:00
|
|
|
|
2005-10-14 04:11:13 +00:00
|
|
|
// TP - Get *SOME* tree pattern, we don't care which.
|
|
|
|
TreePattern &TP = *PatternFragments.begin()->second;
|
|
|
|
|
|
|
|
// At this point, we know that we structurally match the pattern, but the
|
|
|
|
// types of the nodes may not match. Figure out the fewest number of type
|
|
|
|
// comparisons we need to emit. For example, if there is only one integer
|
|
|
|
// type supported by a target, there should be no type comparisons at all for
|
|
|
|
// integer patterns!
|
|
|
|
//
|
|
|
|
// To figure out the fewest number of type checks needed, clone the pattern,
|
|
|
|
// remove the types, then perform type inference on the pattern as a whole.
|
|
|
|
// If there are unresolved types, emit an explicit check for those types,
|
|
|
|
// apply the type to the tree, then rerun type inference. Iterate until all
|
|
|
|
// types are resolved.
|
|
|
|
//
|
2005-12-14 22:02:59 +00:00
|
|
|
TreePatternNode *Pat = Pattern.getSrcPattern()->clone();
|
2005-10-14 04:11:13 +00:00
|
|
|
RemoveAllTypes(Pat);
|
|
|
|
|
2005-10-15 21:34:21 +00:00
|
|
|
do {
|
|
|
|
// Resolve/propagate as many types as possible.
|
|
|
|
try {
|
|
|
|
bool MadeChange = true;
|
|
|
|
while (MadeChange)
|
2006-01-28 19:06:51 +00:00
|
|
|
MadeChange = Pat->ApplyTypeConstraints(TP,
|
|
|
|
true/*Ignore reg constraints*/);
|
2005-10-15 21:34:21 +00:00
|
|
|
} catch (...) {
|
|
|
|
assert(0 && "Error: could not find consistent types for something we"
|
|
|
|
" already decided was ok!");
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Insert a check for an unresolved type and add it to the tree. If we find
|
|
|
|
// an unresolved type to add a check for, this returns true and we iterate,
|
|
|
|
// otherwise we are done.
|
2005-12-14 22:02:59 +00:00
|
|
|
} while (Emitter.InsertOneTypeCheck(Pat, Pattern.getSrcPattern(), "N"));
|
2005-12-09 22:45:35 +00:00
|
|
|
|
2005-12-14 22:02:59 +00:00
|
|
|
Emitter.EmitResultCode(Pattern.getDstPattern(), true /*the root*/);
|
2005-10-14 04:11:13 +00:00
|
|
|
delete Pat;
|
2005-09-23 20:52:47 +00:00
|
|
|
}
|
|
|
|
|
2006-01-29 04:41:05 +00:00
|
|
|
/// EraseCodeLine - Erase one code line from all of the patterns. If removing
|
|
|
|
/// a line causes any of them to be empty, remove them and return true when
|
|
|
|
/// done.
|
|
|
|
static bool EraseCodeLine(std::vector<std::pair<PatternToMatch*,
|
|
|
|
std::vector<std::pair<bool, std::string> > > >
|
|
|
|
&Patterns) {
|
|
|
|
bool ErasedPatterns = false;
|
|
|
|
for (unsigned i = 0, e = Patterns.size(); i != e; ++i) {
|
|
|
|
Patterns[i].second.pop_back();
|
|
|
|
if (Patterns[i].second.empty()) {
|
|
|
|
Patterns.erase(Patterns.begin()+i);
|
|
|
|
--i; --e;
|
|
|
|
ErasedPatterns = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ErasedPatterns;
|
|
|
|
}
|
|
|
|
|
2006-01-29 04:25:26 +00:00
|
|
|
/// EmitPatterns - Emit code for at least one pattern, but try to group common
|
|
|
|
/// code together between the patterns.
|
|
|
|
void DAGISelEmitter::EmitPatterns(std::vector<std::pair<PatternToMatch*,
|
|
|
|
std::vector<std::pair<bool, std::string> > > >
|
|
|
|
&Patterns, unsigned Indent,
|
|
|
|
std::ostream &OS) {
|
|
|
|
typedef std::pair<bool, std::string> CodeLine;
|
|
|
|
typedef std::vector<CodeLine> CodeList;
|
|
|
|
typedef std::vector<std::pair<PatternToMatch*, CodeList> > PatternList;
|
|
|
|
|
|
|
|
if (Patterns.empty()) return;
|
|
|
|
|
2006-01-29 04:41:05 +00:00
|
|
|
// Figure out how many patterns share the next code line. Explicitly copy
|
|
|
|
// FirstCodeLine so that we don't invalidate a reference when changing
|
|
|
|
// Patterns.
|
|
|
|
const CodeLine FirstCodeLine = Patterns.back().second.back();
|
2006-01-29 04:25:26 +00:00
|
|
|
unsigned LastMatch = Patterns.size()-1;
|
|
|
|
while (LastMatch != 0 && Patterns[LastMatch-1].second.back() == FirstCodeLine)
|
|
|
|
--LastMatch;
|
|
|
|
|
|
|
|
// If not all patterns share this line, split the list into two pieces. The
|
|
|
|
// first chunk will use this line, the second chunk won't.
|
|
|
|
if (LastMatch != 0) {
|
|
|
|
PatternList Shared(Patterns.begin()+LastMatch, Patterns.end());
|
|
|
|
PatternList Other(Patterns.begin(), Patterns.begin()+LastMatch);
|
|
|
|
|
|
|
|
// FIXME: Emit braces?
|
|
|
|
if (Shared.size() == 1) {
|
|
|
|
PatternToMatch &Pattern = *Shared.back().first;
|
|
|
|
OS << "\n" << std::string(Indent, ' ') << "// Pattern: ";
|
|
|
|
Pattern.getSrcPattern()->print(OS);
|
|
|
|
OS << "\n" << std::string(Indent, ' ') << "// Emits: ";
|
|
|
|
Pattern.getDstPattern()->print(OS);
|
|
|
|
OS << "\n";
|
|
|
|
OS << std::string(Indent, ' ') << "// Pattern complexity = "
|
|
|
|
<< getPatternSize(Pattern.getSrcPattern(), *this) << " cost = "
|
|
|
|
<< getResultPatternCost(Pattern.getDstPattern()) << "\n";
|
|
|
|
}
|
|
|
|
if (!FirstCodeLine.first) {
|
|
|
|
OS << std::string(Indent, ' ') << "{\n";
|
|
|
|
Indent += 2;
|
|
|
|
}
|
|
|
|
EmitPatterns(Shared, Indent, OS);
|
|
|
|
if (!FirstCodeLine.first) {
|
|
|
|
Indent -= 2;
|
|
|
|
OS << std::string(Indent, ' ') << "}\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Other.size() == 1) {
|
|
|
|
PatternToMatch &Pattern = *Other.back().first;
|
|
|
|
OS << "\n" << std::string(Indent, ' ') << "// Pattern: ";
|
|
|
|
Pattern.getSrcPattern()->print(OS);
|
|
|
|
OS << "\n" << std::string(Indent, ' ') << "// Emits: ";
|
|
|
|
Pattern.getDstPattern()->print(OS);
|
|
|
|
OS << "\n";
|
|
|
|
OS << std::string(Indent, ' ') << "// Pattern complexity = "
|
|
|
|
<< getPatternSize(Pattern.getSrcPattern(), *this) << " cost = "
|
|
|
|
<< getResultPatternCost(Pattern.getDstPattern()) << "\n";
|
|
|
|
}
|
|
|
|
EmitPatterns(Other, Indent, OS);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-01-29 04:41:05 +00:00
|
|
|
// Remove this code from all of the patterns that share it.
|
|
|
|
bool ErasedPatterns = EraseCodeLine(Patterns);
|
|
|
|
|
2006-01-29 04:25:26 +00:00
|
|
|
bool isPredicate = FirstCodeLine.first;
|
|
|
|
|
|
|
|
// Otherwise, every pattern in the list has this line. Emit it.
|
|
|
|
if (!isPredicate) {
|
|
|
|
// Normal code.
|
|
|
|
OS << std::string(Indent, ' ') << FirstCodeLine.second << "\n";
|
|
|
|
} else {
|
2006-01-29 04:41:05 +00:00
|
|
|
OS << std::string(Indent, ' ') << "if (" << FirstCodeLine.second;
|
|
|
|
|
|
|
|
// If the next code line is another predicate, and if all of the pattern
|
|
|
|
// in this group share the same next line, emit it inline now. Do this
|
|
|
|
// until we run out of common predicates.
|
|
|
|
while (!ErasedPatterns && Patterns.back().second.back().first) {
|
|
|
|
// Check that all of fhe patterns in Patterns end with the same predicate.
|
|
|
|
bool AllEndWithSamePredicate = true;
|
|
|
|
for (unsigned i = 0, e = Patterns.size(); i != e; ++i)
|
|
|
|
if (Patterns[i].second.back() != Patterns.back().second.back()) {
|
|
|
|
AllEndWithSamePredicate = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// If all of the predicates aren't the same, we can't share them.
|
|
|
|
if (!AllEndWithSamePredicate) break;
|
|
|
|
|
|
|
|
// Otherwise we can. Emit it shared now.
|
|
|
|
OS << " &&\n" << std::string(Indent+4, ' ')
|
|
|
|
<< Patterns.back().second.back().second;
|
|
|
|
ErasedPatterns = EraseCodeLine(Patterns);
|
2006-01-29 04:25:26 +00:00
|
|
|
}
|
2006-01-29 04:41:05 +00:00
|
|
|
|
|
|
|
OS << ") {\n";
|
|
|
|
Indent += 2;
|
2006-01-29 04:25:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EmitPatterns(Patterns, Indent, OS);
|
|
|
|
|
|
|
|
if (isPredicate)
|
|
|
|
OS << std::string(Indent-2, ' ') << "}\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-09-26 21:59:35 +00:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
/// CompareByRecordName - An ordering predicate that implements less-than by
|
|
|
|
/// comparing the names records.
|
|
|
|
struct CompareByRecordName {
|
|
|
|
bool operator()(const Record *LHS, const Record *RHS) const {
|
|
|
|
// Sort by name first.
|
|
|
|
if (LHS->getName() < RHS->getName()) return true;
|
|
|
|
// If both names are equal, sort by pointer.
|
|
|
|
return LHS->getName() == RHS->getName() && LHS < RHS;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
void DAGISelEmitter::EmitInstructionSelector(std::ostream &OS) {
|
2005-10-18 04:41:01 +00:00
|
|
|
std::string InstNS = Target.inst_begin()->second.Namespace;
|
|
|
|
if (!InstNS.empty()) InstNS += "::";
|
|
|
|
|
2006-01-04 00:25:00 +00:00
|
|
|
// Group the patterns by their top-level opcodes.
|
|
|
|
std::map<Record*, std::vector<PatternToMatch*>,
|
|
|
|
CompareByRecordName> PatternsByOpcode;
|
|
|
|
for (unsigned i = 0, e = PatternsToMatch.size(); i != e; ++i) {
|
|
|
|
TreePatternNode *Node = PatternsToMatch[i].getSrcPattern();
|
|
|
|
if (!Node->isLeaf()) {
|
|
|
|
PatternsByOpcode[Node->getOperator()].push_back(&PatternsToMatch[i]);
|
|
|
|
} else {
|
|
|
|
const ComplexPattern *CP;
|
|
|
|
if (IntInit *II =
|
|
|
|
dynamic_cast<IntInit*>(Node->getLeafValue())) {
|
|
|
|
PatternsByOpcode[getSDNodeNamed("imm")].push_back(&PatternsToMatch[i]);
|
|
|
|
} else if ((CP = NodeGetComplexPattern(Node, *this))) {
|
|
|
|
std::vector<Record*> OpNodes = CP->getRootNodes();
|
|
|
|
for (unsigned j = 0, e = OpNodes.size(); j != e; j++) {
|
2006-01-28 19:06:51 +00:00
|
|
|
PatternsByOpcode[OpNodes[j]]
|
|
|
|
.insert(PatternsByOpcode[OpNodes[j]].begin(), &PatternsToMatch[i]);
|
2006-01-04 00:25:00 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
std::cerr << "Unrecognized opcode '";
|
|
|
|
Node->dump();
|
|
|
|
std::cerr << "' on tree pattern '";
|
2006-01-28 19:06:51 +00:00
|
|
|
std::cerr <<
|
|
|
|
PatternsToMatch[i].getDstPattern()->getOperator()->getName();
|
2006-01-04 00:25:00 +00:00
|
|
|
std::cerr << "'!\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Emit one Select_* method for each top-level opcode. We do this instead of
|
|
|
|
// emitting one giant switch statement to support compilers where this will
|
|
|
|
// result in the recursive functions taking less stack space.
|
|
|
|
for (std::map<Record*, std::vector<PatternToMatch*>,
|
|
|
|
CompareByRecordName>::iterator PBOI = PatternsByOpcode.begin(),
|
|
|
|
E = PatternsByOpcode.end(); PBOI != E; ++PBOI) {
|
2006-02-05 06:43:12 +00:00
|
|
|
const std::string &OpName = PBOI->first->getName();
|
2006-02-09 00:37:58 +00:00
|
|
|
OS << "void Select_" << OpName << "(SDOperand &Result, SDOperand N) {\n";
|
2006-01-04 00:25:00 +00:00
|
|
|
|
|
|
|
const SDNodeInfo &OpcodeInfo = getSDNodeInfo(PBOI->first);
|
2006-02-05 06:43:12 +00:00
|
|
|
bool OptSlctOrder =
|
|
|
|
(OpcodeInfo.hasProperty(SDNodeInfo::SDNPHasChain) &&
|
|
|
|
OpcodeInfo.getNumResults() > 0);
|
|
|
|
|
|
|
|
if (OptSlctOrder) {
|
|
|
|
OS << " if (N.ResNo == " << OpcodeInfo.getNumResults()
|
|
|
|
<< " && N.getValue(0).hasOneUse()) {\n"
|
|
|
|
<< " SDOperand Dummy = "
|
|
|
|
<< "CurDAG->getNode(ISD::HANDLENODE, MVT::Other, N);\n"
|
2006-02-09 22:12:27 +00:00
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, "
|
|
|
|
<< OpcodeInfo.getNumResults() << ", Dummy.Val, 0);\n"
|
|
|
|
<< " SelectionDAG::InsertISelMapEntry(HandleMap, N.Val, "
|
|
|
|
<< OpcodeInfo.getNumResults() << ", Dummy.Val, 0);\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " Result = Dummy;\n"
|
|
|
|
<< " return;\n"
|
2006-02-05 06:43:12 +00:00
|
|
|
<< " }\n";
|
|
|
|
}
|
|
|
|
|
2006-01-04 00:25:00 +00:00
|
|
|
std::vector<PatternToMatch*> &Patterns = PBOI->second;
|
2006-01-29 02:43:35 +00:00
|
|
|
assert(!Patterns.empty() && "No patterns but map has entry?");
|
2006-01-04 00:25:00 +00:00
|
|
|
|
|
|
|
// We want to emit all of the matching code now. However, we want to emit
|
|
|
|
// the matches in order of minimal cost. Sort the patterns so the least
|
|
|
|
// cost one is at the start.
|
|
|
|
std::stable_sort(Patterns.begin(), Patterns.end(),
|
|
|
|
PatternSortingPredicate(*this));
|
2006-02-07 00:37:41 +00:00
|
|
|
|
2006-01-29 02:57:39 +00:00
|
|
|
typedef std::vector<std::pair<bool, std::string> > CodeList;
|
2006-02-07 00:37:41 +00:00
|
|
|
typedef std::set<std::string> DeclSet;
|
2006-01-29 02:57:39 +00:00
|
|
|
|
|
|
|
std::vector<std::pair<PatternToMatch*, CodeList> > CodeForPatterns;
|
2006-02-09 07:16:09 +00:00
|
|
|
std::set<std::pair<bool, std::string> > GeneratedDecl;
|
2006-01-27 22:22:28 +00:00
|
|
|
for (unsigned i = 0, e = Patterns.size(); i != e; ++i) {
|
2006-01-29 02:57:39 +00:00
|
|
|
CodeList GeneratedCode;
|
2006-02-07 00:37:41 +00:00
|
|
|
GenerateCodeForPattern(*Patterns[i], GeneratedCode, GeneratedDecl,
|
|
|
|
OptSlctOrder);
|
2006-01-29 02:57:39 +00:00
|
|
|
CodeForPatterns.push_back(std::make_pair(Patterns[i], GeneratedCode));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Scan the code to see if all of the patterns are reachable and if it is
|
|
|
|
// possible that the last one might not match.
|
|
|
|
bool mightNotMatch = true;
|
|
|
|
for (unsigned i = 0, e = CodeForPatterns.size(); i != e; ++i) {
|
|
|
|
CodeList &GeneratedCode = CodeForPatterns[i].second;
|
|
|
|
mightNotMatch = false;
|
2006-01-29 02:43:35 +00:00
|
|
|
|
2006-01-29 02:57:39 +00:00
|
|
|
for (unsigned j = 0, e = GeneratedCode.size(); j != e; ++j) {
|
|
|
|
if (GeneratedCode[j].first) { // predicate.
|
|
|
|
mightNotMatch = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-01-29 02:43:35 +00:00
|
|
|
|
2006-01-29 02:57:39 +00:00
|
|
|
// If this pattern definitely matches, and if it isn't the last one, the
|
|
|
|
// patterns after it CANNOT ever match. Error out.
|
|
|
|
if (mightNotMatch == false && i != CodeForPatterns.size()-1) {
|
|
|
|
std::cerr << "Pattern '";
|
|
|
|
CodeForPatterns[i+1].first->getSrcPattern()->print(OS);
|
|
|
|
std::cerr << "' is impossible to select!\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
2006-02-07 00:37:41 +00:00
|
|
|
|
|
|
|
// Print all declarations.
|
2006-02-09 07:16:09 +00:00
|
|
|
for (std::set<std::pair<bool, std::string> >::iterator I = GeneratedDecl.begin(),
|
2006-02-07 00:37:41 +00:00
|
|
|
E = GeneratedDecl.end(); I != E; ++I)
|
2006-02-09 07:16:09 +00:00
|
|
|
if (I->first)
|
|
|
|
OS << " SDNode *" << I->second << ";\n";
|
|
|
|
else
|
|
|
|
OS << " SDOperand " << I->second << "(0, 0);\n";
|
2006-02-07 00:37:41 +00:00
|
|
|
|
2006-01-29 04:25:26 +00:00
|
|
|
// Loop through and reverse all of the CodeList vectors, as we will be
|
|
|
|
// accessing them from their logical front, but accessing the end of a
|
|
|
|
// vector is more efficient.
|
2006-01-29 02:57:39 +00:00
|
|
|
for (unsigned i = 0, e = CodeForPatterns.size(); i != e; ++i) {
|
|
|
|
CodeList &GeneratedCode = CodeForPatterns[i].second;
|
2006-01-29 04:25:26 +00:00
|
|
|
std::reverse(GeneratedCode.begin(), GeneratedCode.end());
|
2006-01-27 22:22:28 +00:00
|
|
|
}
|
2006-01-04 00:25:00 +00:00
|
|
|
|
2006-01-29 04:25:26 +00:00
|
|
|
// Next, reverse the list of patterns itself for the same reason.
|
|
|
|
std::reverse(CodeForPatterns.begin(), CodeForPatterns.end());
|
|
|
|
|
|
|
|
// Emit all of the patterns now, grouped together to share code.
|
|
|
|
EmitPatterns(CodeForPatterns, 2, OS);
|
|
|
|
|
2006-01-29 02:57:39 +00:00
|
|
|
// If the last pattern has predicates (which could fail) emit code to catch
|
|
|
|
// the case where nothing handles a pattern.
|
2006-01-29 02:43:35 +00:00
|
|
|
if (mightNotMatch)
|
2006-01-27 22:22:28 +00:00
|
|
|
OS << " std::cerr << \"Cannot yet select: \";\n"
|
|
|
|
<< " N.Val->dump(CurDAG);\n"
|
|
|
|
<< " std::cerr << '\\n';\n"
|
|
|
|
<< " abort();\n";
|
|
|
|
|
|
|
|
OS << "}\n\n";
|
2006-01-04 00:25:00 +00:00
|
|
|
}
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
// Emit boilerplate.
|
2006-02-09 00:37:58 +00:00
|
|
|
OS << "void Select_INLINEASM(SDOperand& Result, SDOperand N) {\n"
|
2006-01-26 23:08:55 +00:00
|
|
|
<< " std::vector<SDOperand> Ops(N.Val->op_begin(), N.Val->op_end());\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " Select(Ops[0], N.getOperand(0)); // Select the chain.\n\n"
|
2006-01-26 23:08:55 +00:00
|
|
|
<< " // Select the flag operand.\n"
|
|
|
|
<< " if (Ops.back().getValueType() == MVT::Flag)\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " Select(Ops.back(), Ops.back());\n"
|
2006-01-26 23:08:55 +00:00
|
|
|
<< " std::vector<MVT::ValueType> VTs;\n"
|
|
|
|
<< " VTs.push_back(MVT::Other);\n"
|
|
|
|
<< " VTs.push_back(MVT::Flag);\n"
|
|
|
|
<< " SDOperand New = CurDAG->getNode(ISD::INLINEASM, VTs, Ops);\n"
|
2006-02-09 22:12:27 +00:00
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, New.Val, 0);\n"
|
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, New.Val, 1);\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " Result = New.getValue(N.ResNo);\n"
|
|
|
|
<< " return;\n"
|
2006-01-26 23:08:55 +00:00
|
|
|
<< "}\n\n";
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
OS << "// The main instruction selector code.\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< "void SelectCode(SDOperand &Result, SDOperand N) {\n"
|
2005-09-23 21:53:45 +00:00
|
|
|
<< " if (N.getOpcode() >= ISD::BUILTIN_OP_END &&\n"
|
2005-10-18 04:41:01 +00:00
|
|
|
<< " N.getOpcode() < (ISD::BUILTIN_OP_END+" << InstNS
|
2006-02-09 00:37:58 +00:00
|
|
|
<< "INSTRUCTION_LIST_END)) {\n"
|
|
|
|
<< " Result = N;\n"
|
|
|
|
<< " return; // Already selected.\n"
|
|
|
|
<< " }\n\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(N);\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " if (CGMI != CodeGenMap.end()) {\n"
|
|
|
|
<< " Result = CGMI->second;\n"
|
|
|
|
<< " return;\n"
|
|
|
|
<< " }\n\n"
|
2005-09-23 21:53:45 +00:00
|
|
|
<< " switch (N.getOpcode()) {\n"
|
2005-09-07 23:44:43 +00:00
|
|
|
<< " default: break;\n"
|
|
|
|
<< " case ISD::EntryToken: // These leaves remain the same.\n"
|
2005-12-18 21:05:44 +00:00
|
|
|
<< " case ISD::BasicBlock:\n"
|
2006-01-11 19:52:27 +00:00
|
|
|
<< " case ISD::Register:\n"
|
2006-02-05 08:46:14 +00:00
|
|
|
<< " case ISD::HANDLENODE:\n"
|
2006-02-05 05:22:18 +00:00
|
|
|
<< " case ISD::TargetConstant:\n"
|
|
|
|
<< " case ISD::TargetConstantPool:\n"
|
|
|
|
<< " case ISD::TargetFrameIndex:\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " case ISD::TargetGlobalAddress: {\n"
|
|
|
|
<< " Result = N;\n"
|
|
|
|
<< " return;\n"
|
|
|
|
<< " }\n"
|
2005-09-07 23:44:43 +00:00
|
|
|
<< " case ISD::AssertSext:\n"
|
2005-09-26 22:10:24 +00:00
|
|
|
<< " case ISD::AssertZext: {\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " SDOperand Tmp0;\n"
|
|
|
|
<< " Select(Tmp0, N.getOperand(0));\n"
|
2006-02-09 22:12:27 +00:00
|
|
|
<< " if (!N.Val->hasOneUse())\n"
|
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, "
|
|
|
|
<< "Tmp0.Val, Tmp0.ResNo);\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " Result = Tmp0;\n"
|
|
|
|
<< " return;\n"
|
2005-10-25 20:35:14 +00:00
|
|
|
<< " }\n"
|
|
|
|
<< " case ISD::TokenFactor:\n"
|
|
|
|
<< " if (N.getNumOperands() == 2) {\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " SDOperand Op0, Op1;\n"
|
|
|
|
<< " Select(Op0, N.getOperand(0));\n"
|
|
|
|
<< " Select(Op1, N.getOperand(1));\n"
|
2006-02-09 22:12:27 +00:00
|
|
|
<< " Result = \n"
|
2005-10-25 20:35:14 +00:00
|
|
|
<< " CurDAG->getNode(ISD::TokenFactor, MVT::Other, Op0, Op1);\n"
|
2006-02-09 22:12:27 +00:00
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, "
|
|
|
|
<< "Result.Val, Result.ResNo);\n"
|
2005-10-25 20:35:14 +00:00
|
|
|
<< " } else {\n"
|
|
|
|
<< " std::vector<SDOperand> Ops;\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " for (unsigned i = 0, e = N.getNumOperands(); i != e; ++i) {\n"
|
|
|
|
<< " SDOperand Val;\n"
|
|
|
|
<< " Select(Val, N.getOperand(i));\n"
|
|
|
|
<< " Ops.push_back(Val);\n"
|
|
|
|
<< " }\n"
|
2006-02-09 22:12:27 +00:00
|
|
|
<< " Result = \n"
|
|
|
|
<< " CurDAG->getNode(ISD::TokenFactor, MVT::Other, Ops);\n"
|
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, N.ResNo, "
|
|
|
|
<< "Result.Val, Result.ResNo);\n"
|
2005-10-25 20:35:14 +00:00
|
|
|
<< " }\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " return;\n"
|
2005-10-25 20:35:14 +00:00
|
|
|
<< " case ISD::CopyFromReg: {\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " SDOperand Chain;\n"
|
|
|
|
<< " Select(Chain, N.getOperand(0));\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " unsigned Reg = cast<RegisterSDNode>(N.getOperand(1))->getReg();\n"
|
|
|
|
<< " MVT::ValueType VT = N.Val->getValueType(0);\n"
|
2005-12-18 15:45:51 +00:00
|
|
|
<< " if (N.Val->getNumValues() == 2) {\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " if (Chain == N.getOperand(0)) {\n"
|
|
|
|
<< " Result = N; // No change\n"
|
|
|
|
<< " return;\n"
|
|
|
|
<< " }\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " SDOperand New = CurDAG->getCopyFromReg(Chain, Reg, VT);\n"
|
2006-02-09 22:12:27 +00:00
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, "
|
|
|
|
<< "New.Val, 0);\n"
|
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, "
|
|
|
|
<< "New.Val, 1);\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " Result = New.getValue(N.ResNo);\n"
|
|
|
|
<< " return;\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " } else {\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " SDOperand Flag;\n"
|
|
|
|
<< " if (N.getNumOperands() == 3) Select(Flag, N.getOperand(2));\n"
|
2005-12-18 15:45:51 +00:00
|
|
|
<< " if (Chain == N.getOperand(0) &&\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " (N.getNumOperands() == 2 || Flag == N.getOperand(2))) {\n"
|
|
|
|
<< " Result = N; // No change\n"
|
|
|
|
<< " return;\n"
|
|
|
|
<< " }\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " SDOperand New = CurDAG->getCopyFromReg(Chain, Reg, VT, Flag);\n"
|
2006-02-09 22:12:27 +00:00
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, "
|
|
|
|
<< "New.Val, 0);\n"
|
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, "
|
|
|
|
<< "New.Val, 1);\n"
|
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 2, "
|
|
|
|
<< "New.Val, 2);\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " Result = New.getValue(N.ResNo);\n"
|
|
|
|
<< " return;\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " }\n"
|
2005-10-25 20:35:14 +00:00
|
|
|
<< " }\n"
|
|
|
|
<< " case ISD::CopyToReg: {\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " SDOperand Chain;\n"
|
|
|
|
<< " Select(Chain, N.getOperand(0));\n"
|
2005-12-18 15:45:51 +00:00
|
|
|
<< " unsigned Reg = cast<RegisterSDNode>(N.getOperand(1))->getReg();\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " SDOperand Val;\n"
|
|
|
|
<< " Select(Val, N.getOperand(2));\n"
|
2006-02-09 07:16:09 +00:00
|
|
|
<< " Result = N;\n"
|
2005-12-18 15:45:51 +00:00
|
|
|
<< " if (N.Val->getNumValues() == 1) {\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " if (Chain != N.getOperand(0) || Val != N.getOperand(2))\n"
|
2006-02-09 07:16:09 +00:00
|
|
|
<< " Result = CurDAG->getCopyToReg(Chain, Reg, Val);\n"
|
2006-02-09 22:12:27 +00:00
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, "
|
|
|
|
<< "Result.Val, 0);\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " } else {\n"
|
2005-12-22 20:37:36 +00:00
|
|
|
<< " SDOperand Flag(0, 0);\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " if (N.getNumOperands() == 4) Select(Flag, N.getOperand(3));\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " if (Chain != N.getOperand(0) || Val != N.getOperand(2) ||\n"
|
2005-12-18 15:45:51 +00:00
|
|
|
<< " (N.getNumOperands() == 4 && Flag != N.getOperand(3)))\n"
|
2006-02-09 07:16:09 +00:00
|
|
|
<< " Result = CurDAG->getCopyToReg(Chain, Reg, Val, Flag);\n"
|
2006-02-09 22:12:27 +00:00
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 0, "
|
|
|
|
<< "Result.Val, 0);\n"
|
|
|
|
<< " SelectionDAG::InsertISelMapEntry(CodeGenMap, N.Val, 1, "
|
|
|
|
<< "Result.Val, 1);\n"
|
2006-02-09 07:16:09 +00:00
|
|
|
<< " Result = Result.getValue(N.ResNo);\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " }\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " return;\n"
|
2006-01-26 23:08:55 +00:00
|
|
|
<< " }\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " case ISD::INLINEASM: Select_INLINEASM(Result, N); return;\n";
|
2006-01-26 23:08:55 +00:00
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
|
2006-01-04 00:25:00 +00:00
|
|
|
// Loop over all of the case statements, emiting a call to each method we
|
|
|
|
// emitted above.
|
2005-09-26 21:59:35 +00:00
|
|
|
for (std::map<Record*, std::vector<PatternToMatch*>,
|
|
|
|
CompareByRecordName>::iterator PBOI = PatternsByOpcode.begin(),
|
|
|
|
E = PatternsByOpcode.end(); PBOI != E; ++PBOI) {
|
2005-09-23 19:36:15 +00:00
|
|
|
const SDNodeInfo &OpcodeInfo = getSDNodeInfo(PBOI->first);
|
2006-01-04 00:25:00 +00:00
|
|
|
OS << " case " << OpcodeInfo.getEnumName() << ": "
|
2006-01-04 00:32:01 +00:00
|
|
|
<< std::string(std::max(0, int(24-OpcodeInfo.getEnumName().size())), ' ')
|
2006-02-09 00:37:58 +00:00
|
|
|
<< "Select_" << PBOI->first->getName() << "(Result, N); return;\n";
|
2005-09-23 19:36:15 +00:00
|
|
|
}
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
OS << " } // end of big switch.\n\n"
|
|
|
|
<< " std::cerr << \"Cannot yet select: \";\n"
|
2005-12-22 02:24:50 +00:00
|
|
|
<< " N.Val->dump(CurDAG);\n"
|
2005-09-07 23:44:43 +00:00
|
|
|
<< " std::cerr << '\\n';\n"
|
|
|
|
<< " abort();\n"
|
|
|
|
<< "}\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
void DAGISelEmitter::run(std::ostream &OS) {
|
|
|
|
EmitSourceFileHeader("DAG Instruction Selector for the " + Target.getName() +
|
|
|
|
" target", OS);
|
|
|
|
|
2005-09-14 00:09:24 +00:00
|
|
|
OS << "// *** NOTE: This file is #included into the middle of the target\n"
|
|
|
|
<< "// *** instruction selector class. These functions are really "
|
|
|
|
<< "methods.\n\n";
|
2005-09-16 00:29:46 +00:00
|
|
|
|
2005-09-24 00:50:51 +00:00
|
|
|
OS << "// Instance var to keep track of multiply used nodes that have \n"
|
|
|
|
<< "// already been selected.\n"
|
|
|
|
<< "std::map<SDOperand, SDOperand> CodeGenMap;\n";
|
2006-02-05 06:43:12 +00:00
|
|
|
|
|
|
|
OS << "// Instance var to keep track of mapping of chain generating nodes\n"
|
2006-02-06 08:12:55 +00:00
|
|
|
<< "// and their place handle nodes.\n";
|
|
|
|
OS << "std::map<SDOperand, SDOperand> HandleMap;\n";
|
|
|
|
OS << "// Instance var to keep track of mapping of place handle nodes\n"
|
2006-02-05 06:43:12 +00:00
|
|
|
<< "// and their replacement nodes.\n";
|
|
|
|
OS << "std::map<SDOperand, SDOperand> ReplaceMap;\n";
|
|
|
|
|
|
|
|
OS << "\n";
|
|
|
|
OS << "static void findNonImmUse(SDNode* Use, SDNode* Def, bool &found, "
|
|
|
|
<< "std::set<SDNode *> &Visited) {\n";
|
|
|
|
OS << " if (found || !Visited.insert(Use).second) return;\n";
|
|
|
|
OS << " for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) {\n";
|
|
|
|
OS << " SDNode *N = Use->getOperand(i).Val;\n";
|
|
|
|
OS << " if (N->getNodeDepth() >= Def->getNodeDepth()) {\n";
|
|
|
|
OS << " if (N != Def) {\n";
|
|
|
|
OS << " findNonImmUse(N, Def, found, Visited);\n";
|
|
|
|
OS << " } else {\n";
|
|
|
|
OS << " found = true;\n";
|
|
|
|
OS << " break;\n";
|
|
|
|
OS << " }\n";
|
|
|
|
OS << " }\n";
|
|
|
|
OS << " }\n";
|
|
|
|
OS << "}\n";
|
|
|
|
|
|
|
|
OS << "\n";
|
|
|
|
OS << "static bool isNonImmUse(SDNode* Use, SDNode* Def) {\n";
|
|
|
|
OS << " std::set<SDNode *> Visited;\n";
|
|
|
|
OS << " bool found = false;\n";
|
|
|
|
OS << " for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) {\n";
|
|
|
|
OS << " SDNode *N = Use->getOperand(i).Val;\n";
|
|
|
|
OS << " if (N != Def) {\n";
|
|
|
|
OS << " findNonImmUse(N, Def, found, Visited);\n";
|
|
|
|
OS << " if (found) break;\n";
|
|
|
|
OS << " }\n";
|
|
|
|
OS << " }\n";
|
|
|
|
OS << " return found;\n";
|
|
|
|
OS << "}\n";
|
|
|
|
|
|
|
|
OS << "\n";
|
2006-02-06 06:03:35 +00:00
|
|
|
OS << "// AddHandleReplacement - Note the pending replacement node for a\n"
|
2006-02-06 08:12:55 +00:00
|
|
|
<< "// handle node in ReplaceMap.\n";
|
2006-02-09 22:12:27 +00:00
|
|
|
OS << "void AddHandleReplacement(SDNode *H, unsigned HNum, SDNode *R, "
|
|
|
|
<< "unsigned RNum) {\n";
|
|
|
|
OS << " SDOperand N(H, HNum);\n";
|
2006-02-06 08:12:55 +00:00
|
|
|
OS << " std::map<SDOperand, SDOperand>::iterator HMI = HandleMap.find(N);\n";
|
|
|
|
OS << " if (HMI != HandleMap.end()) {\n";
|
2006-02-09 22:12:27 +00:00
|
|
|
OS << " ReplaceMap[HMI->second] = SDOperand(R, RNum);\n";
|
2006-02-06 08:12:55 +00:00
|
|
|
OS << " HandleMap.erase(N);\n";
|
2006-02-05 06:43:12 +00:00
|
|
|
OS << " }\n";
|
|
|
|
OS << "}\n";
|
|
|
|
|
|
|
|
OS << "\n";
|
2006-02-06 08:12:55 +00:00
|
|
|
OS << "// SelectDanglingHandles - Select replacements for all `dangling`\n";
|
|
|
|
OS << "// handles.Some handles do not yet have replacements because the\n";
|
|
|
|
OS << "// nodes they replacements have only dead readers.\n";
|
|
|
|
OS << "void SelectDanglingHandles() {\n";
|
|
|
|
OS << " for (std::map<SDOperand, SDOperand>::iterator I = "
|
|
|
|
<< "HandleMap.begin(),\n"
|
|
|
|
<< " E = HandleMap.end(); I != E; ++I) {\n";
|
|
|
|
OS << " SDOperand N = I->first;\n";
|
2006-02-09 00:37:58 +00:00
|
|
|
OS << " SDOperand R;\n";
|
|
|
|
OS << " Select(R, N.getValue(0));\n";
|
2006-02-09 22:12:27 +00:00
|
|
|
OS << " AddHandleReplacement(N.Val, N.ResNo, R.Val, R.ResNo);\n";
|
2006-02-06 08:12:55 +00:00
|
|
|
OS << " }\n";
|
|
|
|
OS << "}\n";
|
|
|
|
OS << "\n";
|
|
|
|
OS << "// ReplaceHandles - Replace all the handles with the real target\n";
|
2006-02-05 06:43:12 +00:00
|
|
|
OS << "// specific nodes.\n";
|
2006-02-06 08:12:55 +00:00
|
|
|
OS << "void ReplaceHandles() {\n";
|
2006-02-05 06:43:12 +00:00
|
|
|
OS << " for (std::map<SDOperand, SDOperand>::iterator I = "
|
|
|
|
<< "ReplaceMap.begin(),\n"
|
|
|
|
<< " E = ReplaceMap.end(); I != E; ++I) {\n";
|
|
|
|
OS << " SDOperand From = I->first;\n";
|
|
|
|
OS << " SDOperand To = I->second;\n";
|
|
|
|
OS << " for (SDNode::use_iterator UI = From.Val->use_begin(), "
|
|
|
|
<< "E = From.Val->use_end(); UI != E; ++UI) {\n";
|
|
|
|
OS << " SDNode *Use = *UI;\n";
|
|
|
|
OS << " std::vector<SDOperand> Ops;\n";
|
|
|
|
OS << " for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) {\n";
|
|
|
|
OS << " SDOperand O = Use->getOperand(i);\n";
|
|
|
|
OS << " if (O.Val == From.Val)\n";
|
|
|
|
OS << " Ops.push_back(To);\n";
|
|
|
|
OS << " else\n";
|
|
|
|
OS << " Ops.push_back(O);\n";
|
|
|
|
OS << " }\n";
|
|
|
|
OS << " SDOperand U = SDOperand(Use, 0);\n";
|
|
|
|
OS << " CurDAG->UpdateNodeOperands(U, Ops);\n";
|
|
|
|
OS << " }\n";
|
|
|
|
OS << " }\n";
|
|
|
|
OS << "}\n";
|
|
|
|
|
|
|
|
OS << "\n";
|
|
|
|
OS << "// SelectRoot - Top level entry to DAG isel.\n";
|
|
|
|
OS << "SDOperand SelectRoot(SDOperand N) {\n";
|
2006-02-09 00:37:58 +00:00
|
|
|
OS << " SDOperand ResNode;\n";
|
|
|
|
OS << " Select(ResNode, N);\n";
|
2006-02-06 08:12:55 +00:00
|
|
|
OS << " SelectDanglingHandles();\n";
|
|
|
|
OS << " ReplaceHandles();\n";
|
2006-02-05 06:43:12 +00:00
|
|
|
OS << " ReplaceMap.clear();\n";
|
2006-02-09 00:37:58 +00:00
|
|
|
OS << " return ResNode;\n";
|
2006-02-05 06:43:12 +00:00
|
|
|
OS << "}\n";
|
2005-09-24 00:50:51 +00:00
|
|
|
|
2005-09-08 21:03:01 +00:00
|
|
|
ParseNodeInfo();
|
2005-09-13 21:51:00 +00:00
|
|
|
ParseNodeTransforms(OS);
|
2005-12-08 02:00:36 +00:00
|
|
|
ParseComplexPatterns();
|
2005-09-15 02:38:02 +00:00
|
|
|
ParsePatternFragments(OS);
|
|
|
|
ParseInstructions();
|
|
|
|
ParsePatterns();
|
2005-09-23 20:52:47 +00:00
|
|
|
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
// Generate variants. For example, commutative patterns can match
|
2005-09-23 20:52:47 +00:00
|
|
|
// multiple ways. Add them to PatternsToMatch as well.
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
GenerateVariants();
|
2005-09-15 02:38:02 +00:00
|
|
|
|
2005-09-29 19:28:10 +00:00
|
|
|
|
|
|
|
DEBUG(std::cerr << "\n\nALL PATTERNS TO MATCH:\n\n";
|
|
|
|
for (unsigned i = 0, e = PatternsToMatch.size(); i != e; ++i) {
|
2005-12-14 22:02:59 +00:00
|
|
|
std::cerr << "PATTERN: "; PatternsToMatch[i].getSrcPattern()->dump();
|
|
|
|
std::cerr << "\nRESULT: ";PatternsToMatch[i].getDstPattern()->dump();
|
2005-09-29 19:28:10 +00:00
|
|
|
std::cerr << "\n";
|
|
|
|
});
|
|
|
|
|
2005-09-16 00:29:46 +00:00
|
|
|
// At this point, we have full information about the 'Patterns' we need to
|
|
|
|
// parse, both implicitly from instructions as well as from explicit pattern
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
// definitions. Emit the resultant instruction selector.
|
2005-09-07 23:44:43 +00:00
|
|
|
EmitInstructionSelector(OS);
|
|
|
|
|
|
|
|
for (std::map<Record*, TreePattern*>::iterator I = PatternFragments.begin(),
|
|
|
|
E = PatternFragments.end(); I != E; ++I)
|
|
|
|
delete I->second;
|
|
|
|
PatternFragments.clear();
|
|
|
|
|
|
|
|
Instructions.clear();
|
|
|
|
}
|