2010-02-15 08:04:42 +00:00
|
|
|
//===- DAGISelMatcherGen.cpp - Matcher generator --------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "DAGISelMatcher.h"
|
|
|
|
#include "CodeGenDAGPatterns.h"
|
|
|
|
#include "Record.h"
|
2010-02-17 02:16:19 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2010-02-15 08:04:42 +00:00
|
|
|
#include "llvm/ADT/StringMap.h"
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
#include <utility>
|
2010-02-15 08:04:42 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2010-02-19 00:27:40 +00:00
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
/// getRegisterValueType - Look up and return the ValueType of the specified
|
|
|
|
/// register. If the register is a member of multiple register classes which
|
|
|
|
/// have different associated types, return MVT::Other.
|
|
|
|
static MVT::SimpleValueType getRegisterValueType(Record *R,
|
|
|
|
const CodeGenTarget &T) {
|
|
|
|
bool FoundRC = false;
|
|
|
|
MVT::SimpleValueType VT = MVT::Other;
|
|
|
|
const std::vector<CodeGenRegisterClass> &RCs = T.getRegisterClasses();
|
|
|
|
std::vector<Record*>::const_iterator Element;
|
2010-02-19 00:27:40 +00:00
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
for (unsigned rc = 0, e = RCs.size(); rc != e; ++rc) {
|
|
|
|
const CodeGenRegisterClass &RC = RCs[rc];
|
|
|
|
if (!std::count(RC.Elements.begin(), RC.Elements.end(), R))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!FoundRC) {
|
|
|
|
FoundRC = true;
|
|
|
|
VT = RC.getValueTypeNum(0);
|
|
|
|
continue;
|
|
|
|
}
|
2010-03-01 22:49:06 +00:00
|
|
|
|
|
|
|
// If this occurs in multiple register classes, they all have to agree.
|
|
|
|
assert(VT == RC.getValueTypeNum(0));
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
}
|
|
|
|
return VT;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
namespace {
|
2010-02-15 08:04:42 +00:00
|
|
|
class MatcherGen {
|
|
|
|
const PatternToMatch &Pattern;
|
|
|
|
const CodeGenDAGPatterns &CGP;
|
|
|
|
|
|
|
|
/// PatWithNoTypes - This is a clone of Pattern.getSrcPattern() that starts
|
|
|
|
/// out with all of the types removed. This allows us to insert type checks
|
|
|
|
/// as we scan the tree.
|
|
|
|
TreePatternNode *PatWithNoTypes;
|
|
|
|
|
|
|
|
/// VariableMap - A map from variable names ('$dst') to the recorded operand
|
|
|
|
/// number that they were captured as. These are biased by 1 to make
|
|
|
|
/// insertion easier.
|
|
|
|
StringMap<unsigned> VariableMap;
|
2010-02-19 00:27:40 +00:00
|
|
|
|
|
|
|
/// NextRecordedOperandNo - As we emit opcodes to record matched values in
|
|
|
|
/// the RecordedNodes array, this keeps track of which slot will be next to
|
|
|
|
/// record into.
|
2010-02-15 08:04:42 +00:00
|
|
|
unsigned NextRecordedOperandNo;
|
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
/// MatchedChainNodes - This maintains the position in the recorded nodes
|
|
|
|
/// array of all of the recorded input nodes that have chains.
|
|
|
|
SmallVector<unsigned, 2> MatchedChainNodes;
|
2010-02-24 05:33:42 +00:00
|
|
|
|
|
|
|
/// MatchedFlagResultNodes - This maintains the position in the recorded
|
|
|
|
/// nodes array of all of the recorded input nodes that have flag results.
|
|
|
|
SmallVector<unsigned, 2> MatchedFlagResultNodes;
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
2010-03-04 01:23:08 +00:00
|
|
|
/// MatchedComplexPatterns - This maintains a list of all of the
|
|
|
|
/// ComplexPatterns that we need to check. The patterns are known to have
|
|
|
|
/// names which were recorded. The second element of each pair is the first
|
|
|
|
/// slot number that the OPC_CheckComplexPat opcode drops the matched
|
|
|
|
/// results into.
|
|
|
|
SmallVector<std::pair<const TreePatternNode*,
|
|
|
|
unsigned>, 2> MatchedComplexPatterns;
|
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
/// PhysRegInputs - List list has an entry for each explicitly specified
|
|
|
|
/// physreg input to the pattern. The first elt is the Register node, the
|
|
|
|
/// second is the recorded slot number the input pattern match saved it in.
|
|
|
|
SmallVector<std::pair<Record*, unsigned>, 2> PhysRegInputs;
|
|
|
|
|
2010-02-17 02:16:19 +00:00
|
|
|
/// Matcher - This is the top level of the generated matcher, the result.
|
2010-02-25 02:04:40 +00:00
|
|
|
Matcher *TheMatcher;
|
2010-02-17 02:16:19 +00:00
|
|
|
|
|
|
|
/// CurPredicate - As we emit matcher nodes, this points to the latest check
|
2010-02-18 02:53:41 +00:00
|
|
|
/// which should have future checks stuck into its Next position.
|
2010-02-25 02:04:40 +00:00
|
|
|
Matcher *CurPredicate;
|
2010-02-15 08:04:42 +00:00
|
|
|
public:
|
|
|
|
MatcherGen(const PatternToMatch &pattern, const CodeGenDAGPatterns &cgp);
|
|
|
|
|
|
|
|
~MatcherGen() {
|
|
|
|
delete PatWithNoTypes;
|
|
|
|
}
|
|
|
|
|
2010-03-01 07:17:40 +00:00
|
|
|
bool EmitMatcherCode(unsigned Variant);
|
2010-02-18 06:47:49 +00:00
|
|
|
void EmitResultCode();
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
Matcher *GetMatcher() const { return TheMatcher; }
|
|
|
|
Matcher *GetCurPredicate() const { return CurPredicate; }
|
2010-02-15 08:04:42 +00:00
|
|
|
private:
|
2010-02-25 02:04:40 +00:00
|
|
|
void AddMatcher(Matcher *NewNode);
|
2010-02-15 08:04:42 +00:00
|
|
|
void InferPossibleTypes();
|
2010-02-18 06:47:49 +00:00
|
|
|
|
|
|
|
// Matcher Generation.
|
2010-02-15 08:04:42 +00:00
|
|
|
void EmitMatchCode(const TreePatternNode *N, TreePatternNode *NodeNoTypes);
|
|
|
|
void EmitLeafMatchCode(const TreePatternNode *N);
|
|
|
|
void EmitOperatorMatchCode(const TreePatternNode *N,
|
|
|
|
TreePatternNode *NodeNoTypes);
|
2010-02-18 06:47:49 +00:00
|
|
|
|
|
|
|
// Result Code Generation.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
unsigned getNamedArgumentSlot(StringRef Name) {
|
|
|
|
unsigned VarMapEntry = VariableMap[Name];
|
|
|
|
assert(VarMapEntry != 0 &&
|
|
|
|
"Variable referenced but not defined and not caught earlier!");
|
|
|
|
return VarMapEntry-1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// GetInstPatternNode - Get the pattern for an instruction.
|
|
|
|
const TreePatternNode *GetInstPatternNode(const DAGInstruction &Ins,
|
|
|
|
const TreePatternNode *N);
|
|
|
|
|
2010-02-18 06:47:49 +00:00
|
|
|
void EmitResultOperand(const TreePatternNode *N,
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
SmallVectorImpl<unsigned> &ResultOps);
|
|
|
|
void EmitResultOfNamedOperand(const TreePatternNode *N,
|
|
|
|
SmallVectorImpl<unsigned> &ResultOps);
|
2010-02-18 06:47:49 +00:00
|
|
|
void EmitResultLeafAsOperand(const TreePatternNode *N,
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
SmallVectorImpl<unsigned> &ResultOps);
|
2010-02-18 06:47:49 +00:00
|
|
|
void EmitResultInstructionAsOperand(const TreePatternNode *N,
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
SmallVectorImpl<unsigned> &ResultOps);
|
|
|
|
void EmitResultSDNodeXFormAsOperand(const TreePatternNode *N,
|
|
|
|
SmallVectorImpl<unsigned> &ResultOps);
|
|
|
|
};
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
} // end anon namespace.
|
|
|
|
|
|
|
|
MatcherGen::MatcherGen(const PatternToMatch &pattern,
|
|
|
|
const CodeGenDAGPatterns &cgp)
|
2010-02-19 00:33:13 +00:00
|
|
|
: Pattern(pattern), CGP(cgp), NextRecordedOperandNo(0),
|
2010-03-01 22:46:42 +00:00
|
|
|
TheMatcher(0), CurPredicate(0) {
|
2010-02-15 08:04:42 +00:00
|
|
|
// We need to produce the matcher tree for the patterns source pattern. To do
|
|
|
|
// this we need to match the structure as well as the types. To do the type
|
|
|
|
// matching, we want to figure out the fewest number of type checks 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.
|
|
|
|
//
|
|
|
|
PatWithNoTypes = Pattern.getSrcPattern()->clone();
|
|
|
|
PatWithNoTypes->RemoveAllTypes();
|
|
|
|
|
|
|
|
// If there are types that are manifestly known, infer them.
|
|
|
|
InferPossibleTypes();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// InferPossibleTypes - As we emit the pattern, we end up generating type
|
|
|
|
/// checks and applying them to the 'PatWithNoTypes' tree. As we do this, we
|
|
|
|
/// want to propagate implied types as far throughout the tree as possible so
|
|
|
|
/// that we avoid doing redundant type checks. This does the type propagation.
|
|
|
|
void MatcherGen::InferPossibleTypes() {
|
|
|
|
// TP - Get *SOME* tree pattern, we don't care which. It is only used for
|
|
|
|
// diagnostics, which we know are impossible at this point.
|
|
|
|
TreePattern &TP = *CGP.pf_begin()->second;
|
|
|
|
|
|
|
|
try {
|
|
|
|
bool MadeChange = true;
|
|
|
|
while (MadeChange)
|
|
|
|
MadeChange = PatWithNoTypes->ApplyTypeConstraints(TP,
|
|
|
|
true/*Ignore reg constraints*/);
|
|
|
|
} catch (...) {
|
|
|
|
errs() << "Type constraint application shouldn't fail!";
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// AddMatcher - Add a matcher node to the current graph we're building.
|
|
|
|
void MatcherGen::AddMatcher(Matcher *NewNode) {
|
2010-02-15 08:04:42 +00:00
|
|
|
if (CurPredicate != 0)
|
2010-02-18 02:53:41 +00:00
|
|
|
CurPredicate->setNext(NewNode);
|
2010-02-15 08:04:42 +00:00
|
|
|
else
|
2010-02-25 02:04:40 +00:00
|
|
|
TheMatcher = NewNode;
|
2010-02-15 08:04:42 +00:00
|
|
|
CurPredicate = NewNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-02-18 06:47:49 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Pattern Match Generation
|
|
|
|
//===----------------------------------------------------------------------===//
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
/// EmitLeafMatchCode - Generate matching code for leaf nodes.
|
|
|
|
void MatcherGen::EmitLeafMatchCode(const TreePatternNode *N) {
|
|
|
|
assert(N->isLeaf() && "Not a leaf?");
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
2010-02-15 08:04:42 +00:00
|
|
|
// Direct match against an integer constant.
|
2010-03-01 07:27:07 +00:00
|
|
|
if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
|
|
|
|
// If this is the root of the dag we're matching, we emit a redundant opcode
|
|
|
|
// check to ensure that this gets folded into the normal top-level
|
|
|
|
// OpcodeSwitch.
|
|
|
|
if (N == Pattern.getSrcPattern()) {
|
|
|
|
const SDNodeInfo &NI = CGP.getSDNodeInfo(CGP.getSDNodeNamed("imm"));
|
|
|
|
AddMatcher(new CheckOpcodeMatcher(NI));
|
|
|
|
}
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
return AddMatcher(new CheckIntegerMatcher(II->getValue()));
|
2010-03-01 07:27:07 +00:00
|
|
|
}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue());
|
|
|
|
if (DI == 0) {
|
|
|
|
errs() << "Unknown leaf kind: " << *DI << "\n";
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
Record *LeafRec = DI->getDef();
|
|
|
|
if (// Handle register references. Nothing to do here, they always match.
|
|
|
|
LeafRec->isSubClassOf("RegisterClass") ||
|
|
|
|
LeafRec->isSubClassOf("PointerLikeRegClass") ||
|
|
|
|
// Place holder for SRCVALUE nodes. Nothing to do here.
|
|
|
|
LeafRec->getName() == "srcvalue")
|
|
|
|
return;
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
// If we have a physreg reference like (mul gpr:$src, EAX) then we need to
|
|
|
|
// record the register
|
|
|
|
if (LeafRec->isSubClassOf("Register")) {
|
2010-03-01 02:24:17 +00:00
|
|
|
AddMatcher(new RecordMatcher("physreg input "+LeafRec->getName(),
|
|
|
|
NextRecordedOperandNo));
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
PhysRegInputs.push_back(std::make_pair(LeafRec, NextRecordedOperandNo++));
|
|
|
|
return;
|
|
|
|
}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
if (LeafRec->isSubClassOf("ValueType"))
|
2010-02-25 02:04:40 +00:00
|
|
|
return AddMatcher(new CheckValueTypeMatcher(LeafRec->getName()));
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
if (LeafRec->isSubClassOf("CondCode"))
|
2010-02-25 02:04:40 +00:00
|
|
|
return AddMatcher(new CheckCondCodeMatcher(LeafRec->getName()));
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
if (LeafRec->isSubClassOf("ComplexPattern")) {
|
2010-02-17 00:11:30 +00:00
|
|
|
// We can't model ComplexPattern uses that don't have their name taken yet.
|
|
|
|
// The OPC_CheckComplexPattern operation implicitly records the results.
|
|
|
|
if (N->getName().empty()) {
|
2010-02-16 23:16:25 +00:00
|
|
|
errs() << "We expect complex pattern uses to have names: " << *N << "\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
2010-02-22 22:18:05 +00:00
|
|
|
|
2010-03-04 01:23:08 +00:00
|
|
|
// Remember this ComplexPattern so that we can emit it after all the other
|
|
|
|
// structural matches are done.
|
|
|
|
MatchedComplexPatterns.push_back(std::make_pair(N, 0));
|
2010-02-17 06:08:25 +00:00
|
|
|
return;
|
2010-02-15 08:04:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
errs() << "Unknown leaf kind: " << *N << "\n";
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MatcherGen::EmitOperatorMatchCode(const TreePatternNode *N,
|
|
|
|
TreePatternNode *NodeNoTypes) {
|
|
|
|
assert(!N->isLeaf() && "Not an operator?");
|
|
|
|
const SDNodeInfo &CInfo = CGP.getSDNodeInfo(N->getOperator());
|
|
|
|
|
|
|
|
// If this is an 'and R, 1234' where the operation is AND/OR and the RHS is
|
|
|
|
// a constant without a predicate fn that has more that one bit set, handle
|
|
|
|
// this as a special case. This is usually for targets that have special
|
|
|
|
// handling of certain large constants (e.g. alpha with it's 8/16/32-bit
|
|
|
|
// handling stuff). Using these instructions is often far more efficient
|
|
|
|
// than materializing the constant. Unfortunately, both the instcombiner
|
|
|
|
// and the dag combiner can often infer that bits are dead, and thus drop
|
|
|
|
// them from the mask in the dag. For example, it might turn 'AND X, 255'
|
|
|
|
// into 'AND X, 254' if it knows the low bit is set. Emit code that checks
|
|
|
|
// to handle this.
|
|
|
|
if ((N->getOperator()->getName() == "and" ||
|
|
|
|
N->getOperator()->getName() == "or") &&
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
N->getChild(1)->isLeaf() && N->getChild(1)->getPredicateFns().empty() &&
|
|
|
|
N->getPredicateFns().empty()) {
|
2010-02-15 08:04:42 +00:00
|
|
|
if (IntInit *II = dynamic_cast<IntInit*>(N->getChild(1)->getLeafValue())) {
|
|
|
|
if (!isPowerOf2_32(II->getValue())) { // Don't bother with single bits.
|
2010-03-01 02:15:34 +00:00
|
|
|
// If this is at the root of the pattern, we emit a redundant
|
|
|
|
// CheckOpcode so that the following checks get factored properly under
|
|
|
|
// a single opcode check.
|
|
|
|
if (N == Pattern.getSrcPattern())
|
|
|
|
AddMatcher(new CheckOpcodeMatcher(CInfo));
|
|
|
|
|
|
|
|
// Emit the CheckAndImm/CheckOrImm node.
|
2010-02-15 08:04:42 +00:00
|
|
|
if (N->getOperator()->getName() == "and")
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CheckAndImmMatcher(II->getValue()));
|
2010-02-15 08:04:42 +00:00
|
|
|
else
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CheckOrImmMatcher(II->getValue()));
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
// Match the LHS of the AND as appropriate.
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new MoveChildMatcher(0));
|
2010-02-15 08:04:42 +00:00
|
|
|
EmitMatchCode(N->getChild(0), NodeNoTypes->getChild(0));
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new MoveParentMatcher());
|
2010-02-15 08:04:42 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check that the current opcode lines up.
|
2010-02-27 21:48:43 +00:00
|
|
|
AddMatcher(new CheckOpcodeMatcher(CInfo));
|
2010-02-15 08:04:42 +00:00
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// If this node has memory references (i.e. is a load or store), tell the
|
|
|
|
// interpreter to capture them in the memref array.
|
|
|
|
if (N->NodeHasProperty(SDNPMemOperand, CGP))
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new RecordMemRefMatcher());
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
2010-02-15 08:04:42 +00:00
|
|
|
// If this node has a chain, then the chain is operand #0 is the SDNode, and
|
|
|
|
// the child numbers of the node are all offset by one.
|
|
|
|
unsigned OpNo = 0;
|
2010-02-16 19:19:58 +00:00
|
|
|
if (N->NodeHasProperty(SDNPHasChain, CGP)) {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// Record the node and remember it in our chained nodes list.
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new RecordMatcher("'" + N->getOperator()->getName() +
|
2010-03-01 02:24:17 +00:00
|
|
|
"' chained node",
|
|
|
|
NextRecordedOperandNo));
|
2010-02-17 02:16:19 +00:00
|
|
|
// Remember all of the input chains our pattern will match.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
MatchedChainNodes.push_back(NextRecordedOperandNo++);
|
2010-02-17 02:16:19 +00:00
|
|
|
|
2010-02-17 01:34:15 +00:00
|
|
|
// Don't look at the input chain when matching the tree pattern to the
|
|
|
|
// SDNode.
|
2010-02-15 08:04:42 +00:00
|
|
|
OpNo = 1;
|
|
|
|
|
2010-02-16 19:19:58 +00:00
|
|
|
// If this node is not the root and the subtree underneath it produces a
|
|
|
|
// chain, then the result of matching the node is also produce a chain.
|
|
|
|
// Beyond that, this means that we're also folding (at least) the root node
|
|
|
|
// into the node that produce the chain (for example, matching
|
|
|
|
// "(add reg, (load ptr))" as a add_with_memory on X86). This is
|
|
|
|
// problematic, if the 'reg' node also uses the load (say, its chain).
|
|
|
|
// Graphically:
|
|
|
|
//
|
|
|
|
// [LD]
|
|
|
|
// ^ ^
|
|
|
|
// | \ DAG's like cheese.
|
|
|
|
// / |
|
|
|
|
// / [YY]
|
|
|
|
// | ^
|
|
|
|
// [XX]--/
|
|
|
|
//
|
|
|
|
// It would be invalid to fold XX and LD. In this case, folding the two
|
|
|
|
// nodes together would induce a cycle in the DAG, making it a 'cyclic DAG'
|
|
|
|
// To prevent this, we emit a dynamic check for legality before allowing
|
|
|
|
// this to be folded.
|
|
|
|
//
|
|
|
|
const TreePatternNode *Root = Pattern.getSrcPattern();
|
|
|
|
if (N != Root) { // Not the root of the pattern.
|
2010-02-16 06:10:58 +00:00
|
|
|
// If there is a node between the root and this node, then we definitely
|
|
|
|
// need to emit the check.
|
|
|
|
bool NeedCheck = !Root->hasChild(N);
|
|
|
|
|
|
|
|
// If it *is* an immediate child of the root, we can still need a check if
|
|
|
|
// the root SDNode has multiple inputs. For us, this means that it is an
|
|
|
|
// intrinsic, has multiple operands, or has other inputs like chain or
|
|
|
|
// flag).
|
|
|
|
if (!NeedCheck) {
|
|
|
|
const SDNodeInfo &PInfo = CGP.getSDNodeInfo(Root->getOperator());
|
|
|
|
NeedCheck =
|
|
|
|
Root->getOperator() == CGP.get_intrinsic_void_sdnode() ||
|
|
|
|
Root->getOperator() == CGP.get_intrinsic_w_chain_sdnode() ||
|
|
|
|
Root->getOperator() == CGP.get_intrinsic_wo_chain_sdnode() ||
|
|
|
|
PInfo.getNumOperands() > 1 ||
|
|
|
|
PInfo.hasProperty(SDNPHasChain) ||
|
|
|
|
PInfo.hasProperty(SDNPInFlag) ||
|
|
|
|
PInfo.hasProperty(SDNPOptInFlag);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NeedCheck)
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CheckFoldableChainNodeMatcher());
|
2010-02-16 06:10:58 +00:00
|
|
|
}
|
2010-02-15 08:04:42 +00:00
|
|
|
}
|
2010-02-24 05:33:42 +00:00
|
|
|
|
|
|
|
// If this node has an output flag and isn't the root, remember it.
|
|
|
|
if (N->NodeHasProperty(SDNPOutFlag, CGP) &&
|
|
|
|
N != Pattern.getSrcPattern()) {
|
|
|
|
// TODO: This redundantly records nodes with both flags and chains.
|
|
|
|
|
|
|
|
// Record the node and remember it in our chained nodes list.
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new RecordMatcher("'" + N->getOperator()->getName() +
|
2010-03-01 02:24:17 +00:00
|
|
|
"' flag output node",
|
|
|
|
NextRecordedOperandNo));
|
2010-02-24 05:33:42 +00:00
|
|
|
// Remember all of the nodes with output flags our pattern will match.
|
|
|
|
MatchedFlagResultNodes.push_back(NextRecordedOperandNo++);
|
|
|
|
}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
// If this node is known to have an input flag or if it *might* have an input
|
|
|
|
// flag, capture it as the flag input of the pattern.
|
|
|
|
if (N->NodeHasProperty(SDNPOptInFlag, CGP) ||
|
|
|
|
N->NodeHasProperty(SDNPInFlag, CGP))
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CaptureFlagInputMatcher());
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i, ++OpNo) {
|
|
|
|
// Get the code suitable for matching this child. Move to the child, check
|
|
|
|
// it then move back to the parent.
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new MoveChildMatcher(OpNo));
|
2010-02-15 08:04:42 +00:00
|
|
|
EmitMatchCode(N->getChild(i), NodeNoTypes->getChild(i));
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new MoveParentMatcher());
|
2010-02-15 08:04:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void MatcherGen::EmitMatchCode(const TreePatternNode *N,
|
|
|
|
TreePatternNode *NodeNoTypes) {
|
|
|
|
// If N and NodeNoTypes don't agree on a type, then this is a case where we
|
|
|
|
// need to do a type check. Emit the check, apply the tyep to NodeNoTypes and
|
|
|
|
// reinfer any correlated types.
|
2010-03-15 06:00:16 +00:00
|
|
|
bool DoTypeCheck = false;
|
|
|
|
if (NodeNoTypes->getExtType() != N->getExtType()) {
|
|
|
|
NodeNoTypes->setType(N->getExtType());
|
2010-02-15 08:04:42 +00:00
|
|
|
InferPossibleTypes();
|
2010-03-15 06:00:16 +00:00
|
|
|
DoTypeCheck = true;
|
2010-02-15 08:04:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// If this node has a name associated with it, capture it in VariableMap. If
|
|
|
|
// we already saw this in the pattern, emit code to verify dagness.
|
|
|
|
if (!N->getName().empty()) {
|
|
|
|
unsigned &VarMapEntry = VariableMap[N->getName()];
|
|
|
|
if (VarMapEntry == 0) {
|
2010-02-22 23:33:44 +00:00
|
|
|
// If it is a named node, we must emit a 'Record' opcode.
|
2010-03-01 02:24:17 +00:00
|
|
|
AddMatcher(new RecordMatcher("$" + N->getName(), NextRecordedOperandNo));
|
2010-02-22 23:33:44 +00:00
|
|
|
VarMapEntry = ++NextRecordedOperandNo;
|
2010-02-15 08:04:42 +00:00
|
|
|
} 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.
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CheckSameMatcher(VarMapEntry-1));
|
2010-02-15 08:04:42 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (N->isLeaf())
|
|
|
|
EmitLeafMatchCode(N);
|
|
|
|
else
|
|
|
|
EmitOperatorMatchCode(N, NodeNoTypes);
|
2010-03-01 07:54:59 +00:00
|
|
|
|
2010-03-07 07:20:49 +00:00
|
|
|
// If there are node predicates for this node, generate their checks.
|
|
|
|
for (unsigned i = 0, e = N->getPredicateFns().size(); i != e; ++i)
|
|
|
|
AddMatcher(new CheckPredicateMatcher(N->getPredicateFns()[i]));
|
|
|
|
|
2010-03-15 06:00:16 +00:00
|
|
|
if (DoTypeCheck)
|
|
|
|
AddMatcher(new CheckTypeMatcher(N->getType()));
|
2010-02-15 08:04:42 +00:00
|
|
|
}
|
|
|
|
|
2010-03-01 07:17:40 +00:00
|
|
|
/// EmitMatcherCode - Generate the code that matches the predicate of this
|
|
|
|
/// pattern for the specified Variant. If the variant is invalid this returns
|
|
|
|
/// true and does not generate code, if it is valid, it returns false.
|
|
|
|
bool MatcherGen::EmitMatcherCode(unsigned Variant) {
|
|
|
|
// If the root of the pattern is a ComplexPattern and if it is specified to
|
|
|
|
// match some number of root opcodes, these are considered to be our variants.
|
|
|
|
// Depending on which variant we're generating code for, emit the root opcode
|
|
|
|
// check.
|
|
|
|
if (const ComplexPattern *CP =
|
|
|
|
Pattern.getSrcPattern()->getComplexPatternInfo(CGP)) {
|
|
|
|
const std::vector<Record*> &OpNodes = CP->getRootNodes();
|
2010-03-01 22:29:19 +00:00
|
|
|
assert(!OpNodes.empty() &&"Complex Pattern must specify what it can match");
|
|
|
|
if (Variant >= OpNodes.size()) return true;
|
|
|
|
|
|
|
|
AddMatcher(new CheckOpcodeMatcher(CGP.getSDNodeInfo(OpNodes[Variant])));
|
2010-03-01 07:17:40 +00:00
|
|
|
} else {
|
|
|
|
if (Variant != 0) return true;
|
|
|
|
}
|
|
|
|
|
2010-03-04 01:25:36 +00:00
|
|
|
// Emit the matcher for the pattern structure and types.
|
|
|
|
EmitMatchCode(Pattern.getSrcPattern(), PatWithNoTypes);
|
|
|
|
|
2010-02-15 08:04:42 +00:00
|
|
|
// If the pattern has a predicate on it (e.g. only enabled when a subtarget
|
|
|
|
// feature is around, do the check).
|
|
|
|
if (!Pattern.getPredicateCheck().empty())
|
2010-03-01 07:17:40 +00:00
|
|
|
AddMatcher(new CheckPatternPredicateMatcher(Pattern.getPredicateCheck()));
|
2010-03-04 01:23:08 +00:00
|
|
|
|
|
|
|
// Now that we've completed the structural type match, emit any ComplexPattern
|
|
|
|
// checks (e.g. addrmode matches). We emit this after the structural match
|
|
|
|
// because they are generally more expensive to evaluate and more difficult to
|
|
|
|
// factor.
|
|
|
|
for (unsigned i = 0, e = MatchedComplexPatterns.size(); i != e; ++i) {
|
|
|
|
const TreePatternNode *N = MatchedComplexPatterns[i].first;
|
|
|
|
|
|
|
|
// Remember where the results of this match get stuck.
|
|
|
|
MatchedComplexPatterns[i].second = NextRecordedOperandNo;
|
|
|
|
|
|
|
|
// Get the slot we recorded the value in from the name on the node.
|
|
|
|
unsigned RecNodeEntry = VariableMap[N->getName()];
|
|
|
|
assert(!N->getName().empty() && RecNodeEntry &&
|
|
|
|
"Complex pattern should have a name and slot");
|
|
|
|
--RecNodeEntry; // Entries in VariableMap are biased.
|
|
|
|
|
|
|
|
const ComplexPattern &CP =
|
|
|
|
CGP.getComplexPattern(((DefInit*)N->getLeafValue())->getDef());
|
|
|
|
|
|
|
|
// Emit a CheckComplexPat operation, which does the match (aborting if it
|
|
|
|
// fails) and pushes the matched operands onto the recorded nodes list.
|
|
|
|
AddMatcher(new CheckComplexPatMatcher(CP, RecNodeEntry,
|
|
|
|
N->getName(), NextRecordedOperandNo));
|
|
|
|
|
|
|
|
// Record the right number of operands.
|
|
|
|
NextRecordedOperandNo += CP.getNumOperands();
|
|
|
|
if (CP.hasProperty(SDNPHasChain)) {
|
|
|
|
// If the complex pattern has a chain, then we need to keep track of the
|
|
|
|
// fact that we just recorded a chain input. The chain input will be
|
|
|
|
// matched as the last operand of the predicate if it was successful.
|
|
|
|
++NextRecordedOperandNo; // Chained node operand.
|
|
|
|
|
|
|
|
// It is the last operand recorded.
|
|
|
|
assert(NextRecordedOperandNo > 1 &&
|
|
|
|
"Should have recorded input/result chains at least!");
|
|
|
|
MatchedChainNodes.push_back(NextRecordedOperandNo-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: Complex patterns can't have output flags, if they did, we'd want
|
|
|
|
// to record them.
|
|
|
|
}
|
|
|
|
|
2010-03-01 07:17:40 +00:00
|
|
|
return false;
|
2010-02-15 08:04:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-02-18 06:47:49 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Node Result Generation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
void MatcherGen::EmitResultOfNamedOperand(const TreePatternNode *N,
|
|
|
|
SmallVectorImpl<unsigned> &ResultOps){
|
|
|
|
assert(!N->getName().empty() && "Operand not named!");
|
|
|
|
|
|
|
|
// A reference to a complex pattern gets all of the results of the complex
|
|
|
|
// pattern's match.
|
|
|
|
if (const ComplexPattern *CP = N->getComplexPatternInfo(CGP)) {
|
2010-03-04 01:23:08 +00:00
|
|
|
unsigned SlotNo = 0;
|
|
|
|
for (unsigned i = 0, e = MatchedComplexPatterns.size(); i != e; ++i)
|
|
|
|
if (MatchedComplexPatterns[i].first->getName() == N->getName()) {
|
|
|
|
SlotNo = MatchedComplexPatterns[i].second;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
assert(SlotNo != 0 && "Didn't get a slot number assigned?");
|
|
|
|
|
2010-02-22 23:33:44 +00:00
|
|
|
// The first slot entry is the node itself, the subsequent entries are the
|
|
|
|
// matched values.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
|
2010-03-04 01:23:08 +00:00
|
|
|
ResultOps.push_back(SlotNo+i);
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-03-04 01:23:08 +00:00
|
|
|
unsigned SlotNo = getNamedArgumentSlot(N->getName());
|
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// If this is an 'imm' or 'fpimm' node, make sure to convert it to the target
|
|
|
|
// version of the immediate so that it doesn't get selected due to some other
|
|
|
|
// node use.
|
|
|
|
if (!N->isLeaf()) {
|
|
|
|
StringRef OperatorName = N->getOperator()->getName();
|
|
|
|
if (OperatorName == "imm" || OperatorName == "fpimm") {
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new EmitConvertToTargetMatcher(SlotNo));
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
ResultOps.push_back(NextRecordedOperandNo++);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ResultOps.push_back(SlotNo);
|
|
|
|
}
|
|
|
|
|
2010-02-18 06:47:49 +00:00
|
|
|
void MatcherGen::EmitResultLeafAsOperand(const TreePatternNode *N,
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
SmallVectorImpl<unsigned> &ResultOps) {
|
2010-02-18 22:03:03 +00:00
|
|
|
assert(N->isLeaf() && "Must be a leaf");
|
|
|
|
|
|
|
|
if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
|
2010-03-15 06:00:16 +00:00
|
|
|
AddMatcher(new EmitIntegerMatcher(II->getValue(), N->getType()));
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
ResultOps.push_back(NextRecordedOperandNo++);
|
2010-02-18 22:03:03 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this is an explicit register reference, handle it.
|
|
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) {
|
|
|
|
if (DI->getDef()->isSubClassOf("Register")) {
|
2010-03-15 06:00:16 +00:00
|
|
|
AddMatcher(new EmitRegisterMatcher(DI->getDef(), N->getType()));
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
ResultOps.push_back(NextRecordedOperandNo++);
|
2010-02-18 22:03:03 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DI->getDef()->getName() == "zero_reg") {
|
2010-03-15 06:00:16 +00:00
|
|
|
AddMatcher(new EmitRegisterMatcher(0, N->getType()));
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
ResultOps.push_back(NextRecordedOperandNo++);
|
2010-02-18 22:03:03 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// Handle a reference to a register class. This is used
|
|
|
|
// in COPY_TO_SUBREG instructions.
|
2010-02-18 22:03:03 +00:00
|
|
|
if (DI->getDef()->isSubClassOf("RegisterClass")) {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
std::string Value = getQualifiedName(DI->getDef()) + "RegClassID";
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new EmitStringIntegerMatcher(Value, MVT::i32));
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
ResultOps.push_back(NextRecordedOperandNo++);
|
|
|
|
return;
|
2010-02-18 22:03:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-18 06:47:49 +00:00
|
|
|
errs() << "unhandled leaf node: \n";
|
|
|
|
N->dump();
|
|
|
|
}
|
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
/// GetInstPatternNode - Get the pattern for an instruction.
|
|
|
|
///
|
|
|
|
const TreePatternNode *MatcherGen::
|
|
|
|
GetInstPatternNode(const DAGInstruction &Inst, const TreePatternNode *N) {
|
|
|
|
const TreePattern *InstPat = Inst.getPattern();
|
|
|
|
|
|
|
|
// FIXME2?: Assume actual pattern comes before "implicit".
|
|
|
|
TreePatternNode *InstPatNode;
|
|
|
|
if (InstPat)
|
|
|
|
InstPatNode = InstPat->getTree(0);
|
|
|
|
else if (/*isRoot*/ N == Pattern.getDstPattern())
|
|
|
|
InstPatNode = Pattern.getSrcPattern();
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (InstPatNode && !InstPatNode->isLeaf() &&
|
|
|
|
InstPatNode->getOperator()->getName() == "set")
|
|
|
|
InstPatNode = InstPatNode->getChild(InstPatNode->getNumChildren()-1);
|
|
|
|
|
|
|
|
return InstPatNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MatcherGen::
|
|
|
|
EmitResultInstructionAsOperand(const TreePatternNode *N,
|
|
|
|
SmallVectorImpl<unsigned> &OutputOps) {
|
2010-02-18 06:47:49 +00:00
|
|
|
Record *Op = N->getOperator();
|
|
|
|
const CodeGenTarget &CGT = CGP.getTargetInfo();
|
|
|
|
CodeGenInstruction &II = CGT.getInstruction(Op->getName());
|
|
|
|
const DAGInstruction &Inst = CGP.getInstruction(Op);
|
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// If we can, get the pattern for the instruction we're generating. We derive
|
|
|
|
// a variety of information from this pattern, such as whether it has a chain.
|
|
|
|
//
|
|
|
|
// FIXME2: This is extremely dubious for several reasons, not the least of
|
|
|
|
// which it gives special status to instructions with patterns that Pat<>
|
|
|
|
// nodes can't duplicate.
|
|
|
|
const TreePatternNode *InstPatNode = GetInstPatternNode(Inst, N);
|
|
|
|
|
|
|
|
// NodeHasChain - Whether the instruction node we're creating takes chains.
|
|
|
|
bool NodeHasChain = InstPatNode &&
|
|
|
|
InstPatNode->TreeHasProperty(SDNPHasChain, CGP);
|
2010-02-18 06:47:49 +00:00
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
bool isRoot = N == Pattern.getDstPattern();
|
|
|
|
|
2010-02-24 05:33:42 +00:00
|
|
|
// TreeHasOutFlag - True if this tree has a flag.
|
|
|
|
bool TreeHasInFlag = false, TreeHasOutFlag = false;
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
if (isRoot) {
|
|
|
|
const TreePatternNode *SrcPat = Pattern.getSrcPattern();
|
2010-02-24 05:33:42 +00:00
|
|
|
TreeHasInFlag = SrcPat->TreeHasProperty(SDNPOptInFlag, CGP) ||
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
SrcPat->TreeHasProperty(SDNPInFlag, CGP);
|
|
|
|
|
|
|
|
// FIXME2: this is checking the entire pattern, not just the node in
|
|
|
|
// question, doing this just for the root seems like a total hack.
|
2010-02-24 05:33:42 +00:00
|
|
|
TreeHasOutFlag = SrcPat->TreeHasProperty(SDNPOutFlag, CGP);
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// NumResults - This is the number of results produced by the instruction in
|
|
|
|
// the "outs" list.
|
2010-02-18 06:47:49 +00:00
|
|
|
unsigned NumResults = Inst.getNumResults();
|
|
|
|
|
|
|
|
// Loop over all of the operands of the instruction pattern, emitting code
|
|
|
|
// to fill them all in. The node 'N' usually has number children equal to
|
|
|
|
// the number of input operands of the instruction. However, in cases
|
|
|
|
// where there are predicate operands for an instruction, we need to fill
|
|
|
|
// in the 'execute always' values. Match up the node operands to the
|
|
|
|
// instruction operands to do this.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
SmallVector<unsigned, 8> InstOps;
|
2010-02-18 06:47:49 +00:00
|
|
|
for (unsigned ChildNo = 0, InstOpNo = NumResults, e = II.OperandList.size();
|
|
|
|
InstOpNo != e; ++InstOpNo) {
|
|
|
|
|
|
|
|
// Determine what to emit for this operand.
|
|
|
|
Record *OperandNode = II.OperandList[InstOpNo].Rec;
|
|
|
|
if ((OperandNode->isSubClassOf("PredicateOperand") ||
|
|
|
|
OperandNode->isSubClassOf("OptionalDefOperand")) &&
|
|
|
|
!CGP.getDefaultOperand(OperandNode).DefaultOps.empty()) {
|
|
|
|
// This is a predicate or optional def operand; emit the
|
|
|
|
// 'default ops' operands.
|
|
|
|
const DAGDefaultOperand &DefaultOp =
|
|
|
|
CGP.getDefaultOperand(II.OperandList[InstOpNo].Rec);
|
|
|
|
for (unsigned i = 0, e = DefaultOp.DefaultOps.size(); i != e; ++i)
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
EmitResultOperand(DefaultOp.DefaultOps[i], InstOps);
|
2010-02-18 06:47:49 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise this is a normal operand or a predicate operand without
|
|
|
|
// 'execute always'; emit it.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
EmitResultOperand(N->getChild(ChildNo), InstOps);
|
2010-02-18 06:47:49 +00:00
|
|
|
++ChildNo;
|
|
|
|
}
|
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// If this node has an input flag or explicitly specified input physregs, we
|
|
|
|
// need to add chained and flagged copyfromreg nodes and materialize the flag
|
|
|
|
// input.
|
|
|
|
if (isRoot && !PhysRegInputs.empty()) {
|
|
|
|
// Emit all of the CopyToReg nodes for the input physical registers. These
|
|
|
|
// occur in patterns like (mul:i8 AL:i8, GR8:i8:$src).
|
|
|
|
for (unsigned i = 0, e = PhysRegInputs.size(); i != e; ++i)
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new EmitCopyToRegMatcher(PhysRegInputs[i].second,
|
2010-03-18 23:57:40 +00:00
|
|
|
PhysRegInputs[i].first));
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// Even if the node has no other flag inputs, the resultant node must be
|
|
|
|
// flagged to the CopyFromReg nodes we just generated.
|
2010-02-24 05:33:42 +00:00
|
|
|
TreeHasInFlag = true;
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
}
|
2010-02-18 06:47:49 +00:00
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// Result order: node results, chain, flags
|
2010-02-18 06:47:49 +00:00
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// Determine the result types.
|
|
|
|
SmallVector<MVT::SimpleValueType, 4> ResultVTs;
|
2010-03-18 23:57:40 +00:00
|
|
|
if (N->getType() != MVT::isVoid) {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// FIXME2: If the node has multiple results, we should add them. For now,
|
|
|
|
// preserve existing behavior?!
|
2010-03-15 06:00:16 +00:00
|
|
|
ResultVTs.push_back(N->getType());
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
}
|
2010-02-18 06:47:49 +00:00
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// If this is the root instruction of a pattern that has physical registers in
|
|
|
|
// its result pattern, add output VTs for them. For example, X86 has:
|
|
|
|
// (set AL, (mul ...))
|
|
|
|
// This also handles implicit results like:
|
|
|
|
// (implicit EFLAGS)
|
|
|
|
if (isRoot && Pattern.getDstRegs().size() != 0) {
|
2010-03-18 23:57:40 +00:00
|
|
|
// If the root came from an implicit def in the instruction handling stuff,
|
|
|
|
// don't re-add it.
|
|
|
|
Record *HandledReg = 0;
|
|
|
|
if (NumResults == 0 && N->getType() != MVT::isVoid &&
|
|
|
|
!II.ImplicitDefs.empty())
|
|
|
|
HandledReg = II.ImplicitDefs[0];
|
|
|
|
|
|
|
|
for (unsigned i = 0; i != Pattern.getDstRegs().size(); ++i) {
|
|
|
|
Record *Reg = Pattern.getDstRegs()[i];
|
|
|
|
if (!Reg->isSubClassOf("Register") || Reg == HandledReg) continue;
|
|
|
|
ResultVTs.push_back(getRegisterValueType(Reg, CGT));
|
|
|
|
}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME2: Instead of using the isVariadic flag on the instruction, we should
|
|
|
|
// have an SDNP that indicates variadicism. The TargetInstrInfo isVariadic
|
|
|
|
// property should be inferred from this when an instruction has a pattern.
|
|
|
|
int NumFixedArityOperands = -1;
|
|
|
|
if (isRoot && II.isVariadic)
|
|
|
|
NumFixedArityOperands = Pattern.getSrcPattern()->getNumChildren();
|
|
|
|
|
|
|
|
// If this is the root node and any of the nodes matched nodes in the input
|
|
|
|
// pattern have MemRefs in them, have the interpreter collect them and plop
|
|
|
|
// them onto this node.
|
|
|
|
//
|
|
|
|
// FIXME3: This is actively incorrect for result patterns where the root of
|
|
|
|
// the pattern is not the memory reference and is also incorrect when the
|
|
|
|
// result pattern has multiple memory-referencing instructions. For example,
|
|
|
|
// in the X86 backend, this pattern causes the memrefs to get attached to the
|
|
|
|
// CVTSS2SDrr instead of the MOVSSrm:
|
|
|
|
//
|
|
|
|
// def : Pat<(extloadf32 addr:$src),
|
|
|
|
// (CVTSS2SDrr (MOVSSrm addr:$src))>;
|
|
|
|
//
|
|
|
|
bool NodeHasMemRefs =
|
|
|
|
isRoot && Pattern.getSrcPattern()->TreeHasProperty(SDNPMemOperand, CGP);
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new EmitNodeMatcher(II.Namespace+"::"+II.TheDef->getName(),
|
2010-02-28 02:31:26 +00:00
|
|
|
ResultVTs.data(), ResultVTs.size(),
|
|
|
|
InstOps.data(), InstOps.size(),
|
2010-02-28 21:53:42 +00:00
|
|
|
NodeHasChain, TreeHasInFlag, TreeHasOutFlag,
|
2010-02-28 02:41:25 +00:00
|
|
|
NodeHasMemRefs, NumFixedArityOperands,
|
|
|
|
NextRecordedOperandNo));
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
2010-02-21 23:54:05 +00:00
|
|
|
// The non-chain and non-flag results of the newly emitted node get recorded.
|
|
|
|
for (unsigned i = 0, e = ResultVTs.size(); i != e; ++i) {
|
|
|
|
if (ResultVTs[i] == MVT::Other || ResultVTs[i] == MVT::Flag) break;
|
2010-02-21 06:03:07 +00:00
|
|
|
OutputOps.push_back(NextRecordedOperandNo++);
|
2010-02-21 23:54:05 +00:00
|
|
|
}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MatcherGen::
|
|
|
|
EmitResultSDNodeXFormAsOperand(const TreePatternNode *N,
|
|
|
|
SmallVectorImpl<unsigned> &ResultOps) {
|
|
|
|
assert(N->getOperator()->isSubClassOf("SDNodeXForm") && "Not SDNodeXForm?");
|
|
|
|
|
|
|
|
// Emit the operand.
|
|
|
|
SmallVector<unsigned, 8> InputOps;
|
|
|
|
|
|
|
|
// FIXME2: Could easily generalize this to support multiple inputs and outputs
|
|
|
|
// to the SDNodeXForm. For now we just support one input and one output like
|
|
|
|
// the old instruction selector.
|
|
|
|
assert(N->getNumChildren() == 1);
|
|
|
|
EmitResultOperand(N->getChild(0), InputOps);
|
|
|
|
|
|
|
|
// The input currently must have produced exactly one result.
|
|
|
|
assert(InputOps.size() == 1 && "Unexpected input to SDNodeXForm");
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new EmitNodeXFormMatcher(InputOps[0], N->getOperator()));
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
ResultOps.push_back(NextRecordedOperandNo++);
|
2010-02-18 06:47:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MatcherGen::EmitResultOperand(const TreePatternNode *N,
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
SmallVectorImpl<unsigned> &ResultOps) {
|
2010-02-18 06:47:49 +00:00
|
|
|
// This is something selected from the pattern we matched.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
if (!N->getName().empty())
|
|
|
|
return EmitResultOfNamedOperand(N, ResultOps);
|
2010-02-18 06:47:49 +00:00
|
|
|
|
|
|
|
if (N->isLeaf())
|
|
|
|
return EmitResultLeafAsOperand(N, ResultOps);
|
|
|
|
|
|
|
|
Record *OpRec = N->getOperator();
|
|
|
|
if (OpRec->isSubClassOf("Instruction"))
|
|
|
|
return EmitResultInstructionAsOperand(N, ResultOps);
|
|
|
|
if (OpRec->isSubClassOf("SDNodeXForm"))
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
return EmitResultSDNodeXFormAsOperand(N, ResultOps);
|
2010-02-18 06:47:49 +00:00
|
|
|
errs() << "Unknown result node to emit code for: " << *N << '\n';
|
|
|
|
throw std::string("Unknown node in result pattern!");
|
|
|
|
}
|
|
|
|
|
|
|
|
void MatcherGen::EmitResultCode() {
|
2010-03-01 22:46:42 +00:00
|
|
|
// Patterns that match nodes with (potentially multiple) chain inputs have to
|
|
|
|
// merge them together into a token factor. This informs the generated code
|
|
|
|
// what all the chained nodes are.
|
|
|
|
if (!MatchedChainNodes.empty())
|
|
|
|
AddMatcher(new EmitMergeInputChainsMatcher
|
|
|
|
(MatchedChainNodes.data(), MatchedChainNodes.size()));
|
|
|
|
|
2010-02-21 23:54:05 +00:00
|
|
|
// Codegen the root of the result pattern, capturing the resulting values.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
SmallVector<unsigned, 8> Ops;
|
2010-02-18 06:47:49 +00:00
|
|
|
EmitResultOperand(Pattern.getDstPattern(), Ops);
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
2010-02-21 23:54:05 +00:00
|
|
|
// At this point, we have however many values the result pattern produces.
|
|
|
|
// However, the input pattern might not need all of these. If there are
|
|
|
|
// excess values at the end (such as condition codes etc) just lop them off.
|
|
|
|
// This doesn't need to worry about flags or chains, just explicit results.
|
|
|
|
//
|
|
|
|
// FIXME2: This doesn't work because there is currently no way to get an
|
|
|
|
// accurate count of the # results the source pattern sets. This is because
|
|
|
|
// of the "parallel" construct in X86 land, which looks like this:
|
|
|
|
//
|
|
|
|
//def : Pat<(parallel (X86and_flag GR8:$src1, GR8:$src2),
|
|
|
|
// (implicit EFLAGS)),
|
|
|
|
// (AND8rr GR8:$src1, GR8:$src2)>;
|
|
|
|
//
|
|
|
|
// This idiom means to match the two-result node X86and_flag (which is
|
|
|
|
// declared as returning a single result, because we can't match multi-result
|
|
|
|
// nodes yet). In this case, we would have to know that the input has two
|
|
|
|
// results. However, mul8r is modelled exactly the same way, but without
|
|
|
|
// implicit defs included. The fix is to support multiple results directly
|
|
|
|
// and eliminate 'parallel'.
|
|
|
|
//
|
|
|
|
// FIXME2: When this is fixed, we should revert the terrible hack in the
|
|
|
|
// OPC_EmitNode code in the interpreter.
|
|
|
|
#if 0
|
|
|
|
const TreePatternNode *Src = Pattern.getSrcPattern();
|
|
|
|
unsigned NumSrcResults = Src->getTypeNum(0) != MVT::isVoid ? 1 : 0;
|
|
|
|
NumSrcResults += Pattern.getDstRegs().size();
|
|
|
|
assert(Ops.size() >= NumSrcResults && "Didn't provide enough results");
|
|
|
|
Ops.resize(NumSrcResults);
|
|
|
|
#endif
|
2010-02-24 05:33:42 +00:00
|
|
|
|
|
|
|
// If the matched pattern covers nodes which define a flag result, emit a node
|
|
|
|
// that tells the matcher about them so that it can update their results.
|
|
|
|
if (!MatchedFlagResultNodes.empty())
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new MarkFlagResultsMatcher(MatchedFlagResultNodes.data(),
|
2010-03-01 01:54:19 +00:00
|
|
|
MatchedFlagResultNodes.size()));
|
2010-02-24 05:33:42 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CompleteMatchMatcher(Ops.data(), Ops.size(), Pattern));
|
2010-02-18 06:47:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-03-01 07:17:40 +00:00
|
|
|
/// ConvertPatternToMatcher - Create the matcher for the specified pattern with
|
|
|
|
/// the specified variant. If the variant number is invalid, this returns null.
|
2010-02-25 02:04:40 +00:00
|
|
|
Matcher *llvm::ConvertPatternToMatcher(const PatternToMatch &Pattern,
|
2010-03-01 07:17:40 +00:00
|
|
|
unsigned Variant,
|
2010-02-28 20:49:53 +00:00
|
|
|
const CodeGenDAGPatterns &CGP) {
|
2010-02-15 08:04:42 +00:00
|
|
|
MatcherGen Gen(Pattern, CGP);
|
|
|
|
|
|
|
|
// Generate the code for the matcher.
|
2010-03-01 07:17:40 +00:00
|
|
|
if (Gen.EmitMatcherCode(Variant))
|
|
|
|
return 0;
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
// FIXME2: Kill extra MoveParent commands at the end of the matcher sequence.
|
|
|
|
// FIXME2: Split result code out to another table, and make the matcher end
|
|
|
|
// with an "Emit <index>" command. This allows result generation stuff to be
|
|
|
|
// shared and factored?
|
|
|
|
|
2010-02-15 08:04:42 +00:00
|
|
|
// If the match succeeds, then we generate Pattern.
|
2010-02-18 06:47:49 +00:00
|
|
|
Gen.EmitResultCode();
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
// Unconditional match.
|
2010-02-18 06:47:49 +00:00
|
|
|
return Gen.GetMatcher();
|
2010-02-15 08:04:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|