2005-09-07 23:44:43 +00:00
|
|
|
//===- DAGISelEmitter.cpp - Generate an instruction selector --------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:37:13 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-09-07 23:44:43 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This tablegen backend emits a DAG instruction selector.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "DAGISelEmitter.h"
|
2010-02-15 08:04:42 +00:00
|
|
|
#include "DAGISelMatcher.h"
|
2005-09-07 23:44:43 +00:00
|
|
|
#include "Record.h"
|
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2008-10-27 21:56:29 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2005-09-07 23:44:43 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2006-10-11 03:35:34 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2008-10-27 21:56:29 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2005-09-25 19:04:43 +00:00
|
|
|
#include <algorithm>
|
2008-07-07 21:00:17 +00:00
|
|
|
#include <deque>
|
2009-07-03 00:10:29 +00:00
|
|
|
#include <iostream>
|
2005-09-07 23:44:43 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2009-08-07 22:27:19 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
GenDebug("gen-debug", cl::desc("Generate debug code"), cl::init(false));
|
2008-10-27 21:56:29 +00:00
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2008-01-05 22:43:57 +00:00
|
|
|
// DAGISelEmitter Helper methods
|
2005-09-07 23:44:43 +00:00
|
|
|
//
|
|
|
|
|
2010-01-05 01:24:18 +00:00
|
|
|
/// getNodeName - The top level Select_* functions have an "SDNode* N"
|
|
|
|
/// argument. When expanding the pattern-matching code, the intermediate
|
|
|
|
/// variables have type SDValue. This function provides a uniform way to
|
|
|
|
/// reference the underlying "SDNode *" for both cases.
|
|
|
|
static std::string getNodeName(const std::string &S) {
|
|
|
|
if (S == "N") return S;
|
|
|
|
return S + ".getNode()";
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getNodeValue - Similar to getNodeName, except it provides a uniform
|
|
|
|
/// way to access the SDValue for both cases.
|
|
|
|
static std::string getValueName(const std::string &S) {
|
|
|
|
if (S == "N") return "SDValue(N, 0)";
|
|
|
|
return S;
|
|
|
|
}
|
|
|
|
|
2008-01-05 22:25:12 +00:00
|
|
|
/// NodeIsComplexPattern - return true if N is a leaf node and a subclass of
|
|
|
|
/// ComplexPattern.
|
|
|
|
static bool NodeIsComplexPattern(TreePatternNode *N) {
|
2005-12-08 02:00:36 +00:00
|
|
|
return (N->isLeaf() &&
|
|
|
|
dynamic_cast<DefInit*>(N->getLeafValue()) &&
|
|
|
|
static_cast<DefInit*>(N->getLeafValue())->getDef()->
|
|
|
|
isSubClassOf("ComplexPattern"));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-09-28 17:57:56 +00:00
|
|
|
/// getPatternSize - Return the 'size' of this pattern. We want to match large
|
|
|
|
/// patterns before small ones. This is used to determine the size of a
|
|
|
|
/// pattern.
|
2008-01-06 01:10:31 +00:00
|
|
|
static unsigned getPatternSize(TreePatternNode *P, CodeGenDAGPatterns &CGP) {
|
2009-08-10 22:56:29 +00:00
|
|
|
assert((EEVT::isExtIntegerInVTs(P->getExtTypes()) ||
|
|
|
|
EEVT::isExtFloatingPointInVTs(P->getExtTypes()) ||
|
2009-08-11 20:47:22 +00:00
|
|
|
P->getExtTypeNum(0) == MVT::isVoid ||
|
|
|
|
P->getExtTypeNum(0) == MVT::Flag ||
|
|
|
|
P->getExtTypeNum(0) == MVT::iPTR ||
|
|
|
|
P->getExtTypeNum(0) == MVT::iPTRAny) &&
|
2006-01-06 22:19:44 +00:00
|
|
|
"Not a valid pattern node to size!");
|
2006-09-08 07:26:39 +00:00
|
|
|
unsigned Size = 3; // The node itself.
|
2006-02-01 06:06:31 +00:00
|
|
|
// If the root node is a ConstantSDNode, increases its size.
|
|
|
|
// e.g. (set R32:$dst, 0).
|
|
|
|
if (P->isLeaf() && dynamic_cast<IntInit*>(P->getLeafValue()))
|
2006-09-08 07:26:39 +00:00
|
|
|
Size += 2;
|
2005-12-08 02:00:36 +00:00
|
|
|
|
|
|
|
// FIXME: This is a hack to statically increase the priority of patterns
|
|
|
|
// which maps a sub-dag to a complex pattern. e.g. favors LEA over ADD.
|
|
|
|
// Later we can allow complexity / cost for each pattern to be (optionally)
|
|
|
|
// specified. To get best possible pattern match we'll need to dynamically
|
|
|
|
// calculate the complexity of all patterns a dag can potentially map to.
|
2010-02-14 22:22:58 +00:00
|
|
|
const ComplexPattern *AM = P->getComplexPatternInfo(CGP);
|
2005-12-08 02:00:36 +00:00
|
|
|
if (AM)
|
2006-09-08 07:26:39 +00:00
|
|
|
Size += AM->getNumOperands() * 3;
|
2006-02-03 18:06:02 +00:00
|
|
|
|
|
|
|
// If this node has some predicate function that must match, it adds to the
|
|
|
|
// complexity of this node.
|
2008-10-15 06:17:21 +00:00
|
|
|
if (!P->getPredicateFns().empty())
|
2006-02-03 18:06:02 +00:00
|
|
|
++Size;
|
|
|
|
|
2005-09-28 17:57:56 +00:00
|
|
|
// Count children in the count if they are also nodes.
|
|
|
|
for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) {
|
|
|
|
TreePatternNode *Child = P->getChild(i);
|
2009-08-11 20:47:22 +00:00
|
|
|
if (!Child->isLeaf() && Child->getExtTypeNum(0) != MVT::Other)
|
2008-01-05 22:25:12 +00:00
|
|
|
Size += getPatternSize(Child, CGP);
|
2005-12-08 02:00:36 +00:00
|
|
|
else if (Child->isLeaf()) {
|
|
|
|
if (dynamic_cast<IntInit*>(Child->getLeafValue()))
|
2006-09-08 07:26:39 +00:00
|
|
|
Size += 5; // Matches a ConstantSDNode (+3) and a specific value (+2).
|
2006-01-06 22:19:44 +00:00
|
|
|
else if (NodeIsComplexPattern(Child))
|
2008-01-05 22:25:12 +00:00
|
|
|
Size += getPatternSize(Child, CGP);
|
2008-10-15 06:17:21 +00:00
|
|
|
else if (!Child->getPredicateFns().empty())
|
2006-02-03 18:06:02 +00:00
|
|
|
++Size;
|
2005-10-19 04:41:05 +00:00
|
|
|
}
|
2005-09-28 17:57:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return Size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getResultPatternCost - Compute the number of instructions for this pattern.
|
|
|
|
/// This is a temporary hack. We should really include the instruction
|
|
|
|
/// latencies in this calculation.
|
2008-01-05 22:25:12 +00:00
|
|
|
static unsigned getResultPatternCost(TreePatternNode *P,
|
2008-01-06 01:10:31 +00:00
|
|
|
CodeGenDAGPatterns &CGP) {
|
2005-09-28 17:57:56 +00:00
|
|
|
if (P->isLeaf()) return 0;
|
|
|
|
|
2006-02-18 02:33:09 +00:00
|
|
|
unsigned Cost = 0;
|
|
|
|
Record *Op = P->getOperator();
|
|
|
|
if (Op->isSubClassOf("Instruction")) {
|
|
|
|
Cost++;
|
2008-01-05 22:25:12 +00:00
|
|
|
CodeGenInstruction &II = CGP.getTargetInfo().getInstruction(Op->getName());
|
2009-10-29 18:10:34 +00:00
|
|
|
if (II.usesCustomInserter)
|
2006-02-18 02:33:09 +00:00
|
|
|
Cost += 10;
|
|
|
|
}
|
2005-09-28 17:57:56 +00:00
|
|
|
for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i)
|
2008-01-05 22:25:12 +00:00
|
|
|
Cost += getResultPatternCost(P->getChild(i), CGP);
|
2005-09-28 17:57:56 +00:00
|
|
|
return Cost;
|
|
|
|
}
|
|
|
|
|
2006-07-19 00:24:41 +00:00
|
|
|
/// getResultPatternCodeSize - Compute the code size of instructions for this
|
|
|
|
/// pattern.
|
2008-01-05 22:25:12 +00:00
|
|
|
static unsigned getResultPatternSize(TreePatternNode *P,
|
2008-01-06 01:10:31 +00:00
|
|
|
CodeGenDAGPatterns &CGP) {
|
2006-07-19 00:24:41 +00:00
|
|
|
if (P->isLeaf()) return 0;
|
|
|
|
|
|
|
|
unsigned Cost = 0;
|
|
|
|
Record *Op = P->getOperator();
|
|
|
|
if (Op->isSubClassOf("Instruction")) {
|
|
|
|
Cost += Op->getValueAsInt("CodeSize");
|
|
|
|
}
|
|
|
|
for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i)
|
2008-01-05 22:25:12 +00:00
|
|
|
Cost += getResultPatternSize(P->getChild(i), CGP);
|
2006-07-19 00:24:41 +00:00
|
|
|
return Cost;
|
|
|
|
}
|
|
|
|
|
2005-09-28 17:57:56 +00:00
|
|
|
// PatternSortingPredicate - return true if we prefer to match LHS before RHS.
|
|
|
|
// In particular, we want to match maximal patterns first and lowest cost within
|
|
|
|
// a particular complexity first.
|
|
|
|
struct PatternSortingPredicate {
|
2008-01-06 01:10:31 +00:00
|
|
|
PatternSortingPredicate(CodeGenDAGPatterns &cgp) : CGP(cgp) {}
|
|
|
|
CodeGenDAGPatterns &CGP;
|
2005-12-08 02:00:36 +00:00
|
|
|
|
2008-10-15 06:17:21 +00:00
|
|
|
typedef std::pair<unsigned, std::string> CodeLine;
|
|
|
|
typedef std::vector<CodeLine> CodeList;
|
|
|
|
typedef std::vector<std::pair<const PatternToMatch*, CodeList> > PatternList;
|
|
|
|
|
|
|
|
bool operator()(const std::pair<const PatternToMatch*, CodeList> &LHSPair,
|
|
|
|
const std::pair<const PatternToMatch*, CodeList> &RHSPair) {
|
|
|
|
const PatternToMatch *LHS = LHSPair.first;
|
|
|
|
const PatternToMatch *RHS = RHSPair.first;
|
|
|
|
|
2008-01-05 22:25:12 +00:00
|
|
|
unsigned LHSSize = getPatternSize(LHS->getSrcPattern(), CGP);
|
|
|
|
unsigned RHSSize = getPatternSize(RHS->getSrcPattern(), CGP);
|
2006-04-19 20:36:09 +00:00
|
|
|
LHSSize += LHS->getAddedComplexity();
|
|
|
|
RHSSize += RHS->getAddedComplexity();
|
2005-09-28 17:57:56 +00:00
|
|
|
if (LHSSize > RHSSize) return true; // LHS -> bigger -> less cost
|
|
|
|
if (LHSSize < RHSSize) return false;
|
|
|
|
|
|
|
|
// If the patterns have equal complexity, compare generated instruction cost
|
2008-01-05 22:25:12 +00:00
|
|
|
unsigned LHSCost = getResultPatternCost(LHS->getDstPattern(), CGP);
|
|
|
|
unsigned RHSCost = getResultPatternCost(RHS->getDstPattern(), CGP);
|
2006-07-19 00:24:41 +00:00
|
|
|
if (LHSCost < RHSCost) return true;
|
|
|
|
if (LHSCost > RHSCost) return false;
|
|
|
|
|
2008-01-05 22:25:12 +00:00
|
|
|
return getResultPatternSize(LHS->getDstPattern(), CGP) <
|
|
|
|
getResultPatternSize(RHS->getDstPattern(), CGP);
|
2005-09-28 17:57:56 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-03-25 23:28:33 +00:00
|
|
|
/// getRegisterValueType - Look up and return the ValueType of the specified
|
|
|
|
/// register. If the register is a member of multiple register classes which
|
2009-08-11 20:47:22 +00:00
|
|
|
/// have different associated types, return MVT::Other.
|
|
|
|
static MVT::SimpleValueType getRegisterValueType(Record *R, const CodeGenTarget &T) {
|
2009-03-26 14:45:34 +00:00
|
|
|
bool FoundRC = false;
|
2009-08-11 20:47:22 +00:00
|
|
|
MVT::SimpleValueType VT = MVT::Other;
|
2009-03-25 23:28:33 +00:00
|
|
|
const std::vector<CodeGenRegisterClass> &RCs = T.getRegisterClasses();
|
|
|
|
std::vector<CodeGenRegisterClass>::const_iterator RC;
|
|
|
|
std::vector<Record*>::const_iterator Element;
|
|
|
|
|
|
|
|
for (RC = RCs.begin() ; RC != RCs.end() ; RC++) {
|
|
|
|
Element = find((*RC).Elements.begin(), (*RC).Elements.end(), R);
|
|
|
|
if (Element != (*RC).Elements.end()) {
|
|
|
|
if (!FoundRC) {
|
2009-03-26 14:45:34 +00:00
|
|
|
FoundRC = true;
|
2009-03-25 23:28:33 +00:00
|
|
|
VT = (*RC).getValueTypeNum(0);
|
|
|
|
} else {
|
|
|
|
// In multiple RC's
|
|
|
|
if (VT != (*RC).getValueTypeNum(0)) {
|
2009-08-11 20:47:22 +00:00
|
|
|
// Types of the RC's do not agree. Return MVT::Other. The
|
2009-03-25 23:28:33 +00:00
|
|
|
// target is responsible for handling this.
|
2009-08-11 20:47:22 +00:00
|
|
|
return MVT::Other;
|
2009-03-25 23:28:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return VT;
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
|
|
|
|
2008-07-03 08:39:51 +00:00
|
|
|
static std::string getOpcodeName(Record *Op, CodeGenDAGPatterns &CGP) {
|
|
|
|
return CGP.getSDNodeInfo(Op).getEnumName();
|
|
|
|
}
|
|
|
|
|
2008-01-05 22:54:53 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Node Transformation emitter implementation.
|
|
|
|
//
|
2009-07-03 00:10:29 +00:00
|
|
|
void DAGISelEmitter::EmitNodeTransforms(raw_ostream &OS) {
|
2008-01-05 22:54:53 +00:00
|
|
|
// Walk the pattern fragments, adding them to a map, which sorts them by
|
|
|
|
// name.
|
2008-01-06 01:10:31 +00:00
|
|
|
typedef std::map<std::string, CodeGenDAGPatterns::NodeXForm> NXsByNameTy;
|
2008-01-05 22:54:53 +00:00
|
|
|
NXsByNameTy NXsByName;
|
|
|
|
|
2008-01-06 01:10:31 +00:00
|
|
|
for (CodeGenDAGPatterns::nx_iterator I = CGP.nx_begin(), E = CGP.nx_end();
|
2008-01-05 22:54:53 +00:00
|
|
|
I != E; ++I)
|
|
|
|
NXsByName.insert(std::make_pair(I->first->getName(), I->second));
|
|
|
|
|
|
|
|
OS << "\n// Node transformations.\n";
|
|
|
|
|
|
|
|
for (NXsByNameTy::iterator I = NXsByName.begin(), E = NXsByName.end();
|
|
|
|
I != E; ++I) {
|
|
|
|
Record *SDNode = I->second.first;
|
|
|
|
std::string Code = I->second.second;
|
|
|
|
|
|
|
|
if (Code.empty()) continue; // Empty code? Skip it.
|
|
|
|
|
2008-01-05 22:58:54 +00:00
|
|
|
std::string ClassName = CGP.getSDNodeInfo(SDNode).getSDClassName();
|
2008-01-05 22:54:53 +00:00
|
|
|
const char *C2 = ClassName == "SDNode" ? "N" : "inN";
|
|
|
|
|
2008-07-27 21:46:04 +00:00
|
|
|
OS << "inline SDValue Transform_" << I->first << "(SDNode *" << C2
|
2008-01-05 22:54:53 +00:00
|
|
|
<< ") {\n";
|
|
|
|
if (ClassName != "SDNode")
|
|
|
|
OS << " " << ClassName << " *N = cast<" << ClassName << ">(inN);\n";
|
|
|
|
OS << Code << "\n}\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-05 22:43:57 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Predicate emitter implementation.
|
|
|
|
//
|
|
|
|
|
2009-07-03 00:10:29 +00:00
|
|
|
void DAGISelEmitter::EmitPredicateFunctions(raw_ostream &OS) {
|
2008-01-05 22:43:57 +00:00
|
|
|
OS << "\n// Predicate functions.\n";
|
|
|
|
|
|
|
|
// Walk the pattern fragments, adding them to a map, which sorts them by
|
|
|
|
// name.
|
|
|
|
typedef std::map<std::string, std::pair<Record*, TreePattern*> > PFsByNameTy;
|
|
|
|
PFsByNameTy PFsByName;
|
|
|
|
|
2008-01-06 01:10:31 +00:00
|
|
|
for (CodeGenDAGPatterns::pf_iterator I = CGP.pf_begin(), E = CGP.pf_end();
|
2008-01-05 22:43:57 +00:00
|
|
|
I != E; ++I)
|
|
|
|
PFsByName.insert(std::make_pair(I->first->getName(), *I));
|
|
|
|
|
|
|
|
|
|
|
|
for (PFsByNameTy::iterator I = PFsByName.begin(), E = PFsByName.end();
|
|
|
|
I != E; ++I) {
|
|
|
|
Record *PatFragRecord = I->second.first;// Record that derives from PatFrag.
|
|
|
|
TreePattern *P = I->second.second;
|
|
|
|
|
|
|
|
// If there is a code init for this fragment, emit the predicate code.
|
|
|
|
std::string Code = PatFragRecord->getValueAsCode("Predicate");
|
|
|
|
if (Code.empty()) continue;
|
|
|
|
|
|
|
|
if (P->getOnlyTree()->isLeaf())
|
|
|
|
OS << "inline bool Predicate_" << PatFragRecord->getName()
|
|
|
|
<< "(SDNode *N) {\n";
|
|
|
|
else {
|
|
|
|
std::string ClassName =
|
2008-01-05 22:58:54 +00:00
|
|
|
CGP.getSDNodeInfo(P->getOnlyTree()->getOperator()).getSDClassName();
|
2008-01-05 22:43:57 +00:00
|
|
|
const char *C2 = ClassName == "SDNode" ? "N" : "inN";
|
|
|
|
|
|
|
|
OS << "inline bool Predicate_" << PatFragRecord->getName()
|
|
|
|
<< "(SDNode *" << C2 << ") {\n";
|
|
|
|
if (ClassName != "SDNode")
|
|
|
|
OS << " " << ClassName << " *N = cast<" << ClassName << ">(inN);\n";
|
|
|
|
}
|
|
|
|
OS << Code << "\n}\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
OS << "\n\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PatternCodeEmitter implementation.
|
|
|
|
//
|
2005-12-09 22:45:35 +00:00
|
|
|
class PatternCodeEmitter {
|
|
|
|
private:
|
2008-01-06 01:10:31 +00:00
|
|
|
CodeGenDAGPatterns &CGP;
|
2005-12-09 22:45:35 +00:00
|
|
|
|
2005-12-14 22:02:59 +00:00
|
|
|
// Predicates.
|
2008-08-22 00:20:26 +00:00
|
|
|
std::string PredicateCheck;
|
2006-04-19 18:07:24 +00:00
|
|
|
// Pattern cost.
|
|
|
|
unsigned Cost;
|
2005-12-14 22:02:59 +00:00
|
|
|
// Instruction selector pattern.
|
|
|
|
TreePatternNode *Pattern;
|
|
|
|
// Matched instruction.
|
|
|
|
TreePatternNode *Instruction;
|
2006-01-28 20:31:24 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
// Node to name mapping
|
2006-01-12 19:35:54 +00:00
|
|
|
std::map<std::string, std::string> VariableMap;
|
|
|
|
// Node to operator mapping
|
|
|
|
std::map<std::string, Record*> OperatorMap;
|
2008-02-05 22:50:29 +00:00
|
|
|
// Name of the folded node which produces a flag.
|
|
|
|
std::pair<std::string, unsigned> FoldedFlag;
|
2005-12-09 22:45:35 +00:00
|
|
|
// Names of all the folded nodes which produce chains.
|
2005-12-19 07:18:51 +00:00
|
|
|
std::vector<std::pair<std::string, unsigned> > FoldedChains;
|
2006-10-12 02:08:53 +00:00
|
|
|
// Original input chain(s).
|
|
|
|
std::vector<std::pair<std::string, std::string> > OrigChains;
|
2006-01-19 01:55:45 +00:00
|
|
|
std::set<std::string> Duplicates;
|
2005-12-09 22:45:35 +00:00
|
|
|
|
2008-02-06 22:27:42 +00:00
|
|
|
/// LSI - Load/Store information.
|
|
|
|
/// Save loads/stores matched by a pattern, and generate a MemOperandSDNode
|
|
|
|
/// for each memory access. This facilitates the use of AliasAnalysis in
|
|
|
|
/// the backend.
|
|
|
|
std::vector<std::string> LSI;
|
|
|
|
|
2006-08-26 00:59:04 +00:00
|
|
|
/// GeneratedCode - This is the buffer that we emit code to. The first int
|
2006-01-28 20:31:24 +00:00
|
|
|
/// indicates whether this is an exit predicate (something that should be
|
2006-08-26 00:59:04 +00:00
|
|
|
/// tested, and if true, the match fails) [when 1], or normal code to emit
|
|
|
|
/// [when 0], or initialization code to emit [when 2].
|
|
|
|
std::vector<std::pair<unsigned, std::string> > &GeneratedCode;
|
2008-07-27 21:46:04 +00:00
|
|
|
/// GeneratedDecl - This is the set of all SDValue declarations needed for
|
2006-02-07 00:37:41 +00:00
|
|
|
/// the set of patterns for each top-level opcode.
|
2006-08-26 01:02:19 +00:00
|
|
|
std::set<std::string> &GeneratedDecl;
|
2006-07-15 08:45:20 +00:00
|
|
|
/// TargetOpcodes - The target specific opcodes used by the resulting
|
|
|
|
/// instructions.
|
|
|
|
std::vector<std::string> &TargetOpcodes;
|
2006-07-16 06:12:52 +00:00
|
|
|
std::vector<std::string> &TargetVTs;
|
2008-05-31 02:11:25 +00:00
|
|
|
/// OutputIsVariadic - Records whether the instruction output pattern uses
|
|
|
|
/// variable_ops. This requires that the Emit function be passed an
|
|
|
|
/// additional argument to indicate where the input varargs operands
|
|
|
|
/// begin.
|
|
|
|
bool &OutputIsVariadic;
|
|
|
|
/// NumInputRootOps - Records the number of operands the root node of the
|
|
|
|
/// input pattern has. This information is used in the generated code to
|
|
|
|
/// pass to Emit functions when variable_ops processing is needed.
|
|
|
|
unsigned &NumInputRootOps;
|
2006-01-28 20:31:24 +00:00
|
|
|
|
2006-02-03 06:22:41 +00:00
|
|
|
std::string ChainName;
|
2006-01-28 20:31:24 +00:00
|
|
|
unsigned TmpNo;
|
2006-07-15 08:45:20 +00:00
|
|
|
unsigned OpcNo;
|
2006-07-16 06:12:52 +00:00
|
|
|
unsigned VTNo;
|
2006-01-28 20:31:24 +00:00
|
|
|
|
|
|
|
void emitCheck(const std::string &S) {
|
|
|
|
if (!S.empty())
|
2006-08-26 00:59:04 +00:00
|
|
|
GeneratedCode.push_back(std::make_pair(1, S));
|
2006-01-28 20:31:24 +00:00
|
|
|
}
|
|
|
|
void emitCode(const std::string &S) {
|
|
|
|
if (!S.empty())
|
2006-08-26 00:59:04 +00:00
|
|
|
GeneratedCode.push_back(std::make_pair(0, S));
|
|
|
|
}
|
|
|
|
void emitInit(const std::string &S) {
|
|
|
|
if (!S.empty())
|
|
|
|
GeneratedCode.push_back(std::make_pair(2, S));
|
2006-01-28 20:31:24 +00:00
|
|
|
}
|
2006-08-26 01:02:19 +00:00
|
|
|
void emitDecl(const std::string &S) {
|
2006-02-07 00:37:41 +00:00
|
|
|
assert(!S.empty() && "Invalid declaration");
|
2006-08-26 01:02:19 +00:00
|
|
|
GeneratedDecl.insert(S);
|
2006-02-07 00:37:41 +00:00
|
|
|
}
|
2006-07-15 08:45:20 +00:00
|
|
|
void emitOpcode(const std::string &Opc) {
|
|
|
|
TargetOpcodes.push_back(Opc);
|
|
|
|
OpcNo++;
|
|
|
|
}
|
2006-07-16 06:12:52 +00:00
|
|
|
void emitVT(const std::string &VT) {
|
|
|
|
TargetVTs.push_back(VT);
|
|
|
|
VTNo++;
|
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
public:
|
2008-08-22 00:20:26 +00:00
|
|
|
PatternCodeEmitter(CodeGenDAGPatterns &cgp, std::string predcheck,
|
2005-12-14 22:02:59 +00:00
|
|
|
TreePatternNode *pattern, TreePatternNode *instr,
|
2006-08-26 00:59:04 +00:00
|
|
|
std::vector<std::pair<unsigned, std::string> > &gc,
|
2006-08-26 01:02:19 +00:00
|
|
|
std::set<std::string> &gd,
|
2006-07-15 08:45:20 +00:00
|
|
|
std::vector<std::string> &to,
|
2008-05-31 02:11:25 +00:00
|
|
|
std::vector<std::string> &tv,
|
|
|
|
bool &oiv,
|
|
|
|
unsigned &niro)
|
2008-08-22 00:20:26 +00:00
|
|
|
: CGP(cgp), PredicateCheck(predcheck), Pattern(pattern), Instruction(instr),
|
2006-08-26 00:59:04 +00:00
|
|
|
GeneratedCode(gc), GeneratedDecl(gd),
|
|
|
|
TargetOpcodes(to), TargetVTs(tv),
|
2008-05-31 02:11:25 +00:00
|
|
|
OutputIsVariadic(oiv), NumInputRootOps(niro),
|
2006-08-09 16:44:44 +00:00
|
|
|
TmpNo(0), OpcNo(0), VTNo(0) {}
|
2005-12-21 05:31:05 +00:00
|
|
|
|
2005-12-09 22:45:35 +00:00
|
|
|
/// EmitMatchCode - Emit a matcher for N, going to the label for PatternNo
|
|
|
|
/// if the match fails. At this point, we already know that the opcode for N
|
|
|
|
/// matches, and the SDNode for the result has the RootName specified name.
|
2006-10-16 06:33:44 +00:00
|
|
|
void EmitMatchCode(TreePatternNode *N, TreePatternNode *P,
|
|
|
|
const std::string &RootName, const std::string &ChainSuffix,
|
2010-02-13 20:06:50 +00:00
|
|
|
bool &FoundChain);
|
2008-02-06 22:27:42 +00:00
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
void EmitChildMatchCode(TreePatternNode *Child, TreePatternNode *Parent,
|
|
|
|
const std::string &RootName,
|
|
|
|
const std::string &ChainSuffix, bool &FoundChain);
|
2008-07-03 08:39:51 +00:00
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
/// EmitResultCode - Emit the action for a pattern. Now that it has matched
|
|
|
|
/// we actually have to build a DAG!
|
|
|
|
std::vector<std::string>
|
|
|
|
EmitResultCode(TreePatternNode *N, std::vector<Record*> DstRegs,
|
|
|
|
bool InFlagDecled, bool ResNodeDecled,
|
|
|
|
bool LikeLeaf = false, bool isRoot = false);
|
2005-12-14 22:02:59 +00:00
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
/// InsertOneTypeCheck - Insert a type-check for an unresolved type in 'Pat'
|
|
|
|
/// and add it to the tree. 'Pat' and 'Other' are isomorphic trees except that
|
|
|
|
/// 'Pat' may be missing types. If we find an unresolved type to add a check
|
|
|
|
/// for, this returns true otherwise false if Pat has all types.
|
|
|
|
bool InsertOneTypeCheck(TreePatternNode *Pat, TreePatternNode *Other,
|
|
|
|
const std::string &Prefix, bool isRoot = false) {
|
|
|
|
// Did we find one?
|
|
|
|
if (Pat->getExtTypes() != Other->getExtTypes()) {
|
|
|
|
// Move a type over from 'other' to 'pat'.
|
|
|
|
Pat->setTypes(Other->getExtTypes());
|
|
|
|
// The top level node type is checked outside of the select function.
|
|
|
|
if (!isRoot)
|
|
|
|
emitCheck(Prefix + ".getValueType() == " +
|
|
|
|
getName(Pat->getTypeNum(0)));
|
|
|
|
return true;
|
2005-11-02 06:49:14 +00:00
|
|
|
}
|
2005-09-24 00:40:24 +00:00
|
|
|
|
2010-02-14 22:22:58 +00:00
|
|
|
unsigned OpNo = (unsigned)Pat->NodeHasProperty(SDNPHasChain, CGP);
|
2010-02-13 20:06:50 +00:00
|
|
|
for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i, ++OpNo)
|
|
|
|
if (InsertOneTypeCheck(Pat->getChild(i), Other->getChild(i),
|
|
|
|
Prefix + utostr(OpNo)))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2005-12-09 00:48:42 +00:00
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
private:
|
|
|
|
/// EmitInFlagSelectCode - Emit the flag operands for the DAG that is
|
|
|
|
/// being built.
|
|
|
|
void EmitInFlagSelectCode(TreePatternNode *N, const std::string &RootName,
|
|
|
|
bool &ChainEmitted, bool &InFlagDecled,
|
|
|
|
bool &ResNodeDecled, bool isRoot = false) {
|
|
|
|
const CodeGenTarget &T = CGP.getTargetInfo();
|
2010-02-14 22:22:58 +00:00
|
|
|
unsigned OpNo = (unsigned)N->NodeHasProperty(SDNPHasChain, CGP);
|
|
|
|
bool HasInFlag = N->NodeHasProperty(SDNPInFlag, CGP);
|
2010-02-13 20:06:50 +00:00
|
|
|
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i, ++OpNo) {
|
|
|
|
TreePatternNode *Child = N->getChild(i);
|
|
|
|
if (!Child->isLeaf()) {
|
|
|
|
EmitInFlagSelectCode(Child, RootName + utostr(OpNo), ChainEmitted,
|
|
|
|
InFlagDecled, ResNodeDecled);
|
|
|
|
} else {
|
|
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) {
|
|
|
|
if (!Child->getName().empty()) {
|
|
|
|
std::string Name = RootName + utostr(OpNo);
|
|
|
|
if (Duplicates.find(Name) != Duplicates.end())
|
|
|
|
// A duplicate! Do not emit a copy for this node.
|
|
|
|
continue;
|
2006-10-16 06:33:44 +00:00
|
|
|
}
|
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
Record *RR = DI->getDef();
|
|
|
|
if (RR->isSubClassOf("Register")) {
|
|
|
|
MVT::SimpleValueType RVT = getRegisterValueType(RR, T);
|
|
|
|
if (RVT == MVT::Flag) {
|
|
|
|
if (!InFlagDecled) {
|
|
|
|
emitCode("SDValue InFlag = " +
|
|
|
|
getValueName(RootName + utostr(OpNo)) + ";");
|
|
|
|
InFlagDecled = true;
|
|
|
|
} else
|
|
|
|
emitCode("InFlag = " +
|
|
|
|
getValueName(RootName + utostr(OpNo)) + ";");
|
|
|
|
} else {
|
|
|
|
if (!ChainEmitted) {
|
|
|
|
emitCode("SDValue Chain = CurDAG->getEntryNode();");
|
|
|
|
ChainName = "Chain";
|
|
|
|
ChainEmitted = true;
|
|
|
|
}
|
|
|
|
if (!InFlagDecled) {
|
|
|
|
emitCode("SDValue InFlag(0, 0);");
|
|
|
|
InFlagDecled = true;
|
|
|
|
}
|
|
|
|
std::string Decl = (!ResNodeDecled) ? "SDNode *" : "";
|
|
|
|
emitCode(Decl + "ResNode = CurDAG->getCopyToReg(" + ChainName +
|
|
|
|
", " + getNodeName(RootName) + "->getDebugLoc()" +
|
|
|
|
", " + getQualifiedName(RR) +
|
|
|
|
", " + getValueName(RootName + utostr(OpNo)) +
|
|
|
|
", InFlag).getNode();");
|
|
|
|
ResNodeDecled = true;
|
|
|
|
emitCode(ChainName + " = SDValue(ResNode, 0);");
|
|
|
|
emitCode("InFlag = SDValue(ResNode, 1);");
|
|
|
|
}
|
2006-10-11 03:35:34 +00:00
|
|
|
}
|
2006-02-05 06:43:12 +00:00
|
|
|
}
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2005-12-09 00:48:42 +00:00
|
|
|
}
|
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
if (HasInFlag) {
|
|
|
|
if (!InFlagDecled) {
|
|
|
|
emitCode("SDValue InFlag = " + getNodeName(RootName) +
|
|
|
|
"->getOperand(" + utostr(OpNo) + ");");
|
|
|
|
InFlagDecled = true;
|
|
|
|
} else
|
|
|
|
emitCode("InFlag = " + getNodeName(RootName) +
|
|
|
|
"->getOperand(" + utostr(OpNo) + ");");
|
2006-01-26 00:22:25 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2006-01-26 00:22:25 +00:00
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
/// EmitMatchCode - Emit a matcher for N, going to the label for PatternNo
|
|
|
|
/// if the match fails. At this point, we already know that the opcode for N
|
|
|
|
/// matches, and the SDNode for the result has the RootName specified name.
|
|
|
|
void PatternCodeEmitter::EmitMatchCode(TreePatternNode *N, TreePatternNode *P,
|
|
|
|
const std::string &RootName,
|
|
|
|
const std::string &ChainSuffix,
|
|
|
|
bool &FoundChain) {
|
|
|
|
|
|
|
|
// Save loads/stores matched by a pattern.
|
|
|
|
if (!N->isLeaf() && N->getName().empty()) {
|
2010-02-14 22:22:58 +00:00
|
|
|
if (N->NodeHasProperty(SDNPMemOperand, CGP))
|
2010-02-13 20:06:50 +00:00
|
|
|
LSI.push_back(getNodeName(RootName));
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isRoot = (P == NULL);
|
|
|
|
// Emit instruction predicates. Each predicate is just a string for now.
|
|
|
|
if (isRoot) {
|
|
|
|
// Record input varargs info.
|
|
|
|
NumInputRootOps = N->getNumChildren();
|
|
|
|
emitCheck(PredicateCheck);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (N->isLeaf()) {
|
|
|
|
if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
|
|
|
|
emitCheck("cast<ConstantSDNode>(" + getNodeName(RootName) +
|
|
|
|
")->getSExtValue() == INT64_C(" +
|
|
|
|
itostr(II->getValue()) + ")");
|
|
|
|
return;
|
|
|
|
} else if (!NodeIsComplexPattern(N)) {
|
|
|
|
assert(0 && "Cannot match this as a leaf value!");
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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()) {
|
|
|
|
std::string &VarMapEntry = VariableMap[N->getName()];
|
|
|
|
if (VarMapEntry.empty()) {
|
|
|
|
VarMapEntry = RootName;
|
|
|
|
} else {
|
|
|
|
// If we get here, this is a second reference to a specific name. Since
|
|
|
|
// we already have checked that the first reference is valid, we don't
|
|
|
|
// have to recursively match it, just check that it's the same as the
|
|
|
|
// previously named thing.
|
|
|
|
emitCheck(VarMapEntry + " == " + RootName);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!N->isLeaf())
|
|
|
|
OperatorMap[N->getName()] = N->getOperator();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Emit code to load the child nodes and match their contents recursively.
|
|
|
|
unsigned OpNo = 0;
|
2010-02-14 22:22:58 +00:00
|
|
|
bool NodeHasChain = N->NodeHasProperty(SDNPHasChain, CGP);
|
|
|
|
bool HasChain = N->TreeHasProperty(SDNPHasChain, CGP);
|
2010-02-13 20:06:50 +00:00
|
|
|
if (HasChain) {
|
|
|
|
if (NodeHasChain)
|
|
|
|
OpNo = 1;
|
|
|
|
if (!isRoot) {
|
2010-02-15 19:41:07 +00:00
|
|
|
// Check if it's profitable to fold the node. e.g. Check for multiple uses
|
|
|
|
// of actual result?
|
|
|
|
std::string ParentName(RootName.begin(), RootName.end()-1);
|
|
|
|
emitCheck("IsProfitableToFold(" + getValueName(RootName) +
|
|
|
|
", " + getNodeName(ParentName) + ", N)");
|
2010-02-13 20:06:50 +00:00
|
|
|
if (NodeHasChain) {
|
|
|
|
// If the immediate use can somehow reach this node through another
|
|
|
|
// path, then can't fold it either or it will create a cycle.
|
|
|
|
// e.g. In the following diagram, XX can reach ld through YY. If
|
|
|
|
// ld is folded into XX, then YY is both a predecessor and a successor
|
|
|
|
// of XX.
|
|
|
|
//
|
|
|
|
// [ld]
|
|
|
|
// ^ ^
|
|
|
|
// | |
|
|
|
|
// / \---
|
|
|
|
// / [YY]
|
|
|
|
// | ^
|
|
|
|
// [XX]-------|
|
2010-02-16 06:10:58 +00:00
|
|
|
|
|
|
|
// We know we need the check if N's parent is not the root.
|
2010-02-13 20:06:50 +00:00
|
|
|
bool NeedCheck = P != Pattern;
|
|
|
|
if (!NeedCheck) {
|
|
|
|
const SDNodeInfo &PInfo = CGP.getSDNodeInfo(P->getOperator());
|
|
|
|
NeedCheck =
|
|
|
|
P->getOperator() == CGP.get_intrinsic_void_sdnode() ||
|
|
|
|
P->getOperator() == CGP.get_intrinsic_w_chain_sdnode() ||
|
|
|
|
P->getOperator() == CGP.get_intrinsic_wo_chain_sdnode() ||
|
|
|
|
PInfo.getNumOperands() > 1 ||
|
|
|
|
PInfo.hasProperty(SDNPHasChain) ||
|
|
|
|
PInfo.hasProperty(SDNPInFlag) ||
|
|
|
|
PInfo.hasProperty(SDNPOptInFlag);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NeedCheck) {
|
2010-02-15 19:41:07 +00:00
|
|
|
emitCheck("IsLegalToFold(" + getValueName(RootName) +
|
2010-02-13 20:06:50 +00:00
|
|
|
", " + getNodeName(ParentName) + ", N)");
|
Special case tblgen generated code for patterns like (and X, 255) or (or X, 42).
The dag/inst combiners often 'simplify' the masked value based on whether
or not the bits are live or known zero/one. This is good and dandy, but
often causes special case patterns to fail, such as alpha's CMPBGE pattern,
which looks like "(set GPRC:$RC, (setuge (and GPRC:$RA, 255), (and GPRC:$RB, 255)))".
Here the pattern for (and X, 255) should match actual dags like (and X, 254) if
the dag combiner proved that the missing bits are already zero (one for 'or').
For CodeGen/Alpha/cmpbge.ll:test2 for example, this results in:
sll $16,1,$0
cmpbge $0,$17,$0
ret $31,($26),1
instead of:
sll $16,1,$0
and $0,254,$0
and $17,255,$1
cmpule $1,$0,$0
ret $31,($26),1
... and requires no target-specific code.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@30871 91177308-0d34-0410-b5e6-96231b3b80d8
2006-10-11 04:05:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
if (NodeHasChain) {
|
|
|
|
if (FoundChain) {
|
|
|
|
emitCheck("(" + ChainName + ".getNode() == " +
|
|
|
|
getNodeName(RootName) + " || "
|
|
|
|
"IsChainCompatible(" + ChainName + ".getNode(), " +
|
|
|
|
getNodeName(RootName) + "))");
|
|
|
|
OrigChains.push_back(std::make_pair(ChainName,
|
|
|
|
getValueName(RootName)));
|
|
|
|
} else
|
|
|
|
FoundChain = true;
|
|
|
|
ChainName = "Chain" + ChainSuffix;
|
|
|
|
emitInit("SDValue " + ChainName + " = " + getNodeName(RootName) +
|
|
|
|
"->getOperand(0);");
|
2005-09-23 21:33:23 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// If there are node predicates for this, emit the calls.
|
|
|
|
for (unsigned i = 0, e = N->getPredicateFns().size(); i != e; ++i)
|
|
|
|
emitCheck(N->getPredicateFns()[i] + "(" + getNodeName(RootName) + ")");
|
|
|
|
|
|
|
|
// 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->isLeaf() &&
|
|
|
|
(N->getOperator()->getName() == "and" ||
|
|
|
|
N->getOperator()->getName() == "or") &&
|
|
|
|
N->getChild(1)->isLeaf() &&
|
|
|
|
N->getChild(1)->getPredicateFns().empty()) {
|
|
|
|
if (IntInit *II = dynamic_cast<IntInit*>(N->getChild(1)->getLeafValue())) {
|
|
|
|
if (!isPowerOf2_32(II->getValue())) { // Don't bother with single bits.
|
|
|
|
emitInit("SDValue " + RootName + "0" + " = " +
|
|
|
|
getNodeName(RootName) + "->getOperand(" + utostr(0) + ");");
|
|
|
|
emitInit("SDValue " + RootName + "1" + " = " +
|
|
|
|
getNodeName(RootName) + "->getOperand(" + utostr(1) + ");");
|
|
|
|
|
|
|
|
unsigned NTmp = TmpNo++;
|
|
|
|
emitCode("ConstantSDNode *Tmp" + utostr(NTmp) +
|
|
|
|
" = dyn_cast<ConstantSDNode>(" +
|
|
|
|
getNodeName(RootName + "1") + ");");
|
|
|
|
emitCheck("Tmp" + utostr(NTmp));
|
|
|
|
const char *MaskPredicate = N->getOperator()->getName() == "or"
|
|
|
|
? "CheckOrMask(" : "CheckAndMask(";
|
|
|
|
emitCheck(MaskPredicate + getValueName(RootName + "0") +
|
|
|
|
", Tmp" + utostr(NTmp) +
|
|
|
|
", INT64_C(" + itostr(II->getValue()) + "))");
|
|
|
|
|
|
|
|
EmitChildMatchCode(N->getChild(0), N, RootName + utostr(0),
|
|
|
|
ChainSuffix + utostr(0), FoundChain);
|
|
|
|
return;
|
2006-10-11 21:02:01 +00:00
|
|
|
}
|
2006-08-26 00:59:04 +00:00
|
|
|
}
|
Teach tblgen to accept register source operands in patterns, e.g.
def SHL8rCL : I<0xD2, MRM4r, (ops R8 :$dst, R8 :$src),
"shl{b} {%cl, $dst|$dst, %CL}",
[(set R8:$dst, (shl R8:$src, CL))]>, Imp<[CL],[]>;
This generates a CopyToReg operand and added its 2nd result to the shl as
a flag operand.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24557 91177308-0d34-0410-b5e6-96231b3b80d8
2005-12-01 00:18:45 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i, ++OpNo) {
|
|
|
|
emitInit("SDValue " + getValueName(RootName + utostr(OpNo)) + " = " +
|
|
|
|
getNodeName(RootName) + "->getOperand(" + utostr(OpNo) + ");");
|
|
|
|
|
|
|
|
EmitChildMatchCode(N->getChild(i), N, RootName + utostr(OpNo),
|
|
|
|
ChainSuffix + utostr(OpNo), FoundChain);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle cases when root is a complex pattern.
|
|
|
|
const ComplexPattern *CP;
|
2010-02-14 22:22:58 +00:00
|
|
|
if (isRoot && N->isLeaf() && (CP = N->getComplexPatternInfo(CGP))) {
|
2010-02-13 20:06:50 +00:00
|
|
|
std::string Fn = CP->getSelectFunc();
|
|
|
|
unsigned NumOps = CP->getNumOperands();
|
|
|
|
for (unsigned i = 0; i < NumOps; ++i) {
|
|
|
|
emitDecl("CPTmp" + RootName + "_" + utostr(i));
|
|
|
|
emitCode("SDValue CPTmp" + RootName + "_" + utostr(i) + ";");
|
|
|
|
}
|
|
|
|
if (CP->hasProperty(SDNPHasChain)) {
|
|
|
|
emitDecl("CPInChain");
|
|
|
|
emitDecl("Chain" + ChainSuffix);
|
|
|
|
emitCode("SDValue CPInChain;");
|
|
|
|
emitCode("SDValue Chain" + ChainSuffix + ";");
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string Code = Fn + "(" +
|
|
|
|
getNodeName(RootName) + ", " +
|
|
|
|
getValueName(RootName);
|
|
|
|
for (unsigned i = 0; i < NumOps; i++)
|
|
|
|
Code += ", CPTmp" + RootName + "_" + utostr(i);
|
|
|
|
if (CP->hasProperty(SDNPHasChain)) {
|
|
|
|
ChainName = "Chain" + ChainSuffix;
|
|
|
|
Code += ", CPInChain, Chain" + ChainSuffix;
|
|
|
|
}
|
|
|
|
emitCheck(Code + ")");
|
|
|
|
}
|
|
|
|
}
|
Special case tblgen generated code for patterns like (and X, 255) or (or X, 42).
The dag/inst combiners often 'simplify' the masked value based on whether
or not the bits are live or known zero/one. This is good and dandy, but
often causes special case patterns to fail, such as alpha's CMPBGE pattern,
which looks like "(set GPRC:$RC, (setuge (and GPRC:$RA, 255), (and GPRC:$RB, 255)))".
Here the pattern for (and X, 255) should match actual dags like (and X, 254) if
the dag combiner proved that the missing bits are already zero (one for 'or').
For CodeGen/Alpha/cmpbge.ll:test2 for example, this results in:
sll $16,1,$0
cmpbge $0,$17,$0
ret $31,($26),1
instead of:
sll $16,1,$0
and $0,254,$0
and $17,255,$1
cmpule $1,$0,$0
ret $31,($26),1
... and requires no target-specific code.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@30871 91177308-0d34-0410-b5e6-96231b3b80d8
2006-10-11 04:05:55 +00:00
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
void PatternCodeEmitter::EmitChildMatchCode(TreePatternNode *Child,
|
|
|
|
TreePatternNode *Parent,
|
|
|
|
const std::string &RootName,
|
|
|
|
const std::string &ChainSuffix,
|
|
|
|
bool &FoundChain) {
|
|
|
|
if (!Child->isLeaf()) {
|
|
|
|
// If it's not a leaf, recursively match.
|
|
|
|
const SDNodeInfo &CInfo = CGP.getSDNodeInfo(Child->getOperator());
|
|
|
|
emitCheck(getNodeName(RootName) + "->getOpcode() == " +
|
|
|
|
CInfo.getEnumName());
|
|
|
|
EmitMatchCode(Child, Parent, RootName, ChainSuffix, FoundChain);
|
|
|
|
bool HasChain = false;
|
2010-02-14 22:22:58 +00:00
|
|
|
if (Child->NodeHasProperty(SDNPHasChain, CGP)) {
|
2010-02-13 20:06:50 +00:00
|
|
|
HasChain = true;
|
|
|
|
FoldedChains.push_back(std::make_pair(getValueName(RootName),
|
|
|
|
CInfo.getNumResults()));
|
|
|
|
}
|
2010-02-14 22:22:58 +00:00
|
|
|
if (Child->NodeHasProperty(SDNPOutFlag, CGP)) {
|
2010-02-13 20:06:50 +00:00
|
|
|
assert(FoldedFlag.first == "" && FoldedFlag.second == 0 &&
|
|
|
|
"Pattern folded multiple nodes which produce flags?");
|
|
|
|
FoldedFlag = std::make_pair(getValueName(RootName),
|
|
|
|
CInfo.getNumResults() + (unsigned)HasChain);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// If this child has a name associated with it, capture it in VarMap. If
|
|
|
|
// we already saw this in the pattern, emit code to verify dagness.
|
|
|
|
if (!Child->getName().empty()) {
|
|
|
|
std::string &VarMapEntry = VariableMap[Child->getName()];
|
|
|
|
if (VarMapEntry.empty()) {
|
|
|
|
VarMapEntry = getValueName(RootName);
|
|
|
|
} else {
|
|
|
|
// If we get here, this is a second reference to a specific name.
|
|
|
|
// Since we already have checked that the first reference is valid,
|
|
|
|
// we don't have to recursively match it, just check that it's the
|
|
|
|
// same as the previously named thing.
|
|
|
|
emitCheck(VarMapEntry + " == " + getValueName(RootName));
|
|
|
|
Duplicates.insert(getValueName(RootName));
|
|
|
|
return;
|
2008-02-05 22:50:29 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Handle leaves of various types.
|
|
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) {
|
|
|
|
Record *LeafRec = DI->getDef();
|
|
|
|
if (LeafRec->isSubClassOf("RegisterClass") ||
|
|
|
|
LeafRec->isSubClassOf("PointerLikeRegClass")) {
|
|
|
|
// Handle register references. Nothing to do here.
|
|
|
|
} else if (LeafRec->isSubClassOf("Register")) {
|
|
|
|
// Handle register references.
|
|
|
|
} else if (LeafRec->isSubClassOf("ComplexPattern")) {
|
|
|
|
// Handle complex pattern.
|
2010-02-14 22:22:58 +00:00
|
|
|
const ComplexPattern *CP = Child->getComplexPatternInfo(CGP);
|
2010-02-13 20:06:50 +00:00
|
|
|
std::string Fn = CP->getSelectFunc();
|
|
|
|
unsigned NumOps = CP->getNumOperands();
|
|
|
|
for (unsigned i = 0; i < NumOps; ++i) {
|
|
|
|
emitDecl("CPTmp" + RootName + "_" + utostr(i));
|
|
|
|
emitCode("SDValue CPTmp" + RootName + "_" + utostr(i) + ";");
|
2006-10-11 03:35:34 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
if (CP->hasProperty(SDNPHasChain)) {
|
|
|
|
const SDNodeInfo &PInfo = CGP.getSDNodeInfo(Parent->getOperator());
|
|
|
|
FoldedChains.push_back(std::make_pair("CPInChain",
|
|
|
|
PInfo.getNumResults()));
|
|
|
|
ChainName = "Chain" + ChainSuffix;
|
|
|
|
emitDecl("CPInChain");
|
|
|
|
emitDecl(ChainName);
|
|
|
|
emitCode("SDValue CPInChain;");
|
|
|
|
emitCode("SDValue " + ChainName + ";");
|
2006-10-11 03:35:34 +00:00
|
|
|
}
|
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
std::string Code = Fn + "(N, ";
|
|
|
|
if (CP->hasProperty(SDNPHasChain)) {
|
|
|
|
std::string ParentName(RootName.begin(), RootName.end()-1);
|
|
|
|
Code += getValueName(ParentName) + ", ";
|
|
|
|
}
|
|
|
|
Code += getValueName(RootName);
|
|
|
|
for (unsigned i = 0; i < NumOps; i++)
|
|
|
|
Code += ", CPTmp" + RootName + "_" + utostr(i);
|
|
|
|
if (CP->hasProperty(SDNPHasChain))
|
|
|
|
Code += ", CPInChain, Chain" + ChainSuffix;
|
|
|
|
emitCheck(Code + ")");
|
|
|
|
} else if (LeafRec->getName() == "srcvalue") {
|
|
|
|
// Place holder for SRCVALUE nodes. Nothing to do here.
|
|
|
|
} else if (LeafRec->isSubClassOf("ValueType")) {
|
|
|
|
// Make sure this is the specified value type.
|
|
|
|
emitCheck("cast<VTSDNode>(" + getNodeName(RootName) +
|
|
|
|
")->getVT() == MVT::" + LeafRec->getName());
|
|
|
|
} else if (LeafRec->isSubClassOf("CondCode")) {
|
|
|
|
// Make sure this is the specified cond code.
|
|
|
|
emitCheck("cast<CondCodeSDNode>(" + getNodeName(RootName) +
|
|
|
|
")->get() == ISD::" + LeafRec->getName());
|
2006-10-11 03:35:34 +00:00
|
|
|
} else {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
Child->dump();
|
2010-02-13 20:06:50 +00:00
|
|
|
errs() << " ";
|
2006-10-11 03:35:34 +00:00
|
|
|
#endif
|
|
|
|
assert(0 && "Unknown leaf type!");
|
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
|
|
|
|
// If there are node predicates for this, emit the calls.
|
|
|
|
for (unsigned i = 0, e = Child->getPredicateFns().size(); i != e; ++i)
|
|
|
|
emitCheck(Child->getPredicateFns()[i] + "(" + getNodeName(RootName) +
|
|
|
|
")");
|
|
|
|
} else if (IntInit *II =
|
|
|
|
dynamic_cast<IntInit*>(Child->getLeafValue())) {
|
|
|
|
unsigned NTmp = TmpNo++;
|
|
|
|
emitCode("ConstantSDNode *Tmp"+ utostr(NTmp) +
|
|
|
|
" = dyn_cast<ConstantSDNode>("+
|
|
|
|
getNodeName(RootName) + ");");
|
|
|
|
emitCheck("Tmp" + utostr(NTmp));
|
|
|
|
unsigned CTmp = TmpNo++;
|
|
|
|
emitCode("int64_t CN"+ utostr(CTmp) +
|
|
|
|
" = Tmp" + utostr(NTmp) + "->getSExtValue();");
|
|
|
|
emitCheck("CN" + utostr(CTmp) + " == "
|
|
|
|
"INT64_C(" +itostr(II->getValue()) + ")");
|
|
|
|
} else {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
Child->dump();
|
|
|
|
#endif
|
|
|
|
assert(0 && "Unknown leaf type!");
|
2006-10-11 03:35:34 +00:00
|
|
|
}
|
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
2005-12-08 02:00:36 +00:00
|
|
|
|
2010-02-13 20:06:50 +00:00
|
|
|
/// EmitResultCode - Emit the action for a pattern. Now that it has matched
|
|
|
|
/// we actually have to build a DAG!
|
|
|
|
std::vector<std::string>
|
|
|
|
PatternCodeEmitter::EmitResultCode(TreePatternNode *N,
|
|
|
|
std::vector<Record*> DstRegs,
|
|
|
|
bool InFlagDecled, bool ResNodeDecled,
|
|
|
|
bool LikeLeaf, bool isRoot) {
|
|
|
|
// List of arguments of getMachineNode() or SelectNodeTo().
|
|
|
|
std::vector<std::string> NodeOps;
|
|
|
|
// This is something selected from the pattern we matched.
|
|
|
|
if (!N->getName().empty()) {
|
|
|
|
const std::string &VarName = N->getName();
|
|
|
|
std::string Val = VariableMap[VarName];
|
|
|
|
bool ModifiedVal = false;
|
|
|
|
if (Val.empty()) {
|
|
|
|
errs() << "Variable '" << VarName << " referenced but not defined "
|
|
|
|
<< "and not caught earlier!\n";
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
if (Val[0] == 'T' && Val[1] == 'm' && Val[2] == 'p') {
|
|
|
|
// Already selected this operand, just return the tmpval.
|
|
|
|
NodeOps.push_back(getValueName(Val));
|
|
|
|
return NodeOps;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ComplexPattern *CP;
|
|
|
|
unsigned ResNo = TmpNo++;
|
|
|
|
if (!N->isLeaf() && N->getOperator()->getName() == "imm") {
|
|
|
|
assert(N->getExtTypes().size() == 1 && "Multiple types not handled!");
|
|
|
|
std::string CastType;
|
|
|
|
std::string TmpVar = "Tmp" + utostr(ResNo);
|
|
|
|
switch (N->getTypeNum(0)) {
|
2007-01-17 07:45:12 +00:00
|
|
|
default:
|
2009-07-03 00:10:29 +00:00
|
|
|
errs() << "Cannot handle " << getEnumName(N->getTypeNum(0))
|
2010-02-13 20:06:50 +00:00
|
|
|
<< " type as an immediate constant. Aborting\n";
|
2007-01-17 07:45:12 +00:00
|
|
|
abort();
|
2009-08-11 20:47:22 +00:00
|
|
|
case MVT::i1: CastType = "bool"; break;
|
|
|
|
case MVT::i8: CastType = "unsigned char"; break;
|
|
|
|
case MVT::i16: CastType = "unsigned short"; break;
|
|
|
|
case MVT::i32: CastType = "unsigned"; break;
|
|
|
|
case MVT::i64: CastType = "uint64_t"; break;
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
|
|
|
emitCode("SDValue " + TmpVar +
|
|
|
|
" = CurDAG->getTargetConstant(((" + CastType +
|
|
|
|
") cast<ConstantSDNode>(" + Val + ")->getZExtValue()), " +
|
|
|
|
getEnumName(N->getTypeNum(0)) + ");");
|
|
|
|
// Add Tmp<ResNo> to VariableMap, so that we don't multiply select this
|
|
|
|
// value if used multiple times by this pattern result.
|
|
|
|
Val = TmpVar;
|
|
|
|
ModifiedVal = true;
|
|
|
|
NodeOps.push_back(getValueName(Val));
|
|
|
|
} else if (!N->isLeaf() && N->getOperator()->getName() == "fpimm") {
|
|
|
|
assert(N->getExtTypes().size() == 1 && "Multiple types not handled!");
|
|
|
|
std::string TmpVar = "Tmp" + utostr(ResNo);
|
|
|
|
emitCode("SDValue " + TmpVar +
|
|
|
|
" = CurDAG->getTargetConstantFP(*cast<ConstantFPSDNode>(" +
|
|
|
|
Val + ")->getConstantFPValue(), cast<ConstantFPSDNode>(" +
|
|
|
|
Val + ")->getValueType(0));");
|
|
|
|
// Add Tmp<ResNo> to VariableMap, so that we don't multiply select this
|
|
|
|
// value if used multiple times by this pattern result.
|
|
|
|
Val = TmpVar;
|
|
|
|
ModifiedVal = true;
|
|
|
|
NodeOps.push_back(getValueName(Val));
|
|
|
|
} else if (!N->isLeaf() && N->getOperator()->getName() == "texternalsym"){
|
|
|
|
Record *Op = OperatorMap[N->getName()];
|
|
|
|
// Transform ExternalSymbol to TargetExternalSymbol
|
|
|
|
if (Op && Op->getName() == "externalsym") {
|
|
|
|
std::string TmpVar = "Tmp"+utostr(ResNo);
|
|
|
|
emitCode("SDValue " + TmpVar + " = CurDAG->getTarget"
|
|
|
|
"ExternalSymbol(cast<ExternalSymbolSDNode>(" +
|
|
|
|
Val + ")->getSymbol(), " +
|
2006-07-15 08:45:20 +00:00
|
|
|
getEnumName(N->getTypeNum(0)) + ");");
|
2010-02-13 20:06:50 +00:00
|
|
|
// Add Tmp<ResNo> to VariableMap, so that we don't multiply select
|
|
|
|
// this value if used multiple times by this pattern result.
|
Fix to bug 1951: tblgen gratuitously renames variables when no temporary was
generated. This feature would only show up in fairly complex patterns, such
as this one in CellSPU:
def : Pat<(add (SPUhi tconstpool:$in, 0), (SPUlo tconstpool:$in, 0)),
(IOHLlo (ILHUhi tconstpool:$in), tconstpool:$in)>;
which generated the following emit code:
SDNode *Emit_0(const SDOperand &N, unsigned Opc0, unsigned Opc1, MVT::ValueType VT0, MVT::ValueType VT1) DISABLE_INLINE {
SDOperand N0 = N.getOperand(0);
SDOperand N00 = N0.getOperand(0);
SDOperand N01 = N0.getOperand(1);
SDOperand N1 = N.getOperand(1);
SDOperand N10 = N1.getOperand(0);
SDOperand N11 = N1.getOperand(1);
SDOperand Tmp3(CurDAG->getTargetNode(Opc0, VT0, N00), 0);
return CurDAG->SelectNodeTo(N.Val, Opc1, VT1, Tmp3, Tmp2); /* Tmp2 s/b N00 */
}
Tested against the test suites without incident.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@46487 91177308-0d34-0410-b5e6-96231b3b80d8
2008-01-29 02:29:31 +00:00
|
|
|
Val = TmpVar;
|
|
|
|
ModifiedVal = true;
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
|
|
|
NodeOps.push_back(getValueName(Val));
|
|
|
|
} else if (!N->isLeaf() && (N->getOperator()->getName() == "tglobaladdr"
|
|
|
|
|| N->getOperator()->getName() == "tglobaltlsaddr")) {
|
|
|
|
Record *Op = OperatorMap[N->getName()];
|
|
|
|
// Transform GlobalAddress to TargetGlobalAddress
|
|
|
|
if (Op && (Op->getName() == "globaladdr" ||
|
|
|
|
Op->getName() == "globaltlsaddr")) {
|
|
|
|
std::string TmpVar = "Tmp" + utostr(ResNo);
|
|
|
|
emitCode("SDValue " + TmpVar + " = CurDAG->getTarget"
|
|
|
|
"GlobalAddress(cast<GlobalAddressSDNode>(" + Val +
|
|
|
|
")->getGlobal(), " + getEnumName(N->getTypeNum(0)) +
|
|
|
|
");");
|
|
|
|
// Add Tmp<ResNo> to VariableMap, so that we don't multiply select
|
|
|
|
// this value if used multiple times by this pattern result.
|
2008-02-14 08:57:00 +00:00
|
|
|
Val = TmpVar;
|
|
|
|
ModifiedVal = true;
|
2005-12-08 02:00:36 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
NodeOps.push_back(getValueName(Val));
|
|
|
|
} else if (!N->isLeaf()
|
2010-02-14 22:22:58 +00:00
|
|
|
&& (N->getOperator()->getName() == "texternalsym" ||
|
|
|
|
N->getOperator()->getName() == "tconstpool")) {
|
|
|
|
// Do not rewrite the variable name, since we don't generate a new
|
|
|
|
// temporary.
|
|
|
|
NodeOps.push_back(getValueName(Val));
|
|
|
|
} else if (N->isLeaf() && (CP = N->getComplexPatternInfo(CGP))) {
|
|
|
|
for (unsigned i = 0; i < CP->getNumOperands(); ++i) {
|
|
|
|
NodeOps.push_back(getValueName("CPTmp" + Val + "_" + utostr(i)));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// This node, probably wrapped in a SDNodeXForm, behaves like a leaf
|
|
|
|
// node even if it isn't one. Don't select it.
|
|
|
|
if (!LikeLeaf) {
|
|
|
|
if (isRoot && N->isLeaf()) {
|
|
|
|
emitCode("ReplaceUses(SDValue(N, 0), " + Val + ");");
|
|
|
|
emitCode("return NULL;");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NodeOps.push_back(getValueName(Val));
|
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
|
2010-02-14 22:22:58 +00:00
|
|
|
if (ModifiedVal)
|
2010-02-13 20:06:50 +00:00
|
|
|
VariableMap[VarName] = Val;
|
|
|
|
return NodeOps;
|
|
|
|
}
|
|
|
|
if (N->isLeaf()) {
|
|
|
|
// If this is an explicit register reference, handle it.
|
|
|
|
if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) {
|
|
|
|
unsigned ResNo = TmpNo++;
|
|
|
|
if (DI->getDef()->isSubClassOf("Register")) {
|
|
|
|
emitCode("SDValue Tmp" + utostr(ResNo) + " = CurDAG->getRegister(" +
|
|
|
|
getQualifiedName(DI->getDef()) + ", " +
|
|
|
|
getEnumName(N->getTypeNum(0)) + ");");
|
|
|
|
NodeOps.push_back(getValueName("Tmp" + utostr(ResNo)));
|
|
|
|
return NodeOps;
|
|
|
|
} else if (DI->getDef()->getName() == "zero_reg") {
|
|
|
|
emitCode("SDValue Tmp" + utostr(ResNo) +
|
|
|
|
" = CurDAG->getRegister(0, " +
|
|
|
|
getEnumName(N->getTypeNum(0)) + ");");
|
|
|
|
NodeOps.push_back(getValueName("Tmp" + utostr(ResNo)));
|
|
|
|
return NodeOps;
|
|
|
|
} else if (DI->getDef()->isSubClassOf("RegisterClass")) {
|
|
|
|
// Handle a reference to a register class. This is used
|
|
|
|
// in COPY_TO_SUBREG instructions.
|
|
|
|
emitCode("SDValue Tmp" + utostr(ResNo) +
|
|
|
|
" = CurDAG->getTargetConstant(" +
|
|
|
|
getQualifiedName(DI->getDef()) + "RegClassID, " +
|
|
|
|
"MVT::i32);");
|
2010-01-05 01:24:18 +00:00
|
|
|
NodeOps.push_back(getValueName("Tmp" + utostr(ResNo)));
|
2006-08-26 00:59:04 +00:00
|
|
|
return NodeOps;
|
2005-10-19 02:07:26 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
} else if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
|
|
|
|
unsigned ResNo = TmpNo++;
|
|
|
|
assert(N->getExtTypes().size() == 1 && "Multiple types not handled!");
|
|
|
|
emitCode("SDValue Tmp" + utostr(ResNo) +
|
|
|
|
" = CurDAG->getTargetConstant(0x" +
|
|
|
|
utohexstr((uint64_t) II->getValue()) +
|
|
|
|
"ULL, " + getEnumName(N->getTypeNum(0)) + ");");
|
|
|
|
NodeOps.push_back(getValueName("Tmp" + utostr(ResNo)));
|
|
|
|
return NodeOps;
|
|
|
|
}
|
2005-10-19 02:07:26 +00:00
|
|
|
|
2006-07-11 18:25:13 +00:00
|
|
|
#ifndef NDEBUG
|
2010-02-13 20:06:50 +00:00
|
|
|
N->dump();
|
2006-07-11 18:25:13 +00:00
|
|
|
#endif
|
2010-02-13 20:06:50 +00:00
|
|
|
assert(0 && "Unknown leaf type!");
|
|
|
|
return NodeOps;
|
|
|
|
}
|
|
|
|
|
|
|
|
Record *Op = N->getOperator();
|
|
|
|
if (Op->isSubClassOf("Instruction")) {
|
|
|
|
const CodeGenTarget &CGT = CGP.getTargetInfo();
|
|
|
|
CodeGenInstruction &II = CGT.getInstruction(Op->getName());
|
|
|
|
const DAGInstruction &Inst = CGP.getInstruction(Op);
|
|
|
|
const TreePattern *InstPat = Inst.getPattern();
|
|
|
|
// FIXME: Assume actual pattern comes before "implicit".
|
|
|
|
TreePatternNode *InstPatNode =
|
|
|
|
isRoot ? (InstPat ? InstPat->getTree(0) : Pattern)
|
|
|
|
: (InstPat ? InstPat->getTree(0) : NULL);
|
|
|
|
if (InstPatNode && !InstPatNode->isLeaf() &&
|
|
|
|
InstPatNode->getOperator()->getName() == "set") {
|
|
|
|
InstPatNode = InstPatNode->getChild(InstPatNode->getNumChildren()-1);
|
2005-12-09 00:48:42 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
bool IsVariadic = isRoot && II.isVariadic;
|
|
|
|
// FIXME: fix how we deal with physical register operands.
|
|
|
|
bool HasImpInputs = isRoot && Inst.getNumImpOperands() > 0;
|
|
|
|
bool HasImpResults = isRoot && DstRegs.size() > 0;
|
|
|
|
bool NodeHasOptInFlag = isRoot &&
|
2010-02-14 22:22:58 +00:00
|
|
|
Pattern->TreeHasProperty(SDNPOptInFlag, CGP);
|
2010-02-13 20:06:50 +00:00
|
|
|
bool NodeHasInFlag = isRoot &&
|
2010-02-14 22:22:58 +00:00
|
|
|
Pattern->TreeHasProperty(SDNPInFlag, CGP);
|
2010-02-13 20:06:50 +00:00
|
|
|
bool NodeHasOutFlag = isRoot &&
|
2010-02-14 22:22:58 +00:00
|
|
|
Pattern->TreeHasProperty(SDNPOutFlag, CGP);
|
2010-02-13 20:06:50 +00:00
|
|
|
bool NodeHasChain = InstPatNode &&
|
2010-02-14 22:22:58 +00:00
|
|
|
InstPatNode->TreeHasProperty(SDNPHasChain, CGP);
|
|
|
|
bool InputHasChain = isRoot && Pattern->NodeHasProperty(SDNPHasChain, CGP);
|
2010-02-13 20:06:50 +00:00
|
|
|
unsigned NumResults = Inst.getNumResults();
|
|
|
|
unsigned NumDstRegs = HasImpResults ? DstRegs.size() : 0;
|
|
|
|
|
|
|
|
// Record output varargs info.
|
|
|
|
OutputIsVariadic = IsVariadic;
|
|
|
|
|
|
|
|
if (NodeHasOptInFlag) {
|
|
|
|
emitCode("bool HasInFlag = "
|
|
|
|
"(N->getOperand(N->getNumOperands()-1).getValueType() == "
|
|
|
|
"MVT::Flag);");
|
|
|
|
}
|
|
|
|
if (IsVariadic)
|
|
|
|
emitCode("SmallVector<SDValue, 8> Ops" + utostr(OpcNo) + ";");
|
|
|
|
|
|
|
|
// How many results is this pattern expected to produce?
|
|
|
|
unsigned NumPatResults = 0;
|
|
|
|
for (unsigned i = 0, e = Pattern->getExtTypes().size(); i != e; i++) {
|
|
|
|
MVT::SimpleValueType VT = Pattern->getTypeNum(i);
|
|
|
|
if (VT != MVT::isVoid && VT != MVT::Flag)
|
|
|
|
NumPatResults++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (OrigChains.size() > 0) {
|
|
|
|
// The original input chain is being ignored. If it is not just
|
|
|
|
// pointing to the op that's being folded, we should create a
|
|
|
|
// TokenFactor with it and the chain of the folded op as the new chain.
|
|
|
|
// We could potentially be doing multiple levels of folding, in that
|
|
|
|
// case, the TokenFactor can have more operands.
|
|
|
|
emitCode("SmallVector<SDValue, 8> InChains;");
|
|
|
|
for (unsigned i = 0, e = OrigChains.size(); i < e; ++i) {
|
|
|
|
emitCode("if (" + OrigChains[i].first + ".getNode() != " +
|
|
|
|
OrigChains[i].second + ".getNode()) {");
|
|
|
|
emitCode(" InChains.push_back(" + OrigChains[i].first + ");");
|
|
|
|
emitCode("}");
|
2006-01-19 21:57:10 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
emitCode("InChains.push_back(" + ChainName + ");");
|
|
|
|
emitCode(ChainName + " = CurDAG->getNode(ISD::TokenFactor, "
|
|
|
|
"N->getDebugLoc(), MVT::Other, "
|
|
|
|
"&InChains[0], InChains.size());");
|
|
|
|
if (GenDebug) {
|
|
|
|
emitCode("CurDAG->setSubgraphColor(" + ChainName +".getNode(), \"yellow\");");
|
|
|
|
emitCode("CurDAG->setSubgraphColor(" + ChainName +".getNode(), \"black\");");
|
2006-10-12 02:08:53 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
std::vector<std::string> AllOps;
|
|
|
|
for (unsigned ChildNo = 0, InstOpNo = NumResults;
|
|
|
|
InstOpNo != II.OperandList.size(); ++InstOpNo) {
|
|
|
|
std::vector<std::string> Ops;
|
|
|
|
|
|
|
|
// 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) {
|
|
|
|
Ops = EmitResultCode(DefaultOp.DefaultOps[i], DstRegs,
|
2008-05-29 19:57:41 +00:00
|
|
|
InFlagDecled, ResNodeDecled);
|
|
|
|
AllOps.insert(AllOps.end(), Ops.begin(), Ops.end());
|
2006-08-26 00:59:04 +00:00
|
|
|
}
|
2008-07-07 21:00:17 +00:00
|
|
|
} else {
|
2010-02-13 20:06:50 +00:00
|
|
|
// Otherwise this is a normal operand or a predicate operand without
|
|
|
|
// 'execute always'; emit it.
|
|
|
|
Ops = EmitResultCode(N->getChild(ChildNo), DstRegs,
|
|
|
|
InFlagDecled, ResNodeDecled);
|
|
|
|
AllOps.insert(AllOps.end(), Ops.begin(), Ops.end());
|
|
|
|
++ChildNo;
|
2008-07-07 21:00:17 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Emit all the chain and CopyToReg stuff.
|
|
|
|
bool ChainEmitted = NodeHasChain;
|
|
|
|
if (NodeHasInFlag || HasImpInputs)
|
|
|
|
EmitInFlagSelectCode(Pattern, "N", ChainEmitted,
|
|
|
|
InFlagDecled, ResNodeDecled, true);
|
|
|
|
if (NodeHasOptInFlag || NodeHasInFlag || HasImpInputs) {
|
|
|
|
if (!InFlagDecled) {
|
|
|
|
emitCode("SDValue InFlag(0, 0);");
|
|
|
|
InFlagDecled = true;
|
2008-07-07 21:00:17 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
if (NodeHasOptInFlag) {
|
|
|
|
emitCode("if (HasInFlag) {");
|
|
|
|
emitCode(" InFlag = N->getOperand(N->getNumOperands()-1);");
|
2008-07-07 21:00:17 +00:00
|
|
|
emitCode("}");
|
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned ResNo = TmpNo++;
|
|
|
|
|
|
|
|
unsigned OpsNo = OpcNo;
|
|
|
|
std::string CodePrefix;
|
|
|
|
bool ChainAssignmentNeeded = NodeHasChain && !isRoot;
|
|
|
|
std::deque<std::string> After;
|
|
|
|
std::string NodeName;
|
|
|
|
if (!isRoot) {
|
|
|
|
NodeName = "Tmp" + utostr(ResNo);
|
|
|
|
CodePrefix = "SDValue " + NodeName + "(";
|
|
|
|
} else {
|
|
|
|
NodeName = "ResNode";
|
|
|
|
if (!ResNodeDecled) {
|
|
|
|
CodePrefix = "SDNode *" + NodeName + " = ";
|
|
|
|
ResNodeDecled = true;
|
|
|
|
} else
|
|
|
|
CodePrefix = NodeName + " = ";
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string Code = "Opc" + utostr(OpcNo);
|
|
|
|
|
|
|
|
if (!isRoot || (InputHasChain && !NodeHasChain))
|
|
|
|
// For call to "getMachineNode()".
|
|
|
|
Code += ", N->getDebugLoc()";
|
|
|
|
|
|
|
|
emitOpcode(II.Namespace + "::" + II.TheDef->getName());
|
|
|
|
|
|
|
|
// Output order: results, chain, flags
|
|
|
|
// Result types.
|
|
|
|
if (NumResults > 0 && N->getTypeNum(0) != MVT::isVoid) {
|
|
|
|
Code += ", VT" + utostr(VTNo);
|
|
|
|
emitVT(getEnumName(N->getTypeNum(0)));
|
|
|
|
}
|
|
|
|
// Add types for implicit results in physical registers, scheduler will
|
|
|
|
// care of adding copyfromreg nodes.
|
|
|
|
for (unsigned i = 0; i < NumDstRegs; i++) {
|
|
|
|
Record *RR = DstRegs[i];
|
|
|
|
if (RR->isSubClassOf("Register")) {
|
|
|
|
MVT::SimpleValueType RVT = getRegisterValueType(RR, CGT);
|
|
|
|
Code += ", " + getEnumName(RVT);
|
2008-07-07 21:00:17 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
|
|
|
if (NodeHasChain)
|
|
|
|
Code += ", MVT::Other";
|
|
|
|
if (NodeHasOutFlag)
|
|
|
|
Code += ", MVT::Flag";
|
|
|
|
|
|
|
|
// Inputs.
|
|
|
|
if (IsVariadic) {
|
|
|
|
for (unsigned i = 0, e = AllOps.size(); i != e; ++i)
|
|
|
|
emitCode("Ops" + utostr(OpsNo) + ".push_back(" + AllOps[i] + ");");
|
|
|
|
AllOps.clear();
|
|
|
|
|
|
|
|
// Figure out whether any operands at the end of the op list are not
|
|
|
|
// part of the variable section.
|
|
|
|
std::string EndAdjust;
|
|
|
|
if (NodeHasInFlag || HasImpInputs)
|
|
|
|
EndAdjust = "-1"; // Always has one flag.
|
|
|
|
else if (NodeHasOptInFlag)
|
|
|
|
EndAdjust = "-(HasInFlag?1:0)"; // May have a flag.
|
|
|
|
|
|
|
|
emitCode("for (unsigned i = NumInputRootOps + " + utostr(NodeHasChain) +
|
|
|
|
", e = N->getNumOperands()" + EndAdjust + "; i != e; ++i) {");
|
|
|
|
|
|
|
|
emitCode(" Ops" + utostr(OpsNo) + ".push_back(N->getOperand(i));");
|
|
|
|
emitCode("}");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Populate MemRefs with entries for each memory accesses covered by
|
|
|
|
// this pattern.
|
|
|
|
if (isRoot && !LSI.empty()) {
|
|
|
|
std::string MemRefs = "MemRefs" + utostr(OpsNo);
|
|
|
|
emitCode("MachineSDNode::mmo_iterator " + MemRefs + " = "
|
|
|
|
"MF->allocateMemRefsArray(" + utostr(LSI.size()) + ");");
|
|
|
|
for (unsigned i = 0, e = LSI.size(); i != e; ++i)
|
|
|
|
emitCode(MemRefs + "[" + utostr(i) + "] = "
|
|
|
|
"cast<MemSDNode>(" + LSI[i] + ")->getMemOperand();");
|
|
|
|
After.push_back("cast<MachineSDNode>(ResNode)->setMemRefs(" +
|
|
|
|
MemRefs + ", " + MemRefs + " + " + utostr(LSI.size()) +
|
|
|
|
");");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NodeHasChain) {
|
|
|
|
if (IsVariadic)
|
|
|
|
emitCode("Ops" + utostr(OpsNo) + ".push_back(" + ChainName + ");");
|
|
|
|
else
|
|
|
|
AllOps.push_back(ChainName);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IsVariadic) {
|
|
|
|
if (NodeHasInFlag || HasImpInputs)
|
|
|
|
emitCode("Ops" + utostr(OpsNo) + ".push_back(InFlag);");
|
|
|
|
else if (NodeHasOptInFlag) {
|
|
|
|
emitCode("if (HasInFlag)");
|
|
|
|
emitCode(" Ops" + utostr(OpsNo) + ".push_back(InFlag);");
|
2008-07-07 21:00:17 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
Code += ", &Ops" + utostr(OpsNo) + "[0], Ops" + utostr(OpsNo) +
|
|
|
|
".size()";
|
|
|
|
} else if (NodeHasInFlag || NodeHasOptInFlag || HasImpInputs)
|
|
|
|
AllOps.push_back("InFlag");
|
|
|
|
|
|
|
|
unsigned NumOps = AllOps.size();
|
|
|
|
if (NumOps) {
|
|
|
|
if (!NodeHasOptInFlag && NumOps < 4) {
|
|
|
|
for (unsigned i = 0; i != NumOps; ++i)
|
|
|
|
Code += ", " + AllOps[i];
|
|
|
|
} else {
|
|
|
|
std::string OpsCode = "SDValue Ops" + utostr(OpsNo) + "[] = { ";
|
|
|
|
for (unsigned i = 0; i != NumOps; ++i) {
|
|
|
|
OpsCode += AllOps[i];
|
|
|
|
if (i != NumOps-1)
|
|
|
|
OpsCode += ", ";
|
2006-08-26 00:59:04 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
emitCode(OpsCode + " };");
|
|
|
|
Code += ", Ops" + utostr(OpsNo) + ", ";
|
|
|
|
if (NodeHasOptInFlag) {
|
|
|
|
Code += "HasInFlag ? ";
|
|
|
|
Code += utostr(NumOps) + " : " + utostr(NumOps-1);
|
|
|
|
} else
|
|
|
|
Code += utostr(NumOps);
|
2008-07-07 21:00:17 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!isRoot)
|
|
|
|
Code += "), 0";
|
|
|
|
|
|
|
|
std::vector<std::string> ReplaceFroms;
|
|
|
|
std::vector<std::string> ReplaceTos;
|
|
|
|
if (!isRoot) {
|
|
|
|
NodeOps.push_back("Tmp" + utostr(ResNo));
|
|
|
|
} else {
|
|
|
|
|
2009-06-02 03:12:52 +00:00
|
|
|
if (NodeHasOutFlag) {
|
2008-07-07 21:00:17 +00:00
|
|
|
if (!InFlagDecled) {
|
2008-07-27 21:46:04 +00:00
|
|
|
After.push_back("SDValue InFlag(ResNode, " +
|
2008-07-07 21:00:17 +00:00
|
|
|
utostr(NumResults+NumDstRegs+(unsigned)NodeHasChain) +
|
|
|
|
");");
|
|
|
|
InFlagDecled = true;
|
|
|
|
} else
|
2008-07-27 21:46:04 +00:00
|
|
|
After.push_back("InFlag = SDValue(ResNode, " +
|
2008-07-07 21:00:17 +00:00
|
|
|
utostr(NumResults+NumDstRegs+(unsigned)NodeHasChain) +
|
|
|
|
");");
|
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
|
2009-01-05 19:31:28 +00:00
|
|
|
for (unsigned j = 0, e = FoldedChains.size(); j < e; j++) {
|
|
|
|
ReplaceFroms.push_back("SDValue(" +
|
|
|
|
FoldedChains[j].first + ".getNode(), " +
|
|
|
|
utostr(FoldedChains[j].second) +
|
|
|
|
")");
|
|
|
|
ReplaceTos.push_back("SDValue(ResNode, " +
|
|
|
|
utostr(NumResults+NumDstRegs) + ")");
|
2008-07-07 21:00:17 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
|
2009-06-02 03:12:52 +00:00
|
|
|
if (NodeHasOutFlag) {
|
2008-07-07 21:00:17 +00:00
|
|
|
if (FoldedFlag.first != "") {
|
2009-06-02 03:12:52 +00:00
|
|
|
ReplaceFroms.push_back("SDValue(" + FoldedFlag.first + ".getNode(), " +
|
2008-07-17 19:10:17 +00:00
|
|
|
utostr(FoldedFlag.second) + ")");
|
|
|
|
ReplaceTos.push_back("InFlag");
|
2008-07-07 21:00:17 +00:00
|
|
|
} else {
|
2010-02-14 22:22:58 +00:00
|
|
|
assert(Pattern->NodeHasProperty(SDNPOutFlag, CGP));
|
2010-01-05 01:24:18 +00:00
|
|
|
ReplaceFroms.push_back("SDValue(N, " +
|
2008-07-17 19:10:17 +00:00
|
|
|
utostr(NumPatResults + (unsigned)InputHasChain)
|
|
|
|
+ ")");
|
|
|
|
ReplaceTos.push_back("InFlag");
|
2005-12-20 07:37:41 +00:00
|
|
|
}
|
2008-07-07 21:00:17 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
|
2008-07-17 19:10:17 +00:00
|
|
|
if (!ReplaceFroms.empty() && InputHasChain) {
|
2010-01-05 01:24:18 +00:00
|
|
|
ReplaceFroms.push_back("SDValue(N, " +
|
2008-07-17 19:10:17 +00:00
|
|
|
utostr(NumPatResults) + ")");
|
2008-08-28 21:40:38 +00:00
|
|
|
ReplaceTos.push_back("SDValue(" + ChainName + ".getNode(), " +
|
2008-08-26 22:36:50 +00:00
|
|
|
ChainName + ".getResNo()" + ")");
|
2008-07-07 21:00:17 +00:00
|
|
|
ChainAssignmentNeeded |= NodeHasChain;
|
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
|
2008-07-07 21:00:17 +00:00
|
|
|
// User does not expect the instruction would produce a chain!
|
2009-06-02 03:12:52 +00:00
|
|
|
if ((!InputHasChain && NodeHasChain) && NodeHasOutFlag) {
|
2008-07-07 21:00:17 +00:00
|
|
|
;
|
|
|
|
} else if (InputHasChain && !NodeHasChain) {
|
|
|
|
// One of the inner node produces a chain.
|
2010-01-04 20:36:57 +00:00
|
|
|
assert(!NodeHasOutFlag && "Node has flag but not chain!");
|
2010-01-05 01:24:18 +00:00
|
|
|
ReplaceFroms.push_back("SDValue(N, " +
|
2008-07-17 19:10:17 +00:00
|
|
|
utostr(NumPatResults) + ")");
|
|
|
|
ReplaceTos.push_back(ChainName);
|
2008-07-07 21:00:17 +00:00
|
|
|
}
|
2005-10-16 01:41:58 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
|
|
|
|
if (ChainAssignmentNeeded) {
|
|
|
|
// Remember which op produces the chain.
|
|
|
|
std::string ChainAssign;
|
2006-08-09 16:44:44 +00:00
|
|
|
if (!isRoot)
|
2010-02-13 20:06:50 +00:00
|
|
|
ChainAssign = ChainName + " = SDValue(" + NodeName +
|
|
|
|
".getNode(), " + utostr(NumResults+NumDstRegs) + ");";
|
|
|
|
else
|
|
|
|
ChainAssign = ChainName + " = SDValue(" + NodeName +
|
|
|
|
", " + utostr(NumResults+NumDstRegs) + ");";
|
|
|
|
|
|
|
|
After.push_front(ChainAssign);
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
|
|
|
|
if (ReplaceFroms.size() == 1) {
|
|
|
|
After.push_back("ReplaceUses(" + ReplaceFroms[0] + ", " +
|
|
|
|
ReplaceTos[0] + ");");
|
|
|
|
} else if (!ReplaceFroms.empty()) {
|
|
|
|
After.push_back("const SDValue Froms[] = {");
|
|
|
|
for (unsigned i = 0, e = ReplaceFroms.size(); i != e; ++i)
|
|
|
|
After.push_back(" " + ReplaceFroms[i] + (i + 1 != e ? "," : ""));
|
|
|
|
After.push_back("};");
|
|
|
|
After.push_back("const SDValue Tos[] = {");
|
|
|
|
for (unsigned i = 0, e = ReplaceFroms.size(); i != e; ++i)
|
|
|
|
After.push_back(" " + ReplaceTos[i] + (i + 1 != e ? "," : ""));
|
|
|
|
After.push_back("};");
|
|
|
|
After.push_back("ReplaceUses(Froms, Tos, " +
|
|
|
|
itostr(ReplaceFroms.size()) + ");");
|
|
|
|
}
|
|
|
|
|
|
|
|
// We prefer to use SelectNodeTo since it avoids allocation when
|
|
|
|
// possible and it avoids CSE map recalculation for the node's
|
|
|
|
// users, however it's tricky to use in a non-root context.
|
|
|
|
//
|
|
|
|
// We also don't use SelectNodeTo if the pattern replacement is being
|
|
|
|
// used to jettison a chain result, since morphing the node in place
|
|
|
|
// would leave users of the chain dangling.
|
|
|
|
//
|
|
|
|
if (!isRoot || (InputHasChain && !NodeHasChain)) {
|
|
|
|
Code = "CurDAG->getMachineNode(" + Code;
|
|
|
|
} else {
|
|
|
|
Code = "CurDAG->SelectNodeTo(N, " + Code;
|
|
|
|
}
|
|
|
|
if (isRoot) {
|
|
|
|
if (After.empty())
|
|
|
|
CodePrefix = "return ";
|
|
|
|
else
|
|
|
|
After.push_back("return ResNode;");
|
|
|
|
}
|
|
|
|
|
|
|
|
emitCode(CodePrefix + Code + ");");
|
|
|
|
|
|
|
|
if (GenDebug) {
|
|
|
|
if (!isRoot) {
|
|
|
|
emitCode("CurDAG->setSubgraphColor(" +
|
|
|
|
NodeName +".getNode(), \"yellow\");");
|
|
|
|
emitCode("CurDAG->setSubgraphColor(" +
|
|
|
|
NodeName +".getNode(), \"black\");");
|
2005-12-09 22:45:35 +00:00
|
|
|
} else {
|
2010-02-13 20:06:50 +00:00
|
|
|
emitCode("CurDAG->setSubgraphColor(" + NodeName +", \"yellow\");");
|
|
|
|
emitCode("CurDAG->setSubgraphColor(" + NodeName +", \"black\");");
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = After.size(); i != e; ++i)
|
|
|
|
emitCode(After[i]);
|
|
|
|
|
|
|
|
return NodeOps;
|
2005-12-09 22:45:35 +00:00
|
|
|
}
|
2010-02-13 20:06:50 +00:00
|
|
|
if (Op->isSubClassOf("SDNodeXForm")) {
|
|
|
|
assert(N->getNumChildren() == 1 && "node xform should have one child!");
|
|
|
|
// PatLeaf node - the operand may or may not be a leaf node. But it should
|
|
|
|
// behave like one.
|
|
|
|
std::vector<std::string> Ops =
|
|
|
|
EmitResultCode(N->getChild(0), DstRegs, InFlagDecled,
|
|
|
|
ResNodeDecled, true);
|
|
|
|
unsigned ResNo = TmpNo++;
|
|
|
|
emitCode("SDValue Tmp" + utostr(ResNo) + " = Transform_" + Op->getName()
|
|
|
|
+ "(" + Ops.back() + ".getNode());");
|
|
|
|
NodeOps.push_back("Tmp" + utostr(ResNo));
|
|
|
|
if (isRoot)
|
|
|
|
emitCode("return Tmp" + utostr(ResNo) + ".getNode();");
|
|
|
|
return NodeOps;
|
|
|
|
}
|
|
|
|
|
|
|
|
N->dump();
|
|
|
|
errs() << "\n";
|
|
|
|
throw std::string("Unknown node in result pattern!");
|
|
|
|
}
|
|
|
|
|
2005-11-02 06:49:14 +00:00
|
|
|
|
2005-09-23 21:33:23 +00:00
|
|
|
/// EmitCodeForPattern - Given a pattern to match, emit code to the specified
|
|
|
|
/// stream to match the pattern, and generate the code for the match if it
|
2006-01-29 02:43:35 +00:00
|
|
|
/// succeeds. Returns true if the pattern is not guaranteed to match.
|
2008-01-05 22:30:17 +00:00
|
|
|
void DAGISelEmitter::GenerateCodeForPattern(const PatternToMatch &Pattern,
|
2006-08-26 00:59:04 +00:00
|
|
|
std::vector<std::pair<unsigned, std::string> > &GeneratedCode,
|
2006-08-26 01:02:19 +00:00
|
|
|
std::set<std::string> &GeneratedDecl,
|
2006-07-15 08:45:20 +00:00
|
|
|
std::vector<std::string> &TargetOpcodes,
|
2008-05-31 02:11:25 +00:00
|
|
|
std::vector<std::string> &TargetVTs,
|
|
|
|
bool &OutputIsVariadic,
|
|
|
|
unsigned &NumInputRootOps) {
|
|
|
|
OutputIsVariadic = false;
|
|
|
|
NumInputRootOps = 0;
|
|
|
|
|
2008-08-22 00:20:26 +00:00
|
|
|
PatternCodeEmitter Emitter(CGP, Pattern.getPredicateCheck(),
|
2005-12-14 22:02:59 +00:00
|
|
|
Pattern.getSrcPattern(), Pattern.getDstPattern(),
|
2006-07-16 06:12:52 +00:00
|
|
|
GeneratedCode, GeneratedDecl,
|
2008-05-31 02:11:25 +00:00
|
|
|
TargetOpcodes, TargetVTs,
|
|
|
|
OutputIsVariadic, NumInputRootOps);
|
2005-12-09 22:45:35 +00:00
|
|
|
|
2005-09-23 23:16:51 +00:00
|
|
|
// Emit the matcher, capturing named arguments in VariableMap.
|
2005-12-23 22:11:47 +00:00
|
|
|
bool FoundChain = false;
|
2006-10-16 06:33:44 +00:00
|
|
|
Emitter.EmitMatchCode(Pattern.getSrcPattern(), NULL, "N", "", FoundChain);
|
2005-12-09 22:45:35 +00:00
|
|
|
|
2010-02-14 21:11:53 +00:00
|
|
|
// TP - Get *SOME* tree pattern, we don't care which. It is only used for
|
|
|
|
// diagnostics, which we know are impossible at this point.
|
2008-01-05 22:58:54 +00:00
|
|
|
TreePattern &TP = *CGP.pf_begin()->second;
|
2005-10-14 04:11:13 +00:00
|
|
|
|
|
|
|
// At this point, we know that we structurally match the pattern, but the
|
|
|
|
// types of the nodes may not match. Figure out the fewest number of type
|
|
|
|
// comparisons we need to emit. For example, if there is only one integer
|
|
|
|
// type supported by a target, there should be no type comparisons at all for
|
|
|
|
// integer patterns!
|
|
|
|
//
|
|
|
|
// To figure out the fewest number of type checks needed, clone the pattern,
|
|
|
|
// remove the types, then perform type inference on the pattern as a whole.
|
|
|
|
// If there are unresolved types, emit an explicit check for those types,
|
|
|
|
// apply the type to the tree, then rerun type inference. Iterate until all
|
|
|
|
// types are resolved.
|
|
|
|
//
|
2005-12-14 22:02:59 +00:00
|
|
|
TreePatternNode *Pat = Pattern.getSrcPattern()->clone();
|
2010-02-14 22:22:58 +00:00
|
|
|
Pat->RemoveAllTypes();
|
2005-10-14 04:11:13 +00:00
|
|
|
|
2005-10-15 21:34:21 +00:00
|
|
|
do {
|
|
|
|
// Resolve/propagate as many types as possible.
|
|
|
|
try {
|
|
|
|
bool MadeChange = true;
|
|
|
|
while (MadeChange)
|
2006-01-28 19:06:51 +00:00
|
|
|
MadeChange = Pat->ApplyTypeConstraints(TP,
|
|
|
|
true/*Ignore reg constraints*/);
|
2005-10-15 21:34:21 +00:00
|
|
|
} catch (...) {
|
|
|
|
assert(0 && "Error: could not find consistent types for something we"
|
|
|
|
" already decided was ok!");
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Insert a check for an unresolved type and add it to the tree. If we find
|
|
|
|
// an unresolved type to add a check for, this returns true and we iterate,
|
|
|
|
// otherwise we are done.
|
2006-08-09 16:44:44 +00:00
|
|
|
} while (Emitter.InsertOneTypeCheck(Pat, Pattern.getSrcPattern(), "N", true));
|
2005-12-09 22:45:35 +00:00
|
|
|
|
2007-09-12 23:30:14 +00:00
|
|
|
Emitter.EmitResultCode(Pattern.getDstPattern(), Pattern.getDstRegs(),
|
2007-09-17 22:26:41 +00:00
|
|
|
false, false, false, true);
|
2005-10-14 04:11:13 +00:00
|
|
|
delete Pat;
|
2005-09-23 20:52:47 +00:00
|
|
|
}
|
|
|
|
|
2006-01-29 04:41:05 +00:00
|
|
|
/// EraseCodeLine - Erase one code line from all of the patterns. If removing
|
|
|
|
/// a line causes any of them to be empty, remove them and return true when
|
|
|
|
/// done.
|
2008-01-05 22:30:17 +00:00
|
|
|
static bool EraseCodeLine(std::vector<std::pair<const PatternToMatch*,
|
2006-08-26 00:59:04 +00:00
|
|
|
std::vector<std::pair<unsigned, std::string> > > >
|
2006-01-29 04:41:05 +00:00
|
|
|
&Patterns) {
|
|
|
|
bool ErasedPatterns = false;
|
|
|
|
for (unsigned i = 0, e = Patterns.size(); i != e; ++i) {
|
|
|
|
Patterns[i].second.pop_back();
|
|
|
|
if (Patterns[i].second.empty()) {
|
|
|
|
Patterns.erase(Patterns.begin()+i);
|
|
|
|
--i; --e;
|
|
|
|
ErasedPatterns = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ErasedPatterns;
|
|
|
|
}
|
|
|
|
|
2006-01-29 04:25:26 +00:00
|
|
|
/// EmitPatterns - Emit code for at least one pattern, but try to group common
|
|
|
|
/// code together between the patterns.
|
2008-01-05 22:30:17 +00:00
|
|
|
void DAGISelEmitter::EmitPatterns(std::vector<std::pair<const PatternToMatch*,
|
2006-08-26 00:59:04 +00:00
|
|
|
std::vector<std::pair<unsigned, std::string> > > >
|
2006-01-29 04:25:26 +00:00
|
|
|
&Patterns, unsigned Indent,
|
2009-07-03 00:10:29 +00:00
|
|
|
raw_ostream &OS) {
|
2006-08-26 00:59:04 +00:00
|
|
|
typedef std::pair<unsigned, std::string> CodeLine;
|
2006-01-29 04:25:26 +00:00
|
|
|
typedef std::vector<CodeLine> CodeList;
|
2008-01-05 22:30:17 +00:00
|
|
|
typedef std::vector<std::pair<const PatternToMatch*, CodeList> > PatternList;
|
2006-01-29 04:25:26 +00:00
|
|
|
|
|
|
|
if (Patterns.empty()) return;
|
|
|
|
|
2006-01-29 04:41:05 +00:00
|
|
|
// Figure out how many patterns share the next code line. Explicitly copy
|
|
|
|
// FirstCodeLine so that we don't invalidate a reference when changing
|
|
|
|
// Patterns.
|
|
|
|
const CodeLine FirstCodeLine = Patterns.back().second.back();
|
2006-01-29 04:25:26 +00:00
|
|
|
unsigned LastMatch = Patterns.size()-1;
|
|
|
|
while (LastMatch != 0 && Patterns[LastMatch-1].second.back() == FirstCodeLine)
|
|
|
|
--LastMatch;
|
|
|
|
|
|
|
|
// If not all patterns share this line, split the list into two pieces. The
|
|
|
|
// first chunk will use this line, the second chunk won't.
|
|
|
|
if (LastMatch != 0) {
|
|
|
|
PatternList Shared(Patterns.begin()+LastMatch, Patterns.end());
|
|
|
|
PatternList Other(Patterns.begin(), Patterns.begin()+LastMatch);
|
|
|
|
|
|
|
|
// FIXME: Emit braces?
|
|
|
|
if (Shared.size() == 1) {
|
2008-01-05 22:30:17 +00:00
|
|
|
const PatternToMatch &Pattern = *Shared.back().first;
|
2006-01-29 04:25:26 +00:00
|
|
|
OS << "\n" << std::string(Indent, ' ') << "// Pattern: ";
|
|
|
|
Pattern.getSrcPattern()->print(OS);
|
|
|
|
OS << "\n" << std::string(Indent, ' ') << "// Emits: ";
|
|
|
|
Pattern.getDstPattern()->print(OS);
|
|
|
|
OS << "\n";
|
2006-04-19 20:36:09 +00:00
|
|
|
unsigned AddedComplexity = Pattern.getAddedComplexity();
|
2006-01-29 04:25:26 +00:00
|
|
|
OS << std::string(Indent, ' ') << "// Pattern complexity = "
|
2008-01-05 22:58:54 +00:00
|
|
|
<< getPatternSize(Pattern.getSrcPattern(), CGP) + AddedComplexity
|
2006-04-19 18:07:24 +00:00
|
|
|
<< " cost = "
|
2008-01-05 22:58:54 +00:00
|
|
|
<< getResultPatternCost(Pattern.getDstPattern(), CGP)
|
2006-07-19 00:24:41 +00:00
|
|
|
<< " size = "
|
2008-01-05 22:58:54 +00:00
|
|
|
<< getResultPatternSize(Pattern.getDstPattern(), CGP) << "\n";
|
2006-01-29 04:25:26 +00:00
|
|
|
}
|
2006-08-26 00:59:04 +00:00
|
|
|
if (FirstCodeLine.first != 1) {
|
2006-01-29 04:25:26 +00:00
|
|
|
OS << std::string(Indent, ' ') << "{\n";
|
|
|
|
Indent += 2;
|
|
|
|
}
|
|
|
|
EmitPatterns(Shared, Indent, OS);
|
2006-08-26 00:59:04 +00:00
|
|
|
if (FirstCodeLine.first != 1) {
|
2006-01-29 04:25:26 +00:00
|
|
|
Indent -= 2;
|
|
|
|
OS << std::string(Indent, ' ') << "}\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Other.size() == 1) {
|
2008-01-05 22:30:17 +00:00
|
|
|
const PatternToMatch &Pattern = *Other.back().first;
|
2006-01-29 04:25:26 +00:00
|
|
|
OS << "\n" << std::string(Indent, ' ') << "// Pattern: ";
|
|
|
|
Pattern.getSrcPattern()->print(OS);
|
|
|
|
OS << "\n" << std::string(Indent, ' ') << "// Emits: ";
|
|
|
|
Pattern.getDstPattern()->print(OS);
|
|
|
|
OS << "\n";
|
2006-04-19 20:36:09 +00:00
|
|
|
unsigned AddedComplexity = Pattern.getAddedComplexity();
|
2006-01-29 04:25:26 +00:00
|
|
|
OS << std::string(Indent, ' ') << "// Pattern complexity = "
|
2008-01-05 22:58:54 +00:00
|
|
|
<< getPatternSize(Pattern.getSrcPattern(), CGP) + AddedComplexity
|
2006-04-19 18:07:24 +00:00
|
|
|
<< " cost = "
|
2008-01-05 22:58:54 +00:00
|
|
|
<< getResultPatternCost(Pattern.getDstPattern(), CGP)
|
2006-08-09 16:44:44 +00:00
|
|
|
<< " size = "
|
2008-01-05 22:58:54 +00:00
|
|
|
<< getResultPatternSize(Pattern.getDstPattern(), CGP) << "\n";
|
2006-01-29 04:25:26 +00:00
|
|
|
}
|
|
|
|
EmitPatterns(Other, Indent, OS);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-01-29 04:41:05 +00:00
|
|
|
// Remove this code from all of the patterns that share it.
|
|
|
|
bool ErasedPatterns = EraseCodeLine(Patterns);
|
|
|
|
|
2006-08-26 00:59:04 +00:00
|
|
|
bool isPredicate = FirstCodeLine.first == 1;
|
2006-01-29 04:25:26 +00:00
|
|
|
|
|
|
|
// Otherwise, every pattern in the list has this line. Emit it.
|
|
|
|
if (!isPredicate) {
|
|
|
|
// Normal code.
|
|
|
|
OS << std::string(Indent, ' ') << FirstCodeLine.second << "\n";
|
|
|
|
} else {
|
2006-01-29 04:41:05 +00:00
|
|
|
OS << std::string(Indent, ' ') << "if (" << FirstCodeLine.second;
|
|
|
|
|
|
|
|
// If the next code line is another predicate, and if all of the pattern
|
|
|
|
// in this group share the same next line, emit it inline now. Do this
|
|
|
|
// until we run out of common predicates.
|
2006-08-26 00:59:04 +00:00
|
|
|
while (!ErasedPatterns && Patterns.back().second.back().first == 1) {
|
2009-03-26 16:17:51 +00:00
|
|
|
// Check that all of the patterns in Patterns end with the same predicate.
|
2006-01-29 04:41:05 +00:00
|
|
|
bool AllEndWithSamePredicate = true;
|
|
|
|
for (unsigned i = 0, e = Patterns.size(); i != e; ++i)
|
|
|
|
if (Patterns[i].second.back() != Patterns.back().second.back()) {
|
|
|
|
AllEndWithSamePredicate = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// If all of the predicates aren't the same, we can't share them.
|
|
|
|
if (!AllEndWithSamePredicate) break;
|
|
|
|
|
|
|
|
// Otherwise we can. Emit it shared now.
|
|
|
|
OS << " &&\n" << std::string(Indent+4, ' ')
|
|
|
|
<< Patterns.back().second.back().second;
|
|
|
|
ErasedPatterns = EraseCodeLine(Patterns);
|
2006-01-29 04:25:26 +00:00
|
|
|
}
|
2006-01-29 04:41:05 +00:00
|
|
|
|
|
|
|
OS << ") {\n";
|
|
|
|
Indent += 2;
|
2006-01-29 04:25:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EmitPatterns(Patterns, Indent, OS);
|
|
|
|
|
|
|
|
if (isPredicate)
|
|
|
|
OS << std::string(Indent-2, ' ') << "}\n";
|
|
|
|
}
|
|
|
|
|
2006-11-08 23:01:03 +00:00
|
|
|
static std::string getLegalCName(std::string OpName) {
|
|
|
|
std::string::size_type pos = OpName.find("::");
|
|
|
|
if (pos != std::string::npos)
|
|
|
|
OpName.replace(pos, 2, "_");
|
|
|
|
return OpName;
|
2005-09-26 21:59:35 +00:00
|
|
|
}
|
|
|
|
|
2009-07-03 00:10:29 +00:00
|
|
|
void DAGISelEmitter::EmitInstructionSelector(raw_ostream &OS) {
|
2008-01-05 22:58:54 +00:00
|
|
|
const CodeGenTarget &Target = CGP.getTargetInfo();
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2008-08-20 21:45:57 +00:00
|
|
|
// Get the namespace to insert instructions into.
|
|
|
|
std::string InstNS = Target.getInstNamespace();
|
2005-10-18 04:41:01 +00:00
|
|
|
if (!InstNS.empty()) InstNS += "::";
|
|
|
|
|
2006-01-04 00:25:00 +00:00
|
|
|
// Group the patterns by their top-level opcodes.
|
2008-01-05 22:30:17 +00:00
|
|
|
std::map<std::string, std::vector<const PatternToMatch*> > PatternsByOpcode;
|
2006-07-15 08:45:20 +00:00
|
|
|
// All unique target node emission functions.
|
|
|
|
std::map<std::string, unsigned> EmitFunctions;
|
2008-01-06 01:10:31 +00:00
|
|
|
for (CodeGenDAGPatterns::ptm_iterator I = CGP.ptm_begin(),
|
2008-01-05 22:58:54 +00:00
|
|
|
E = CGP.ptm_end(); I != E; ++I) {
|
2008-01-05 22:30:17 +00:00
|
|
|
const PatternToMatch &Pattern = *I;
|
2008-01-05 22:25:12 +00:00
|
|
|
TreePatternNode *Node = Pattern.getSrcPattern();
|
2006-01-04 00:25:00 +00:00
|
|
|
if (!Node->isLeaf()) {
|
2008-01-05 22:58:54 +00:00
|
|
|
PatternsByOpcode[getOpcodeName(Node->getOperator(), CGP)].
|
2008-01-05 22:25:12 +00:00
|
|
|
push_back(&Pattern);
|
2006-01-04 00:25:00 +00:00
|
|
|
} else {
|
|
|
|
const ComplexPattern *CP;
|
2006-11-03 01:11:05 +00:00
|
|
|
if (dynamic_cast<IntInit*>(Node->getLeafValue())) {
|
2008-01-05 22:58:54 +00:00
|
|
|
PatternsByOpcode[getOpcodeName(CGP.getSDNodeNamed("imm"), CGP)].
|
2008-01-05 22:25:12 +00:00
|
|
|
push_back(&Pattern);
|
2010-02-14 22:22:58 +00:00
|
|
|
} else if ((CP = Node->getComplexPatternInfo(CGP))) {
|
2006-01-04 00:25:00 +00:00
|
|
|
std::vector<Record*> OpNodes = CP->getRootNodes();
|
|
|
|
for (unsigned j = 0, e = OpNodes.size(); j != e; j++) {
|
2008-01-05 22:58:54 +00:00
|
|
|
PatternsByOpcode[getOpcodeName(OpNodes[j], CGP)]
|
|
|
|
.insert(PatternsByOpcode[getOpcodeName(OpNodes[j], CGP)].begin(),
|
2008-01-05 22:25:12 +00:00
|
|
|
&Pattern);
|
2006-01-04 00:25:00 +00:00
|
|
|
}
|
|
|
|
} else {
|
2009-07-03 00:10:29 +00:00
|
|
|
errs() << "Unrecognized opcode '";
|
2006-01-04 00:25:00 +00:00
|
|
|
Node->dump();
|
2009-07-03 00:10:29 +00:00
|
|
|
errs() << "' on tree pattern '";
|
|
|
|
errs() << Pattern.getDstPattern()->getOperator()->getName() << "'!\n";
|
2006-01-04 00:25:00 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-08-09 16:44:44 +00:00
|
|
|
|
|
|
|
// For each opcode, there might be multiple select functions, one per
|
|
|
|
// ValueType of the node (or its first operand if it doesn't produce a
|
|
|
|
// non-chain result.
|
|
|
|
std::map<std::string, std::vector<std::string> > OpcodeVTMap;
|
|
|
|
|
2006-01-04 00:25:00 +00:00
|
|
|
// Emit one Select_* method for each top-level opcode. We do this instead of
|
|
|
|
// emitting one giant switch statement to support compilers where this will
|
|
|
|
// result in the recursive functions taking less stack space.
|
2008-01-05 22:30:17 +00:00
|
|
|
for (std::map<std::string, std::vector<const PatternToMatch*> >::iterator
|
2006-11-08 23:01:03 +00:00
|
|
|
PBOI = PatternsByOpcode.begin(), E = PatternsByOpcode.end();
|
|
|
|
PBOI != E; ++PBOI) {
|
|
|
|
const std::string &OpName = PBOI->first;
|
2008-01-05 22:30:17 +00:00
|
|
|
std::vector<const PatternToMatch*> &PatternsOfOp = PBOI->second;
|
2006-08-09 16:44:44 +00:00
|
|
|
assert(!PatternsOfOp.empty() && "No patterns but map has entry?");
|
|
|
|
|
|
|
|
// Split them into groups by type.
|
2009-08-11 20:47:22 +00:00
|
|
|
std::map<MVT::SimpleValueType,
|
2008-06-06 12:08:01 +00:00
|
|
|
std::vector<const PatternToMatch*> > PatternsByType;
|
2006-08-09 16:44:44 +00:00
|
|
|
for (unsigned i = 0, e = PatternsOfOp.size(); i != e; ++i) {
|
2008-01-05 22:30:17 +00:00
|
|
|
const PatternToMatch *Pat = PatternsOfOp[i];
|
2006-08-09 16:44:44 +00:00
|
|
|
TreePatternNode *SrcPat = Pat->getSrcPattern();
|
2008-08-26 07:01:28 +00:00
|
|
|
PatternsByType[SrcPat->getTypeNum(0)].push_back(Pat);
|
2006-08-09 16:41:21 +00:00
|
|
|
}
|
2006-08-09 16:44:44 +00:00
|
|
|
|
2009-08-11 20:47:22 +00:00
|
|
|
for (std::map<MVT::SimpleValueType,
|
2008-06-06 12:08:01 +00:00
|
|
|
std::vector<const PatternToMatch*> >::iterator
|
2006-08-09 16:44:44 +00:00
|
|
|
II = PatternsByType.begin(), EE = PatternsByType.end(); II != EE;
|
|
|
|
++II) {
|
2009-08-11 20:47:22 +00:00
|
|
|
MVT::SimpleValueType OpVT = II->first;
|
2008-01-05 22:30:17 +00:00
|
|
|
std::vector<const PatternToMatch*> &Patterns = II->second;
|
2008-10-15 06:17:21 +00:00
|
|
|
typedef std::pair<unsigned, std::string> CodeLine;
|
|
|
|
typedef std::vector<CodeLine> CodeList;
|
|
|
|
typedef CodeList::iterator CodeListI;
|
2006-07-28 22:51:01 +00:00
|
|
|
|
2008-01-05 22:30:17 +00:00
|
|
|
std::vector<std::pair<const PatternToMatch*, CodeList> > CodeForPatterns;
|
2006-08-09 16:44:44 +00:00
|
|
|
std::vector<std::vector<std::string> > PatternOpcodes;
|
|
|
|
std::vector<std::vector<std::string> > PatternVTs;
|
2006-08-26 01:02:19 +00:00
|
|
|
std::vector<std::set<std::string> > PatternDecls;
|
2008-05-31 02:11:25 +00:00
|
|
|
std::vector<bool> OutputIsVariadicFlags;
|
|
|
|
std::vector<unsigned> NumInputRootOpsCounts;
|
2006-08-09 16:44:44 +00:00
|
|
|
for (unsigned i = 0, e = Patterns.size(); i != e; ++i) {
|
|
|
|
CodeList GeneratedCode;
|
2006-08-26 01:02:19 +00:00
|
|
|
std::set<std::string> GeneratedDecl;
|
2006-08-09 16:44:44 +00:00
|
|
|
std::vector<std::string> TargetOpcodes;
|
|
|
|
std::vector<std::string> TargetVTs;
|
2008-05-31 02:11:25 +00:00
|
|
|
bool OutputIsVariadic;
|
|
|
|
unsigned NumInputRootOps;
|
2006-08-09 16:44:44 +00:00
|
|
|
GenerateCodeForPattern(*Patterns[i], GeneratedCode, GeneratedDecl,
|
2008-05-31 02:11:25 +00:00
|
|
|
TargetOpcodes, TargetVTs,
|
|
|
|
OutputIsVariadic, NumInputRootOps);
|
2006-08-09 16:44:44 +00:00
|
|
|
CodeForPatterns.push_back(std::make_pair(Patterns[i], GeneratedCode));
|
|
|
|
PatternDecls.push_back(GeneratedDecl);
|
|
|
|
PatternOpcodes.push_back(TargetOpcodes);
|
|
|
|
PatternVTs.push_back(TargetVTs);
|
2008-05-31 02:11:25 +00:00
|
|
|
OutputIsVariadicFlags.push_back(OutputIsVariadic);
|
|
|
|
NumInputRootOpsCounts.push_back(NumInputRootOps);
|
2006-08-09 16:41:21 +00:00
|
|
|
}
|
2006-08-09 16:44:44 +00:00
|
|
|
|
|
|
|
// Factor target node emission code (emitted by EmitResultCode) into
|
|
|
|
// separate functions. Uniquing and share them among all instruction
|
|
|
|
// selection routines.
|
|
|
|
for (unsigned i = 0, e = CodeForPatterns.size(); i != e; ++i) {
|
|
|
|
CodeList &GeneratedCode = CodeForPatterns[i].second;
|
|
|
|
std::vector<std::string> &TargetOpcodes = PatternOpcodes[i];
|
|
|
|
std::vector<std::string> &TargetVTs = PatternVTs[i];
|
2006-08-26 01:02:19 +00:00
|
|
|
std::set<std::string> Decls = PatternDecls[i];
|
2008-05-31 02:11:25 +00:00
|
|
|
bool OutputIsVariadic = OutputIsVariadicFlags[i];
|
|
|
|
unsigned NumInputRootOps = NumInputRootOpsCounts[i];
|
2006-08-26 00:59:04 +00:00
|
|
|
std::vector<std::string> AddedInits;
|
2006-08-09 16:44:44 +00:00
|
|
|
int CodeSize = (int)GeneratedCode.size();
|
|
|
|
int LastPred = -1;
|
|
|
|
for (int j = CodeSize-1; j >= 0; --j) {
|
2006-08-26 00:59:04 +00:00
|
|
|
if (LastPred == -1 && GeneratedCode[j].first == 1)
|
2006-08-09 16:44:44 +00:00
|
|
|
LastPred = j;
|
2006-08-26 00:59:04 +00:00
|
|
|
else if (LastPred != -1 && GeneratedCode[j].first == 2)
|
|
|
|
AddedInits.push_back(GeneratedCode[j].second);
|
2006-08-09 16:44:44 +00:00
|
|
|
}
|
|
|
|
|
2010-01-05 01:24:18 +00:00
|
|
|
std::string CalleeCode = "(SDNode *N";
|
2006-08-26 05:34:46 +00:00
|
|
|
std::string CallerCode = "(N";
|
2006-08-09 16:44:44 +00:00
|
|
|
for (unsigned j = 0, e = TargetOpcodes.size(); j != e; ++j) {
|
|
|
|
CalleeCode += ", unsigned Opc" + utostr(j);
|
|
|
|
CallerCode += ", " + TargetOpcodes[j];
|
|
|
|
}
|
|
|
|
for (unsigned j = 0, e = TargetVTs.size(); j != e; ++j) {
|
2009-09-11 09:01:57 +00:00
|
|
|
CalleeCode += ", MVT::SimpleValueType VT" + utostr(j);
|
2006-08-09 16:44:44 +00:00
|
|
|
CallerCode += ", " + TargetVTs[j];
|
|
|
|
}
|
2006-08-26 01:02:19 +00:00
|
|
|
for (std::set<std::string>::iterator
|
2006-08-09 16:44:44 +00:00
|
|
|
I = Decls.begin(), E = Decls.end(); I != E; ++I) {
|
2006-08-26 01:02:19 +00:00
|
|
|
std::string Name = *I;
|
2008-07-27 21:46:04 +00:00
|
|
|
CalleeCode += ", SDValue &" + Name;
|
2006-08-26 00:59:04 +00:00
|
|
|
CallerCode += ", " + Name;
|
2006-08-09 16:44:44 +00:00
|
|
|
}
|
2008-05-31 02:11:25 +00:00
|
|
|
|
|
|
|
if (OutputIsVariadic) {
|
|
|
|
CalleeCode += ", unsigned NumInputRootOps";
|
|
|
|
CallerCode += ", " + utostr(NumInputRootOps);
|
|
|
|
}
|
|
|
|
|
2006-08-09 16:44:44 +00:00
|
|
|
CallerCode += ");";
|
2009-11-14 16:37:18 +00:00
|
|
|
CalleeCode += ") {\n";
|
2006-08-26 00:59:04 +00:00
|
|
|
|
|
|
|
for (std::vector<std::string>::const_reverse_iterator
|
|
|
|
I = AddedInits.rbegin(), E = AddedInits.rend(); I != E; ++I)
|
|
|
|
CalleeCode += " " + *I + "\n";
|
|
|
|
|
2006-08-26 01:02:19 +00:00
|
|
|
for (int j = LastPred+1; j < CodeSize; ++j)
|
|
|
|
CalleeCode += " " + GeneratedCode[j].second + "\n";
|
2006-08-09 16:44:44 +00:00
|
|
|
for (int j = LastPred+1; j < CodeSize; ++j)
|
|
|
|
GeneratedCode.pop_back();
|
|
|
|
CalleeCode += "}\n";
|
|
|
|
|
|
|
|
// Uniquing the emission routines.
|
|
|
|
unsigned EmitFuncNum;
|
|
|
|
std::map<std::string, unsigned>::iterator EFI =
|
|
|
|
EmitFunctions.find(CalleeCode);
|
|
|
|
if (EFI != EmitFunctions.end()) {
|
|
|
|
EmitFuncNum = EFI->second;
|
2006-07-15 08:45:20 +00:00
|
|
|
} else {
|
2006-08-09 16:44:44 +00:00
|
|
|
EmitFuncNum = EmitFunctions.size();
|
|
|
|
EmitFunctions.insert(std::make_pair(CalleeCode, EmitFuncNum));
|
2009-11-14 16:37:18 +00:00
|
|
|
// Prevent emission routines from being inlined to reduce selection
|
|
|
|
// routines stack frame sizes.
|
|
|
|
OS << "DISABLE_INLINE ";
|
2006-08-11 08:59:35 +00:00
|
|
|
OS << "SDNode *Emit_" << utostr(EmitFuncNum) << CalleeCode;
|
2006-07-15 08:45:20 +00:00
|
|
|
}
|
2006-08-09 16:41:21 +00:00
|
|
|
|
2006-08-09 16:44:44 +00:00
|
|
|
// Replace the emission code within selection routines with calls to the
|
|
|
|
// emission functions.
|
2010-02-13 20:06:50 +00:00
|
|
|
if (GenDebug)
|
2010-01-05 01:24:18 +00:00
|
|
|
GeneratedCode.push_back(std::make_pair(0, "CurDAG->setSubgraphColor(N, \"red\");"));
|
2008-10-27 21:56:29 +00:00
|
|
|
CallerCode = "SDNode *Result = Emit_" + utostr(EmitFuncNum) + CallerCode;
|
|
|
|
GeneratedCode.push_back(std::make_pair(3, CallerCode));
|
|
|
|
if (GenDebug) {
|
|
|
|
GeneratedCode.push_back(std::make_pair(0, "if(Result) {"));
|
|
|
|
GeneratedCode.push_back(std::make_pair(0, " CurDAG->setSubgraphColor(Result, \"yellow\");"));
|
|
|
|
GeneratedCode.push_back(std::make_pair(0, " CurDAG->setSubgraphColor(Result, \"black\");"));
|
|
|
|
GeneratedCode.push_back(std::make_pair(0, "}"));
|
2010-01-05 01:24:18 +00:00
|
|
|
//GeneratedCode.push_back(std::make_pair(0, "CurDAG->setSubgraphColor(N, \"black\");"));
|
2008-10-27 21:56:29 +00:00
|
|
|
}
|
|
|
|
GeneratedCode.push_back(std::make_pair(0, "return Result;"));
|
2006-08-09 16:44:44 +00:00
|
|
|
}
|
2006-08-09 16:41:21 +00:00
|
|
|
|
2006-08-09 16:44:44 +00:00
|
|
|
// Print function.
|
2006-11-14 21:32:01 +00:00
|
|
|
std::string OpVTStr;
|
2009-08-11 20:47:22 +00:00
|
|
|
if (OpVT == MVT::iPTR) {
|
2006-11-14 22:17:10 +00:00
|
|
|
OpVTStr = "_iPTR";
|
2009-08-11 20:47:22 +00:00
|
|
|
} else if (OpVT == MVT::iPTRAny) {
|
2008-07-30 04:36:53 +00:00
|
|
|
OpVTStr = "_iPTRAny";
|
2009-08-11 20:47:22 +00:00
|
|
|
} else if (OpVT == MVT::isVoid) {
|
2006-11-14 22:17:10 +00:00
|
|
|
// Nodes with a void result actually have a first result type of either
|
|
|
|
// Other (a chain) or Flag. Since there is no one-to-one mapping from
|
|
|
|
// void to this case, we handle it specially here.
|
|
|
|
} else {
|
2009-08-11 20:47:22 +00:00
|
|
|
OpVTStr = "_" + getEnumName(OpVT).substr(5); // Skip 'MVT::'
|
2006-11-14 22:17:10 +00:00
|
|
|
}
|
2006-08-09 16:44:44 +00:00
|
|
|
std::map<std::string, std::vector<std::string> >::iterator OpVTI =
|
|
|
|
OpcodeVTMap.find(OpName);
|
|
|
|
if (OpVTI == OpcodeVTMap.end()) {
|
|
|
|
std::vector<std::string> VTSet;
|
|
|
|
VTSet.push_back(OpVTStr);
|
|
|
|
OpcodeVTMap.insert(std::make_pair(OpName, VTSet));
|
|
|
|
} else
|
|
|
|
OpVTI->second.push_back(OpVTStr);
|
|
|
|
|
2008-10-15 06:17:21 +00:00
|
|
|
// We want to emit all of the matching code now. However, we want to emit
|
|
|
|
// the matches in order of minimal cost. Sort the patterns so the least
|
|
|
|
// cost one is at the start.
|
|
|
|
std::stable_sort(CodeForPatterns.begin(), CodeForPatterns.end(),
|
|
|
|
PatternSortingPredicate(CGP));
|
|
|
|
|
|
|
|
// Scan the code to see if all of the patterns are reachable and if it is
|
|
|
|
// possible that the last one might not match.
|
|
|
|
bool mightNotMatch = true;
|
|
|
|
for (unsigned i = 0, e = CodeForPatterns.size(); i != e; ++i) {
|
|
|
|
CodeList &GeneratedCode = CodeForPatterns[i].second;
|
|
|
|
mightNotMatch = false;
|
|
|
|
|
|
|
|
for (unsigned j = 0, e = GeneratedCode.size(); j != e; ++j) {
|
|
|
|
if (GeneratedCode[j].first == 1) { // predicate.
|
|
|
|
mightNotMatch = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this pattern definitely matches, and if it isn't the last one, the
|
|
|
|
// patterns after it CANNOT ever match. Error out.
|
|
|
|
if (mightNotMatch == false && i != CodeForPatterns.size()-1) {
|
2009-07-03 00:10:29 +00:00
|
|
|
errs() << "Pattern '";
|
|
|
|
CodeForPatterns[i].first->getSrcPattern()->print(errs());
|
|
|
|
errs() << "' is impossible to select!\n";
|
2008-10-15 06:17:21 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-09 16:44:44 +00:00
|
|
|
// Loop through and reverse all of the CodeList vectors, as we will be
|
|
|
|
// accessing them from their logical front, but accessing the end of a
|
|
|
|
// vector is more efficient.
|
|
|
|
for (unsigned i = 0, e = CodeForPatterns.size(); i != e; ++i) {
|
|
|
|
CodeList &GeneratedCode = CodeForPatterns[i].second;
|
|
|
|
std::reverse(GeneratedCode.begin(), GeneratedCode.end());
|
|
|
|
}
|
2006-01-04 00:25:00 +00:00
|
|
|
|
2006-08-09 16:44:44 +00:00
|
|
|
// Next, reverse the list of patterns itself for the same reason.
|
|
|
|
std::reverse(CodeForPatterns.begin(), CodeForPatterns.end());
|
2006-01-29 04:25:26 +00:00
|
|
|
|
2009-01-29 01:37:18 +00:00
|
|
|
OS << "SDNode *Select_" << getLegalCName(OpName)
|
2010-01-05 01:24:18 +00:00
|
|
|
<< OpVTStr << "(SDNode *N) {\n";
|
2009-01-29 01:37:18 +00:00
|
|
|
|
2006-08-09 16:44:44 +00:00
|
|
|
// Emit all of the patterns now, grouped together to share code.
|
|
|
|
EmitPatterns(CodeForPatterns, 2, OS);
|
2006-01-29 04:25:26 +00:00
|
|
|
|
2006-09-21 18:28:27 +00:00
|
|
|
// If the last pattern has predicates (which could fail) emit code to
|
|
|
|
// catch the case where nothing handles a pattern.
|
2006-08-09 16:44:44 +00:00
|
|
|
if (mightNotMatch) {
|
2008-09-27 23:53:14 +00:00
|
|
|
OS << "\n";
|
2006-11-08 23:01:03 +00:00
|
|
|
if (OpName != "ISD::INTRINSIC_W_CHAIN" &&
|
|
|
|
OpName != "ISD::INTRINSIC_WO_CHAIN" &&
|
2008-09-27 23:53:14 +00:00
|
|
|
OpName != "ISD::INTRINSIC_VOID")
|
|
|
|
OS << " CannotYetSelect(N);\n";
|
|
|
|
else
|
|
|
|
OS << " CannotYetSelectIntrinsic(N);\n";
|
|
|
|
|
|
|
|
OS << " return NULL;\n";
|
2006-03-28 00:41:33 +00:00
|
|
|
}
|
2006-08-09 16:44:44 +00:00
|
|
|
OS << "}\n\n";
|
2006-03-28 00:41:33 +00:00
|
|
|
}
|
2006-01-04 00:25:00 +00:00
|
|
|
}
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
OS << "// The main instruction selector code.\n"
|
2010-01-05 01:24:18 +00:00
|
|
|
<< "SDNode *SelectCode(SDNode *N) {\n"
|
|
|
|
<< " MVT::SimpleValueType NVT = N->getValueType(0).getSimpleVT().SimpleTy;\n"
|
|
|
|
<< " switch (N->getOpcode()) {\n"
|
2008-11-05 18:30:52 +00:00
|
|
|
<< " default:\n"
|
2010-01-05 01:24:18 +00:00
|
|
|
<< " assert(!N->isMachineOpcode() && \"Node already selected!\");\n"
|
2008-11-05 18:30:52 +00:00
|
|
|
<< " break;\n"
|
|
|
|
<< " case ISD::EntryToken: // These nodes remain the same.\n"
|
2005-12-18 21:05:44 +00:00
|
|
|
<< " case ISD::BasicBlock:\n"
|
2006-01-11 19:52:27 +00:00
|
|
|
<< " case ISD::Register:\n"
|
2006-02-05 08:46:14 +00:00
|
|
|
<< " case ISD::HANDLENODE:\n"
|
2006-02-05 05:22:18 +00:00
|
|
|
<< " case ISD::TargetConstant:\n"
|
2008-02-14 08:57:00 +00:00
|
|
|
<< " case ISD::TargetConstantFP:\n"
|
2006-02-05 05:22:18 +00:00
|
|
|
<< " case ISD::TargetConstantPool:\n"
|
|
|
|
<< " case ISD::TargetFrameIndex:\n"
|
2008-09-16 21:48:12 +00:00
|
|
|
<< " case ISD::TargetExternalSymbol:\n"
|
2009-10-30 01:27:03 +00:00
|
|
|
<< " case ISD::TargetBlockAddress:\n"
|
2006-04-22 18:53:45 +00:00
|
|
|
<< " case ISD::TargetJumpTable:\n"
|
2007-04-20 21:38:10 +00:00
|
|
|
<< " case ISD::TargetGlobalTLSAddress:\n"
|
Eliminate the ISel priority queue, which used the topological order for a
priority function. Instead, just iterate over the AllNodes list, which is
already in topological order. This eliminates a fair amount of bookkeeping,
and speeds up the isel phase by about 15% on many testcases.
The impact on most targets is that AddToISelQueue calls can be simply removed.
In the x86 target, there are two additional notable changes.
The rule-bending AND+SHIFT optimization in MatchAddress that creates new
pre-isel nodes during isel is now a little more verbose, but more robust.
Instead of either creating an invalid DAG or creating an invalid topological
sort, as it has historically done, it can now just insert the new nodes into
the node list at a position where they will be consistent with the topological
ordering.
Also, the address-matching code has logic that checked to see if a node was
"already selected". However, when a node is selected, it has all its uses
taken away via ReplaceAllUsesWith or equivalent, so it won't recieve any
further visits from MatchAddress. This code is now removed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@58748 91177308-0d34-0410-b5e6-96231b3b80d8
2008-11-05 04:14:16 +00:00
|
|
|
<< " case ISD::TargetGlobalAddress:\n"
|
|
|
|
<< " case ISD::TokenFactor:\n"
|
|
|
|
<< " case ISD::CopyFromReg:\n"
|
|
|
|
<< " case ISD::CopyToReg: {\n"
|
2006-08-11 08:59:35 +00:00
|
|
|
<< " return NULL;\n"
|
2006-02-09 00:37:58 +00:00
|
|
|
<< " }\n"
|
2005-09-07 23:44:43 +00:00
|
|
|
<< " case ISD::AssertSext:\n"
|
2005-09-26 22:10:24 +00:00
|
|
|
<< " case ISD::AssertZext: {\n"
|
2010-01-05 01:24:18 +00:00
|
|
|
<< " ReplaceUses(SDValue(N, 0), N->getOperand(0));\n"
|
2006-08-11 08:59:35 +00:00
|
|
|
<< " return NULL;\n"
|
2005-10-25 20:35:14 +00:00
|
|
|
<< " }\n"
|
2007-01-26 17:29:20 +00:00
|
|
|
<< " case ISD::INLINEASM: return Select_INLINEASM(N);\n"
|
2008-07-02 23:23:19 +00:00
|
|
|
<< " case ISD::EH_LABEL: return Select_EH_LABEL(N);\n"
|
2008-03-15 00:03:38 +00:00
|
|
|
<< " case ISD::UNDEF: return Select_UNDEF(N);\n";
|
2006-01-26 23:08:55 +00:00
|
|
|
|
2006-01-04 00:25:00 +00:00
|
|
|
// Loop over all of the case statements, emiting a call to each method we
|
|
|
|
// emitted above.
|
2008-01-05 22:30:17 +00:00
|
|
|
for (std::map<std::string, std::vector<const PatternToMatch*> >::iterator
|
2006-11-08 23:01:03 +00:00
|
|
|
PBOI = PatternsByOpcode.begin(), E = PatternsByOpcode.end();
|
|
|
|
PBOI != E; ++PBOI) {
|
|
|
|
const std::string &OpName = PBOI->first;
|
2006-08-09 16:44:44 +00:00
|
|
|
// Potentially multiple versions of select for this opcode. One for each
|
|
|
|
// ValueType of the node (or its first true operand if it doesn't produce a
|
|
|
|
// result.
|
|
|
|
std::map<std::string, std::vector<std::string> >::iterator OpVTI =
|
|
|
|
OpcodeVTMap.find(OpName);
|
|
|
|
std::vector<std::string> &OpVTs = OpVTI->second;
|
2006-11-08 23:01:03 +00:00
|
|
|
OS << " case " << OpName << ": {\n";
|
2009-05-12 22:32:29 +00:00
|
|
|
// If we have only one variant and it's the default, elide the
|
|
|
|
// switch. Marginally faster, and makes MSVC happier.
|
|
|
|
if (OpVTs.size()==1 && OpVTs[0].empty()) {
|
|
|
|
OS << " return Select_" << getLegalCName(OpName) << "(N);\n";
|
|
|
|
OS << " break;\n";
|
|
|
|
OS << " }\n";
|
|
|
|
continue;
|
|
|
|
}
|
2007-09-04 20:18:28 +00:00
|
|
|
// Keep track of whether we see a pattern that has an iPtr result.
|
|
|
|
bool HasPtrPattern = false;
|
|
|
|
bool HasDefaultPattern = false;
|
2006-11-14 21:50:27 +00:00
|
|
|
|
2007-09-04 20:18:28 +00:00
|
|
|
OS << " switch (NVT) {\n";
|
|
|
|
for (unsigned i = 0, e = OpVTs.size(); i < e; ++i) {
|
|
|
|
std::string &VTStr = OpVTs[i];
|
|
|
|
if (VTStr.empty()) {
|
|
|
|
HasDefaultPattern = true;
|
|
|
|
continue;
|
|
|
|
}
|
2006-11-14 21:50:27 +00:00
|
|
|
|
2007-09-04 20:18:28 +00:00
|
|
|
// If this is a match on iPTR: don't emit it directly, we need special
|
|
|
|
// code.
|
|
|
|
if (VTStr == "_iPTR") {
|
|
|
|
HasPtrPattern = true;
|
|
|
|
continue;
|
2006-08-09 16:44:44 +00:00
|
|
|
}
|
2009-08-11 20:47:22 +00:00
|
|
|
OS << " case MVT::" << VTStr.substr(1) << ":\n"
|
2007-09-04 20:18:28 +00:00
|
|
|
<< " return Select_" << getLegalCName(OpName)
|
|
|
|
<< VTStr << "(N);\n";
|
|
|
|
}
|
|
|
|
OS << " default:\n";
|
2006-11-14 21:50:27 +00:00
|
|
|
|
2007-09-04 20:18:28 +00:00
|
|
|
// If there is an iPTR result version of this pattern, emit it here.
|
|
|
|
if (HasPtrPattern) {
|
2008-06-06 12:08:01 +00:00
|
|
|
OS << " if (TLI.getPointerTy() == NVT)\n";
|
2007-09-04 20:18:28 +00:00
|
|
|
OS << " return Select_" << getLegalCName(OpName) <<"_iPTR(N);\n";
|
|
|
|
}
|
|
|
|
if (HasDefaultPattern) {
|
|
|
|
OS << " return Select_" << getLegalCName(OpName) << "(N);\n";
|
2006-08-09 16:44:44 +00:00
|
|
|
}
|
2007-09-04 20:18:28 +00:00
|
|
|
OS << " break;\n";
|
|
|
|
OS << " }\n";
|
|
|
|
OS << " break;\n";
|
2006-08-09 16:44:44 +00:00
|
|
|
OS << " }\n";
|
2005-09-23 19:36:15 +00:00
|
|
|
}
|
|
|
|
|
2005-09-07 23:44:43 +00:00
|
|
|
OS << " } // end of big switch.\n\n"
|
2010-01-05 01:24:18 +00:00
|
|
|
<< " if (N->getOpcode() != ISD::INTRINSIC_W_CHAIN &&\n"
|
|
|
|
<< " N->getOpcode() != ISD::INTRINSIC_WO_CHAIN &&\n"
|
|
|
|
<< " N->getOpcode() != ISD::INTRINSIC_VOID) {\n"
|
2008-09-27 23:53:14 +00:00
|
|
|
<< " CannotYetSelect(N);\n"
|
2006-03-25 06:47:53 +00:00
|
|
|
<< " } else {\n"
|
2008-09-27 23:53:14 +00:00
|
|
|
<< " CannotYetSelectIntrinsic(N);\n"
|
2006-03-25 06:47:53 +00:00
|
|
|
<< " }\n"
|
2008-09-27 23:53:14 +00:00
|
|
|
<< " return NULL;\n"
|
|
|
|
<< "}\n\n";
|
2005-09-07 23:44:43 +00:00
|
|
|
}
|
|
|
|
|
2009-07-03 00:10:29 +00:00
|
|
|
void DAGISelEmitter::run(raw_ostream &OS) {
|
2008-01-05 22:58:54 +00:00
|
|
|
EmitSourceFileHeader("DAG Instruction Selector for the " +
|
|
|
|
CGP.getTargetInfo().getName() + " target", OS);
|
2005-09-07 23:44:43 +00:00
|
|
|
|
2005-09-14 00:09:24 +00:00
|
|
|
OS << "// *** NOTE: This file is #included into the middle of the target\n"
|
|
|
|
<< "// *** instruction selector class. These functions are really "
|
|
|
|
<< "methods.\n\n";
|
2006-08-09 16:44:44 +00:00
|
|
|
|
2008-05-14 10:17:11 +00:00
|
|
|
OS << "// Include standard, target-independent definitions and methods used\n"
|
|
|
|
<< "// by the instruction selector.\n";
|
2009-05-04 18:40:41 +00:00
|
|
|
OS << "#include \"llvm/CodeGen/DAGISelHeader.h\"\n\n";
|
2005-09-24 00:50:51 +00:00
|
|
|
|
2008-01-05 22:54:53 +00:00
|
|
|
EmitNodeTransforms(OS);
|
2008-01-05 22:43:57 +00:00
|
|
|
EmitPredicateFunctions(OS);
|
|
|
|
|
2009-08-23 04:44:11 +00:00
|
|
|
DEBUG(errs() << "\n\nALL PATTERNS TO MATCH:\n\n");
|
2008-01-06 01:10:31 +00:00
|
|
|
for (CodeGenDAGPatterns::ptm_iterator I = CGP.ptm_begin(), E = CGP.ptm_end();
|
2008-01-05 22:25:12 +00:00
|
|
|
I != E; ++I) {
|
2009-08-23 04:44:11 +00:00
|
|
|
DEBUG(errs() << "PATTERN: "; I->getSrcPattern()->dump());
|
|
|
|
DEBUG(errs() << "\nRESULT: "; I->getDstPattern()->dump());
|
|
|
|
DEBUG(errs() << "\n");
|
2006-12-07 22:21:48 +00:00
|
|
|
}
|
2005-09-29 19:28:10 +00:00
|
|
|
|
2005-09-16 00:29:46 +00:00
|
|
|
// At this point, we have full information about the 'Patterns' we need to
|
|
|
|
// parse, both implicitly from instructions as well as from explicit pattern
|
Emit an error if instructions or patterns are defined but can never match.
Currently we check that immediate values live on the RHS of commutative
operators. Defining ORI like this, for example:
def ORI : DForm_4<24, (ops GPRC:$dst, GPRC:$src1, u16imm:$src2),
"ori $dst, $src1, $src2",
[(set GPRC:$dst, (or immZExt16:$src2, GPRC:$src1))]>;
results in:
tblgen: In ORI: Instruction can never match: Immediate values must be on the RHS of commutative operators!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23501 91177308-0d34-0410-b5e6-96231b3b80d8
2005-09-28 19:27:25 +00:00
|
|
|
// definitions. Emit the resultant instruction selector.
|
2005-09-07 23:44:43 +00:00
|
|
|
EmitInstructionSelector(OS);
|
|
|
|
|
2010-02-15 08:04:42 +00:00
|
|
|
#if 0
|
|
|
|
MatcherNode *Matcher = 0;
|
|
|
|
// Walk the patterns backwards, building a matcher for each and adding it to
|
|
|
|
// the matcher for the whole target.
|
|
|
|
for (CodeGenDAGPatterns::ptm_iterator I = CGP.ptm_begin(),
|
|
|
|
E = CGP.ptm_end(); I != E;) {
|
|
|
|
const PatternToMatch &Pattern = *--E;
|
|
|
|
MatcherNode *N = ConvertPatternToMatcher(Pattern, CGP);
|
|
|
|
|
|
|
|
if (Matcher == 0)
|
|
|
|
Matcher = N;
|
|
|
|
else
|
|
|
|
Matcher = new PushMatcherNode(N, Matcher);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
EmitMatcherTable(Matcher, OS);
|
|
|
|
|
|
|
|
|
|
|
|
//Matcher->dump();
|
|
|
|
delete Matcher;
|
|
|
|
#endif
|
2005-09-07 23:44:43 +00:00
|
|
|
}
|