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.
|
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;
|
2005-12-08 02:00:36 +00:00
|
|
|
|
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-01-06 22:19:44 +00:00
|
|
|
Size += 3; // Matches a ConstantSDNode.
|
|
|
|
else if (NodeIsComplexPattern(Child))
|
|
|
|
Size += getPatternSize(Child, ISE);
|
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;
|
|
|
|
|
|
|
|
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));
|
|
|
|
}
|
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-01-28 20:31:24 +00:00
|
|
|
std::vector<std::pair<bool, std::string> > &gc)
|
|
|
|
: ISE(ise), Predicates(preds), Pattern(pattern), Instruction(instr),
|
2006-01-29 02:43:35 +00:00
|
|
|
GeneratedCode(gc), 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.
|
|
|
|
void EmitMatchCode(TreePatternNode *N, const std::string &RootName,
|
2005-12-23 22:11:47 +00:00
|
|
|
bool &FoundChain, bool isRoot = false) {
|
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;
|
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
|
|
|
bool NodeHasChain = NodeHasProperty(N, SDNodeInfo::SDNPHasChain, ISE);
|
|
|
|
bool HasChain = PatternHasProperty(N, SDNodeInfo::SDNPHasChain, 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-01-28 20:31:24 +00:00
|
|
|
if (NodeHasChain)
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck("!CodeGenMap.count(" + RootName + ".getValue(" +
|
2006-01-28 20:31:24 +00:00
|
|
|
utostr(CInfo.getNumResults()) + "))");
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2006-01-27 22:13:45 +00:00
|
|
|
if (NodeHasChain) {
|
|
|
|
if (!FoundChain) {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Chain = " + RootName + ".getOperand(0);");
|
2006-01-27 22:13:45 +00:00
|
|
|
FoundChain = true;
|
|
|
|
} else {
|
2006-01-28 20:43:52 +00:00
|
|
|
emitCheck("Chain.Val == " + RootName + ".Val");
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("Chain = " + RootName + ".getOperand(0);");
|
2006-01-27 22:13:45 +00:00
|
|
|
}
|
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.
|
|
|
|
// FIXME: we really need to separate the concepts of flag and "glue". Those
|
|
|
|
// real flag results, e.g. X86CMP output, can have multiple uses.
|
2006-01-26 02:13:31 +00:00
|
|
|
// FIXME: If the incoming flag is optional. 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-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand " + RootName + utostr(OpNo) + " = " +
|
|
|
|
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());
|
2005-12-23 22:11:47 +00:00
|
|
|
EmitMatchCode(Child, RootName + 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-28 20:43:52 +00:00
|
|
|
emitCheck("isa<ConstantSDNode>(" + RootName + utostr(OpNo) +
|
|
|
|
") && cast<ConstantSDNode>(" + RootName + utostr(OpNo) +
|
|
|
|
")->getSignExtended() == " + 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-28 20:31:24 +00:00
|
|
|
const char *Code;
|
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!");
|
|
|
|
case MVT::i1: Code = "bool Tmp"; break;
|
|
|
|
case MVT::i8: Code = "unsigned char Tmp"; break;
|
|
|
|
case MVT::i16: Code = "unsigned short Tmp"; break;
|
|
|
|
case MVT::i32: Code = "unsigned Tmp"; break;
|
|
|
|
case MVT::i64: Code = "uint64_t Tmp"; break;
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode(Code + utostr(ResNo) + "C = (unsigned)cast<ConstantSDNode>(" +
|
|
|
|
Val + ")->getValue();");
|
|
|
|
emitCode("SDOperand Tmp" + utostr(ResNo) +
|
|
|
|
" = 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-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Tmp" + utostr(ResNo) + " = CurDAG->getTarget"
|
|
|
|
"ExternalSymbol(cast<ExternalSymbolSDNode>(" +
|
|
|
|
Val + ")->getSymbol(), MVT::" +
|
|
|
|
getEnumName(N->getTypeNum(0)) + ");");
|
|
|
|
} else {
|
|
|
|
emitCode("SDOperand Tmp" + utostr(ResNo) + " = " + Val + ";");
|
|
|
|
}
|
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-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Tmp" + utostr(ResNo) + " = CurDAG->getTarget"
|
|
|
|
"GlobalAddress(cast<GlobalAddressSDNode>(" + Val +
|
|
|
|
")->getGlobal(), MVT::" + getEnumName(N->getTypeNum(0)) +
|
|
|
|
");");
|
|
|
|
} else {
|
|
|
|
emitCode("SDOperand Tmp" + utostr(ResNo) + " = " + Val + ";");
|
|
|
|
}
|
2006-01-03 22:55:16 +00:00
|
|
|
} else if (!N->isLeaf() && N->getOperator()->getName() == "texternalsym"){
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Tmp" + utostr(ResNo) + " = " + Val + ";");
|
2006-01-12 07:54:57 +00:00
|
|
|
} else if (!N->isLeaf() && N->getOperator()->getName() == "tconstpool") {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand 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-01-28 20:31:24 +00:00
|
|
|
std::string Code = "SDOperand ";
|
2006-01-04 03:23:30 +00:00
|
|
|
for (unsigned i = 0; i < NumRes - 1; ++i)
|
2006-01-28 20:31:24 +00:00
|
|
|
Code += "Tmp" + utostr(i+ResNo) + ", ";
|
|
|
|
emitCode(Code + "Tmp" + utostr(NumRes - 1 + ResNo) + ";");
|
|
|
|
|
2006-01-28 20:43:52 +00:00
|
|
|
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 + ")");
|
2005-12-09 22:45:35 +00:00
|
|
|
TmpNo = ResNo + NumRes;
|
|
|
|
} else {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Tmp" + utostr(ResNo) + " = Select(" + 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-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Tmp" + utostr(ResNo) + " = CurDAG->getRegister(" +
|
|
|
|
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-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Tmp" + utostr(ResNo) +
|
|
|
|
" = 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-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand InFlag = SDOperand(0, 0);");
|
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-01-28 20:31:24 +00:00
|
|
|
emitCode("Chain = Select(Chain);");
|
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-01-28 20:31:24 +00:00
|
|
|
std::string Code =
|
|
|
|
"SDOperand Tmp" + utostr(ResNo) + " = CurDAG->getTargetNode(" +
|
|
|
|
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-01-28 20:31:24 +00:00
|
|
|
emitCode(Code + ");");
|
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-01-28 20:31:24 +00:00
|
|
|
emitCode("Chain = Tmp" + utostr(LastOp) + ".getValue(" +
|
|
|
|
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) {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Result = SDOperand(0, 0);");
|
2006-01-24 20:46:50 +00:00
|
|
|
unsigned FlagNo = (unsigned) NodeHasChain + Pattern->getNumChildren();
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("if (HasOptInFlag)");
|
|
|
|
std::string Code = " Result = CurDAG->getTargetNode(" +
|
|
|
|
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]);
|
|
|
|
if (HasChain) Code += ", Chain";
|
|
|
|
emitCode(Code + ", InFlag);");
|
2006-01-24 20:46:50 +00:00
|
|
|
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("else");
|
|
|
|
Code = " Result = CurDAG->getTargetNode(" + 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]);
|
|
|
|
if (HasChain) Code += ", Chain);";
|
|
|
|
emitCode(Code);
|
2006-01-24 20:46:50 +00:00
|
|
|
} else {
|
2006-01-28 20:31:24 +00:00
|
|
|
std::string Code = "SDOperand Result = CurDAG->getTargetNode(" +
|
|
|
|
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]);
|
|
|
|
if (HasChain) Code += ", Chain";
|
|
|
|
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-01-28 20:31:24 +00:00
|
|
|
emitCode("CodeGenMap[N.getValue(" + utostr(ValNo) + ")] = Result"
|
|
|
|
".getValue(" + utostr(ValNo) + ");");
|
2005-12-19 22:40:04 +00:00
|
|
|
ValNo++;
|
|
|
|
}
|
|
|
|
|
2005-12-23 22:11:47 +00:00
|
|
|
if (HasChain)
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("Chain = Result.getValue(" + utostr(ValNo) + ");");
|
2005-12-20 07:37:41 +00:00
|
|
|
|
2006-01-26 00:22:25 +00:00
|
|
|
if (NodeHasOutFlag)
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("InFlag = Result.getValue(" +
|
|
|
|
utostr(ValNo + (unsigned)HasChain) + ");");
|
|
|
|
|
|
|
|
if (HasImpResults && EmitCopyFromRegs(N, ChainEmitted)) {
|
|
|
|
emitCode("CodeGenMap[N.getValue(" + utostr(ValNo) + ")] = "
|
|
|
|
"Result.getValue(" + utostr(ValNo) + ");");
|
|
|
|
ValNo++;
|
2005-12-22 02:24:50 +00:00
|
|
|
}
|
2005-12-20 07:37:41 +00:00
|
|
|
|
2005-12-23 22:11:47 +00:00
|
|
|
// User does not expect that the instruction produces a chain!
|
2006-01-09 18:27:06 +00:00
|
|
|
bool AddedChain = HasChain && !NodeHasChain;
|
|
|
|
if (NodeHasChain)
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("CodeGenMap[N.getValue(" + utostr(ValNo++) + ")] = Chain;");
|
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-01-28 20:31:24 +00:00
|
|
|
Code += "CodeGenMap[" + FoldedChains[j].first + ".getValue(" +
|
|
|
|
utostr(FoldedChains[j].second) + ")] = ";
|
|
|
|
emitCode(Code + "Chain;");
|
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-01-28 20:31:24 +00:00
|
|
|
emitCode("CodeGenMap[N.getValue(" + utostr(ValNo) + ")] = InFlag;");
|
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-01-28 20:31:24 +00:00
|
|
|
emitCode("return Result.getValue(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) + ")");
|
|
|
|
emitCode(" return Result.getValue(N.ResNo);");
|
|
|
|
emitCode("else");
|
|
|
|
emitCode(" return Result.getValue(N.ResNo+1);");
|
2005-12-22 02:24:50 +00:00
|
|
|
}
|
2005-12-20 07:37:41 +00:00
|
|
|
} else {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("return Result.getValue(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()) {");
|
|
|
|
std::string Code = " return CurDAG->SelectNodeTo(N.Val, " +
|
|
|
|
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 {");
|
|
|
|
Code = " return CodeGenMap[N] = CurDAG->getTargetNode(" +
|
|
|
|
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("}");
|
2005-12-04 08:18:16 +00:00
|
|
|
}
|
2005-12-20 07:37:41 +00:00
|
|
|
|
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-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Tmp" + utostr(ResNo) + " = Transform_" + Op->getName()
|
|
|
|
+ "(Tmp" + utostr(OpVal) + ".Val);");
|
2005-12-09 22:45:35 +00:00
|
|
|
if (isRoot) {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("CodeGenMap[N] = Tmp" +utostr(ResNo) + ";");
|
|
|
|
emitCode("return Tmp" + utostr(ResNo) + ";");
|
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-01-28 20:31:24 +00:00
|
|
|
emitCode("InFlag = Select(" + RootName + utostr(OpNo) + ");");
|
2006-01-11 22:16:13 +00:00
|
|
|
} else {
|
|
|
|
if (!ChainEmitted) {
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Chain = CurDAG->getEntryNode();");
|
2006-01-11 22:16:13 +00:00
|
|
|
ChainEmitted = true;
|
|
|
|
}
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand " + RootName + "CR" + utostr(i) + ";");
|
|
|
|
emitCode(RootName + "CR" + utostr(i) +
|
|
|
|
" = CurDAG->getCopyToReg(Chain, CurDAG->getRegister(" +
|
|
|
|
ISE.getQualifiedName(RR) + ", MVT::" + getEnumName(RVT) +
|
|
|
|
"), Select(" + RootName + utostr(OpNo) + "), InFlag);");
|
|
|
|
emitCode("Chain = " + RootName + "CR" + utostr(i) +
|
|
|
|
".getValue(0);");
|
|
|
|
emitCode("InFlag = " + RootName + "CR" + utostr(i) +
|
|
|
|
".getValue(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-01-28 20:31:24 +00:00
|
|
|
emitCode(Code + "InFlag = Select(" + 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-01-28 20:31:24 +00:00
|
|
|
emitCode("SDOperand Chain = CurDAG->getEntryNode();");
|
2006-01-11 22:16:13 +00:00
|
|
|
ChainEmitted = true;
|
2005-12-20 07:37:41 +00:00
|
|
|
}
|
2006-01-28 20:31:24 +00:00
|
|
|
emitCode("Result = CurDAG->getCopyFromReg(Chain, " +
|
|
|
|
ISE.getQualifiedName(RR) + ", MVT::" + getEnumName(RVT) +
|
|
|
|
", InFlag);");
|
|
|
|
emitCode("Chain = Result.getValue(1);");
|
|
|
|
emitCode("InFlag = Result.getValue(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.
|
|
|
|
void DAGISelEmitter::EmitCodeForPattern(PatternToMatch &Pattern,
|
|
|
|
std::vector<std::pair<bool, std::string> > &GeneratedCode) {
|
2005-12-14 22:02:59 +00:00
|
|
|
PatternCodeEmitter Emitter(*this, Pattern.getPredicates(),
|
|
|
|
Pattern.getSrcPattern(), Pattern.getDstPattern(),
|
2006-01-29 02:43:35 +00:00
|
|
|
GeneratedCode);
|
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;
|
|
|
|
Emitter.EmitMatchCode(Pattern.getSrcPattern(), "N", FoundChain,
|
|
|
|
true /*the root*/);
|
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
|
|
|
}
|
|
|
|
|
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) {
|
|
|
|
OS << "SDOperand Select_" << PBOI->first->getName() << "(SDOperand N) {\n";
|
|
|
|
|
|
|
|
const SDNodeInfo &OpcodeInfo = getSDNodeInfo(PBOI->first);
|
|
|
|
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-01-29 02:57:39 +00:00
|
|
|
typedef std::vector<std::pair<bool, std::string> > CodeList;
|
|
|
|
|
|
|
|
std::vector<std::pair<PatternToMatch*, CodeList> > CodeForPatterns;
|
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;
|
|
|
|
EmitCodeForPattern(*Patterns[i], GeneratedCode);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = CodeForPatterns.size(); i != e; ++i) {
|
|
|
|
CodeList &GeneratedCode = CodeForPatterns[i].second;
|
|
|
|
PatternToMatch &Pattern = *CodeForPatterns[i].first;
|
|
|
|
OS << " { // Pattern: ";
|
2006-01-29 02:43:35 +00:00
|
|
|
Pattern.getSrcPattern()->print(OS);
|
|
|
|
OS << "\n // Emits: ";
|
|
|
|
Pattern.getDstPattern()->print(OS);
|
|
|
|
OS << "\n";
|
|
|
|
OS << " // Pattern complexity = "
|
|
|
|
<< getPatternSize(Pattern.getSrcPattern(), *this) << " cost = "
|
|
|
|
<< getResultPatternCost(Pattern.getDstPattern()) << "\n";
|
|
|
|
|
|
|
|
// Actually output the generated code now.
|
|
|
|
mightNotMatch = false;
|
|
|
|
unsigned Indent = 4;
|
|
|
|
for (unsigned j = 0, e = GeneratedCode.size(); j != e; ++j) {
|
|
|
|
if (!GeneratedCode[j].first) {
|
|
|
|
// Normal code.
|
|
|
|
OS << std::string(Indent, ' ') << GeneratedCode[j].second << "\n";
|
|
|
|
} else {
|
|
|
|
mightNotMatch = true;
|
|
|
|
OS << std::string(Indent, ' ')
|
|
|
|
<< "if (" << GeneratedCode[j].second << ") {\n";
|
|
|
|
Indent += 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (; Indent != 4; Indent -= 2)
|
|
|
|
OS << std::string(Indent-2, ' ') << "}\n";
|
|
|
|
|
|
|
|
OS << " }\n";
|
2006-01-27 22:22:28 +00:00
|
|
|
}
|
2006-01-04 00:25:00 +00:00
|
|
|
|
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-01-26 23:08:55 +00:00
|
|
|
OS << "SDOperand Select_INLINEASM(SDOperand N) {\n"
|
|
|
|
<< " std::vector<SDOperand> Ops(N.Val->op_begin(), N.Val->op_end());\n"
|
|
|
|
<< " Ops[0] = Select(N.getOperand(0)); // Select the chain.\n\n"
|
|
|
|
<< " // Select the flag operand.\n"
|
|
|
|
<< " if (Ops.back().getValueType() == MVT::Flag)\n"
|
|
|
|
<< " Ops.back() = Select(Ops.back());\n"
|
|
|
|
<< " 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"
|
|
|
|
<< " CodeGenMap[N.getValue(0)] = New;\n"
|
|
|
|
<< " CodeGenMap[N.getValue(1)] = New.getValue(1);\n"
|
|
|
|
<< " return New.getValue(N.ResNo);\n"
|
|
|
|
<< "}\n\n";
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
OS << "// The main instruction selector code.\n"
|
2005-09-23 21:53:45 +00:00
|
|
|
<< "SDOperand SelectCode(SDOperand N) {\n"
|
|
|
|
<< " if (N.getOpcode() >= ISD::BUILTIN_OP_END &&\n"
|
2005-10-18 04:41:01 +00:00
|
|
|
<< " N.getOpcode() < (ISD::BUILTIN_OP_END+" << InstNS
|
|
|
|
<< "INSTRUCTION_LIST_END))\n"
|
2005-09-23 21:53:45 +00:00
|
|
|
<< " return N; // Already selected.\n\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " std::map<SDOperand, SDOperand>::iterator CGMI = CodeGenMap.find(N);\n"
|
2005-12-12 23:22:48 +00:00
|
|
|
<< " if (CGMI != CodeGenMap.end()) return CGMI->second;\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"
|
2005-09-23 21:53:45 +00:00
|
|
|
<< " 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"
|
|
|
|
<< " SDOperand Tmp0 = Select(N.getOperand(0));\n"
|
|
|
|
<< " if (!N.Val->hasOneUse()) CodeGenMap[N] = Tmp0;\n"
|
|
|
|
<< " return Tmp0;\n"
|
2005-10-25 20:35:14 +00:00
|
|
|
<< " }\n"
|
|
|
|
<< " case ISD::TokenFactor:\n"
|
|
|
|
<< " if (N.getNumOperands() == 2) {\n"
|
|
|
|
<< " SDOperand Op0 = Select(N.getOperand(0));\n"
|
|
|
|
<< " SDOperand Op1 = Select(N.getOperand(1));\n"
|
|
|
|
<< " return CodeGenMap[N] =\n"
|
|
|
|
<< " CurDAG->getNode(ISD::TokenFactor, MVT::Other, Op0, Op1);\n"
|
|
|
|
<< " } else {\n"
|
|
|
|
<< " std::vector<SDOperand> Ops;\n"
|
|
|
|
<< " for (unsigned i = 0, e = N.getNumOperands(); i != e; ++i)\n"
|
|
|
|
<< " Ops.push_back(Select(N.getOperand(i)));\n"
|
|
|
|
<< " return CodeGenMap[N] = \n"
|
|
|
|
<< " CurDAG->getNode(ISD::TokenFactor, MVT::Other, Ops);\n"
|
|
|
|
<< " }\n"
|
|
|
|
<< " case ISD::CopyFromReg: {\n"
|
2006-01-03 22:55:16 +00:00
|
|
|
<< " SDOperand Chain = Select(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"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " if (Chain == N.getOperand(0)) return N; // No change\n"
|
|
|
|
<< " SDOperand New = CurDAG->getCopyFromReg(Chain, Reg, VT);\n"
|
|
|
|
<< " CodeGenMap[N.getValue(0)] = New;\n"
|
|
|
|
<< " CodeGenMap[N.getValue(1)] = New.getValue(1);\n"
|
|
|
|
<< " return New.getValue(N.ResNo);\n"
|
|
|
|
<< " } else {\n"
|
2005-12-22 20:37:36 +00:00
|
|
|
<< " SDOperand Flag(0, 0);\n"
|
2005-12-18 15:45:51 +00:00
|
|
|
<< " if (N.getNumOperands() == 3) Flag = Select(N.getOperand(2));\n"
|
|
|
|
<< " if (Chain == N.getOperand(0) &&\n"
|
|
|
|
<< " (N.getNumOperands() == 2 || Flag == N.getOperand(2)))\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " return N; // No change\n"
|
|
|
|
<< " SDOperand New = CurDAG->getCopyFromReg(Chain, Reg, VT, Flag);\n"
|
|
|
|
<< " CodeGenMap[N.getValue(0)] = New;\n"
|
|
|
|
<< " CodeGenMap[N.getValue(1)] = New.getValue(1);\n"
|
|
|
|
<< " CodeGenMap[N.getValue(2)] = New.getValue(2);\n"
|
|
|
|
<< " return New.getValue(N.ResNo);\n"
|
|
|
|
<< " }\n"
|
2005-10-25 20:35:14 +00:00
|
|
|
<< " }\n"
|
|
|
|
<< " case ISD::CopyToReg: {\n"
|
2006-01-03 22:55:16 +00:00
|
|
|
<< " SDOperand Chain = Select(N.getOperand(0));\n"
|
2005-12-18 15:45:51 +00:00
|
|
|
<< " unsigned Reg = cast<RegisterSDNode>(N.getOperand(1))->getReg();\n"
|
2005-10-25 20:35:14 +00:00
|
|
|
<< " SDOperand Val = Select(N.getOperand(2));\n"
|
2006-01-03 22:55:16 +00:00
|
|
|
<< " SDOperand 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"
|
2005-12-18 15:45:51 +00:00
|
|
|
<< " Result = CurDAG->getCopyToReg(Chain, Reg, Val);\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " return CodeGenMap[N] = Result;\n"
|
|
|
|
<< " } else {\n"
|
2005-12-22 20:37:36 +00:00
|
|
|
<< " SDOperand Flag(0, 0);\n"
|
2005-12-18 15:45:51 +00:00
|
|
|
<< " if (N.getNumOperands() == 4) Flag = Select(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"
|
|
|
|
<< " Result = CurDAG->getCopyToReg(Chain, Reg, Val, Flag);\n"
|
2005-12-18 15:28:25 +00:00
|
|
|
<< " CodeGenMap[N.getValue(0)] = Result;\n"
|
|
|
|
<< " CodeGenMap[N.getValue(1)] = Result.getValue(1);\n"
|
|
|
|
<< " return Result.getValue(N.ResNo);\n"
|
|
|
|
<< " }\n"
|
2006-01-26 23:08:55 +00:00
|
|
|
<< " }\n"
|
|
|
|
<< " case ISD::INLINEASM: return Select_INLINEASM(N);\n";
|
|
|
|
|
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-01-04 00:25:00 +00:00
|
|
|
<< "return Select_" << PBOI->first->getName() << "(N);\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";
|
|
|
|
|
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();
|
|
|
|
}
|