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;
|
|
|
|
}
|
|
|
|
|
|
|
|
// In multiple RC's. If the Types of the RC's do not agree, return
|
|
|
|
// MVT::Other. The target is responsible for handling this.
|
|
|
|
if (VT != RC.getValueTypeNum(0))
|
|
|
|
// FIXME2: when does this happen? Abort?
|
|
|
|
return MVT::Other;
|
|
|
|
}
|
|
|
|
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
|
|
|
|
|
|
|
/// 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;
|
|
|
|
|
|
|
|
/// EmittedMergeInputChains - For nodes that match patterns involving
|
|
|
|
/// chains, is set to true if we emitted the "MergeInputChains" operation.
|
|
|
|
bool EmittedMergeInputChains;
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
void EmitMatcherCode();
|
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-02-25 02:04:40 +00:00
|
|
|
EmittedMergeInputChains(false), 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
|
|
|
|
|
|
|
// If there are node predicates for this node, generate their checks.
|
|
|
|
for (unsigned i = 0, e = N->getPredicateFns().size(); i != e; ++i)
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CheckPredicateMatcher(N->getPredicateFns()[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
|
|
|
|
2010-02-15 08:04:42 +00:00
|
|
|
// Direct match against an integer constant.
|
|
|
|
if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue()))
|
2010-02-25 02:04:40 +00:00
|
|
|
return AddMatcher(new CheckIntegerMatcher(II->getValue()));
|
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-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new RecordMatcher("physreg input "+LeafRec->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
|
|
|
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-02-15 08:04:42 +00:00
|
|
|
// Handle complex pattern.
|
|
|
|
const ComplexPattern &CP = CGP.getComplexPattern(LeafRec);
|
2010-02-22 22:18:05 +00:00
|
|
|
|
|
|
|
// If we're at the root of the pattern, we have to check that the opcode
|
|
|
|
// is a one of the ones requested to be matched.
|
|
|
|
if (N == Pattern.getSrcPattern()) {
|
|
|
|
const std::vector<Record*> &OpNodes = CP.getRootNodes();
|
|
|
|
if (OpNodes.size() == 1) {
|
2010-02-27 21:48:43 +00:00
|
|
|
AddMatcher(new CheckOpcodeMatcher(CGP.getSDNodeInfo(OpNodes[0])));
|
2010-02-22 22:18:05 +00:00
|
|
|
} else if (!OpNodes.empty()) {
|
2010-02-27 21:48:43 +00:00
|
|
|
SmallVector<const SDNodeInfo*, 4> OpNames;
|
2010-02-22 22:30:37 +00:00
|
|
|
for (unsigned i = 0, e = OpNodes.size(); i != e; i++)
|
2010-02-27 21:48:43 +00:00
|
|
|
OpNames.push_back(&CGP.getSDNodeInfo(OpNodes[i]));
|
|
|
|
AddMatcher(new CheckMultiOpcodeMatcher(OpNames.data(), OpNames.size()));
|
2010-02-22 22:18:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-22 23:33:44 +00:00
|
|
|
// Emit a CheckComplexPat operation, which does the match (aborting if it
|
|
|
|
// fails) and pushes the matched operands onto the recorded nodes list.
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CheckComplexPatMatcher(CP));
|
2010-02-17 06:08:25 +00:00
|
|
|
|
2010-02-22 23:33:44 +00:00
|
|
|
// Record the right number of operands.
|
|
|
|
NextRecordedOperandNo += CP.getNumOperands();
|
|
|
|
if (CP.hasProperty(SDNPHasChain))
|
|
|
|
++NextRecordedOperandNo; // Chained node operand.
|
|
|
|
|
2010-02-17 06:08:25 +00:00
|
|
|
// 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.
|
|
|
|
if (CP.hasProperty(SDNPHasChain)) {
|
|
|
|
// It is the last operand recorded.
|
|
|
|
assert(NextRecordedOperandNo > 1 &&
|
|
|
|
"Should have recorded input/result chains at least!");
|
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-1);
|
2010-02-17 06:23:39 +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 we need to check chains, do so, see comment for
|
2010-02-17 06:23:39 +00:00
|
|
|
// "NodeHasProperty(SDNPHasChain" below.
|
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 (MatchedChainNodes.size() > 1) {
|
|
|
|
// FIXME2: This is broken, we should eliminate this nonsense completely,
|
2010-02-17 06:23:39 +00:00
|
|
|
// but we want to produce the same selections that the old matcher does
|
|
|
|
// for now.
|
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 PrevOp = MatchedChainNodes[MatchedChainNodes.size()-2];
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CheckChainCompatibleMatcher(PrevOp));
|
2010-02-17 06:23:39 +00:00
|
|
|
}
|
2010-02-17 06:08:25 +00:00
|
|
|
}
|
2010-02-24 05:33:42 +00:00
|
|
|
|
|
|
|
// TODO: Complex patterns can't have output flags, if they did, we'd want
|
|
|
|
// to record them.
|
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.
|
|
|
|
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 there are node predicates for this node, generate their checks.
|
|
|
|
for (unsigned i = 0, e = N->getPredicateFns().size(); i != e; ++i)
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CheckPredicateMatcher(N->getPredicateFns()[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
|
|
|
|
|
|
|
|
|
|
|
// 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() +
|
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
|
|
|
"' chained node"));
|
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
|
|
|
|
|
|
|
// If this is the second (e.g. indbr(load) or store(add(load))) or third
|
|
|
|
// input chain (e.g. (store (add (load, load))) from msp430) we need to make
|
|
|
|
// sure that folding the chain won't induce cycles in the DAG. This could
|
|
|
|
// happen if there were an intermediate node between the indbr and load, for
|
|
|
|
// example.
|
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 (MatchedChainNodes.size() > 1) {
|
|
|
|
// FIXME2: This is broken, we should eliminate this nonsense completely,
|
2010-02-17 06:23:39 +00:00
|
|
|
// but we want to produce the same selections that the old matcher does
|
|
|
|
// for now.
|
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 PrevOp = MatchedChainNodes[MatchedChainNodes.size()-2];
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CheckChainCompatibleMatcher(PrevOp));
|
2010-02-17 06:23:39 +00:00
|
|
|
}
|
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-02-24 05:33:42 +00:00
|
|
|
"' flag output node"));
|
|
|
|
// 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.
|
|
|
|
if (NodeNoTypes->getExtTypes() != N->getExtTypes()) {
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new CheckTypeMatcher(N->getTypeNum(0)));
|
2010-02-15 08:04:42 +00:00
|
|
|
NodeNoTypes->setTypes(N->getExtTypes());
|
|
|
|
InferPossibleTypes();
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
VarMapEntry = ++NextRecordedOperandNo;
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new RecordMatcher("$" + N->getName()));
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MatcherGen::EmitMatcherCode() {
|
|
|
|
// If the pattern has a predicate on it (e.g. only enabled when a subtarget
|
|
|
|
// feature is around, do the check).
|
2010-02-25 00:03:03 +00:00
|
|
|
// FIXME: This should get emitted after the match code below to encourage
|
|
|
|
// sharing. This can't happen until we get an X86ISD::AddrMode node made by
|
|
|
|
// dag combine, eliminating the horrible side-effect-full stuff from
|
|
|
|
// X86's MatchAddress.
|
2010-02-15 08:04:42 +00:00
|
|
|
if (!Pattern.getPredicateCheck().empty())
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new
|
|
|
|
CheckPatternPredicateMatcher(Pattern.getPredicateCheck()));
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
// Emit the matcher for the pattern structure and types.
|
|
|
|
EmitMatchCode(Pattern.getSrcPattern(), PatWithNoTypes);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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!");
|
|
|
|
|
|
|
|
unsigned SlotNo = getNamedArgumentSlot(N->getName());
|
|
|
|
|
|
|
|
// 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-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-02-22 23:33:44 +00:00
|
|
|
ResultOps.push_back(SlotNo+i+1);
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new EmitIntegerMatcher(II->getValue(),N->getTypeNum(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
|
|
|
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-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new EmitRegisterMatcher(DI->getDef(),
|
2010-02-18 22:03:03 +00:00
|
|
|
N->getTypeNum(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
|
|
|
ResultOps.push_back(NextRecordedOperandNo++);
|
2010-02-18 22:03:03 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DI->getDef()->getName() == "zero_reg") {
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new EmitRegisterMatcher(0, N->getTypeNum(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
|
|
|
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
|
|
|
// Nodes that match patterns with (potentially multiple) chain inputs have to
|
|
|
|
// merge them together into a token factor.
|
|
|
|
if (NodeHasChain && !EmittedMergeInputChains) {
|
|
|
|
// FIXME2: Move this out of emitresult to a top level place.
|
|
|
|
assert(!MatchedChainNodes.empty() &&
|
|
|
|
"How can this node have chain if no inputs do?");
|
|
|
|
// Otherwise, we have to emit an operation to merge the input chains and
|
|
|
|
// set this as the current input chain.
|
2010-02-25 02:04:40 +00:00
|
|
|
AddMatcher(new EmitMergeInputChainsMatcher
|
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.data(), MatchedChainNodes.size()));
|
|
|
|
EmittedMergeInputChains = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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,
|
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[i].first));
|
|
|
|
// 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-02-21 23:54:05 +00:00
|
|
|
if (NumResults != 0 && N->getTypeNum(0) != 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?!
|
|
|
|
ResultVTs.push_back(N->getTypeNum(0));
|
|
|
|
}
|
|
|
|
|
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) {
|
|
|
|
for (unsigned i = 0; i != Pattern.getDstRegs().size(); ++i)
|
|
|
|
if (Pattern.getDstRegs()[i]->isSubClassOf("Register"))
|
|
|
|
ResultVTs.push_back(getRegisterValueType(Pattern.getDstRegs()[i], CGT));
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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-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-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
|
|
|
// We know that the resulting pattern has exactly one result/
|
|
|
|
// FIXME2: why? what about something like (set a,b,c, (complexpat))
|
|
|
|
// FIXME2: Implicit results should be pushed here I guess?
|
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-02-25 02:04:40 +00:00
|
|
|
Matcher *llvm::ConvertPatternToMatcher(const PatternToMatch &Pattern,
|
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.
|
|
|
|
Gen.EmitMatcherCode();
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|