2010-02-15 08:04:42 +00:00
|
|
|
//===- DAGISelMatcher.h - Representation of DAG pattern matcher -----------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef TBLGEN_DAGISELMATCHER_H
|
|
|
|
#define TBLGEN_DAGISELMATCHER_H
|
|
|
|
|
2010-02-16 07:21:10 +00:00
|
|
|
#include "llvm/CodeGen/ValueTypes.h"
|
2010-02-15 08:04:42 +00:00
|
|
|
#include "llvm/ADT/OwningPtr.h"
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2010-02-16 07:21:10 +00:00
|
|
|
#include "llvm/Support/Casting.h"
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
class CodeGenDAGPatterns;
|
2010-02-25 02:04:40 +00:00
|
|
|
class Matcher;
|
2010-02-15 08:04:42 +00:00
|
|
|
class PatternToMatch;
|
|
|
|
class raw_ostream;
|
|
|
|
class ComplexPattern;
|
2010-02-18 22:03:03 +00:00
|
|
|
class Record;
|
2010-02-27 21:48:43 +00:00
|
|
|
class SDNodeInfo;
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-03-01 07:17:40 +00:00
|
|
|
Matcher *ConvertPatternToMatcher(const PatternToMatch &Pattern,unsigned Variant,
|
2010-02-25 02:04:40 +00:00
|
|
|
const CodeGenDAGPatterns &CGP);
|
2010-02-28 20:49:53 +00:00
|
|
|
Matcher *OptimizeMatcher(Matcher *Matcher, const CodeGenDAGPatterns &CGP);
|
2010-03-01 01:54:19 +00:00
|
|
|
void EmitMatcherTable(const Matcher *Matcher, const CodeGenDAGPatterns &CGP,
|
|
|
|
raw_ostream &OS);
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// Matcher - Base class for all the the DAG ISel Matcher representation
|
2010-02-15 08:04:42 +00:00
|
|
|
/// nodes.
|
2010-02-25 02:04:40 +00:00
|
|
|
class Matcher {
|
2010-02-18 02:53:41 +00:00
|
|
|
// The next matcher node that is executed after this one. Null if this is the
|
|
|
|
// last stage of a match.
|
2010-02-25 02:04:40 +00:00
|
|
|
OwningPtr<Matcher> Next;
|
2010-02-15 08:04:42 +00:00
|
|
|
public:
|
|
|
|
enum KindTy {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
// Matcher state manipulation.
|
2010-02-25 01:56:48 +00:00
|
|
|
Scope, // Push a checking scope.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
RecordNode, // Record the current node.
|
2010-02-24 07:31:45 +00:00
|
|
|
RecordChild, // Record a child of the current node.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
RecordMemRef, // Record the memref in the current node.
|
|
|
|
CaptureFlagInput, // If the current node has an input flag, save it.
|
|
|
|
MoveChild, // Move current node to specified child.
|
|
|
|
MoveParent, // Move current node to parent.
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-18 22:03:03 +00:00
|
|
|
// Predicate checking.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
CheckSame, // Fail if not same as prev match.
|
2010-02-15 08:04:42 +00:00
|
|
|
CheckPatternPredicate,
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
CheckPredicate, // Fail if node predicate fails.
|
|
|
|
CheckOpcode, // Fail if not opcode.
|
2010-03-01 06:59:22 +00:00
|
|
|
SwitchOpcode, // Dispatch based on opcode.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
CheckType, // Fail if not correct type.
|
2010-02-24 20:15:25 +00:00
|
|
|
CheckChildType, // Fail if child has wrong type.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
CheckInteger, // Fail if wrong val.
|
|
|
|
CheckCondCode, // Fail if not condcode.
|
2010-02-15 08:04:42 +00:00
|
|
|
CheckValueType,
|
|
|
|
CheckComplexPat,
|
|
|
|
CheckAndImm,
|
2010-02-16 06:10:58 +00:00
|
|
|
CheckOrImm,
|
2010-02-17 06:23:39 +00:00
|
|
|
CheckFoldableChainNode,
|
2010-02-18 22:03:03 +00:00
|
|
|
CheckChainCompatible,
|
|
|
|
|
|
|
|
// Node creation/emisssion.
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
EmitInteger, // Create a TargetConstant
|
|
|
|
EmitStringInteger, // Create a TargetConstant from a string.
|
|
|
|
EmitRegister, // Create a register.
|
|
|
|
EmitConvertToTarget, // Convert a imm/fpimm to target imm/fpimm
|
|
|
|
EmitMergeInputChains, // Merge together a chains for an input.
|
|
|
|
EmitCopyToReg, // Emit a copytoreg into a physreg.
|
|
|
|
EmitNode, // Create a DAG node
|
|
|
|
EmitNodeXForm, // Run a SDNodeXForm
|
2010-02-24 05:33:42 +00:00
|
|
|
MarkFlagResults, // Indicate which interior nodes have flag results.
|
2010-02-28 02:31:26 +00:00
|
|
|
CompleteMatch, // Finish a match and update the results.
|
2010-02-28 20:55:18 +00:00
|
|
|
MorphNodeTo // Build a node, finish a match and update results.
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
const KindTy Kind;
|
2010-02-18 02:49:24 +00:00
|
|
|
|
2010-02-15 08:04:42 +00:00
|
|
|
protected:
|
2010-02-25 02:04:40 +00:00
|
|
|
Matcher(KindTy K) : Kind(K) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
virtual ~Matcher() {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
KindTy getKind() const { return Kind; }
|
2010-02-18 02:49:24 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
Matcher *getNext() { return Next.get(); }
|
|
|
|
const Matcher *getNext() const { return Next.get(); }
|
|
|
|
void setNext(Matcher *C) { Next.reset(C); }
|
|
|
|
Matcher *takeNext() { return Next.take(); }
|
2010-02-24 07:31:45 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
OwningPtr<Matcher> &getNextPtr() { return Next; }
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *) { return true; }
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
bool isEqual(const Matcher *M) const {
|
|
|
|
if (getKind() != M->getKind()) return false;
|
|
|
|
return isEqualImpl(M);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned getHash() const {
|
2010-02-26 07:35:27 +00:00
|
|
|
// Clear the high bit so we don't conflict with tombstones etc.
|
|
|
|
return ((getHashImpl() << 4) ^ getKind()) & (~0U>>1);
|
2010-02-25 06:49:58 +00:00
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
/// isSafeToReorderWithPatternPredicate - Return true if it is safe to sink a
|
|
|
|
/// PatternPredicate node past this one.
|
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-02-27 07:49:13 +00:00
|
|
|
/// isContradictory - Return true of these two matchers could never match on
|
|
|
|
/// the same node.
|
|
|
|
bool isContradictory(const Matcher *Other) const {
|
|
|
|
// Since this predicate is reflexive, we canonicalize the ordering so that
|
|
|
|
// we always match a node against nodes with kinds that are greater or equal
|
|
|
|
// to them. For example, we'll pass in a CheckType node as an argument to
|
|
|
|
// the CheckOpcode method, not the other way around.
|
|
|
|
if (getKind() < Other->getKind())
|
|
|
|
return isContradictoryImpl(Other);
|
|
|
|
return Other->isContradictoryImpl(this);
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:53:39 +00:00
|
|
|
void print(raw_ostream &OS, unsigned indent = 0) const;
|
2010-02-27 07:49:13 +00:00
|
|
|
void printOne(raw_ostream &OS) const;
|
2010-02-15 08:04:42 +00:00
|
|
|
void dump() const;
|
2010-02-18 02:49:24 +00:00
|
|
|
protected:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const = 0;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const = 0;
|
|
|
|
virtual unsigned getHashImpl() const = 0;
|
2010-02-27 07:49:13 +00:00
|
|
|
virtual bool isContradictoryImpl(const Matcher *M) const { return false; }
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 19:00:39 +00:00
|
|
|
/// ScopeMatcher - This attempts to match each of its children to find the first
|
|
|
|
/// one that successfully matches. If one child fails, it tries the next child.
|
|
|
|
/// If none of the children match then this check fails. It never has a 'next'.
|
2010-02-25 02:04:40 +00:00
|
|
|
class ScopeMatcher : public Matcher {
|
2010-02-25 19:00:39 +00:00
|
|
|
SmallVector<Matcher*, 4> Children;
|
2010-02-15 08:04:42 +00:00
|
|
|
public:
|
2010-02-25 19:00:39 +00:00
|
|
|
ScopeMatcher(Matcher *const *children, unsigned numchildren)
|
|
|
|
: Matcher(Scope), Children(children, children+numchildren) {
|
2010-02-15 08:04:42 +00:00
|
|
|
}
|
2010-02-25 19:00:39 +00:00
|
|
|
virtual ~ScopeMatcher();
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-25 19:00:39 +00:00
|
|
|
unsigned getNumChildren() const { return Children.size(); }
|
|
|
|
|
|
|
|
Matcher *getChild(unsigned i) { return Children[i]; }
|
|
|
|
const Matcher *getChild(unsigned i) const { return Children[i]; }
|
|
|
|
|
|
|
|
void resetChild(unsigned i, Matcher *N) {
|
|
|
|
delete Children[i];
|
|
|
|
Children[i] = N;
|
|
|
|
}
|
|
|
|
|
|
|
|
Matcher *takeChild(unsigned i) {
|
|
|
|
Matcher *Res = Children[i];
|
|
|
|
Children[i] = 0;
|
|
|
|
return Res;
|
|
|
|
}
|
2010-02-26 07:35:27 +00:00
|
|
|
|
|
|
|
void setNumChildren(unsigned NC) {
|
|
|
|
if (NC < Children.size()) {
|
|
|
|
// delete any children we're about to lose pointers to.
|
|
|
|
for (unsigned i = NC, e = Children.size(); i != e; ++i)
|
|
|
|
delete Children[i];
|
|
|
|
}
|
|
|
|
Children.resize(NC);
|
|
|
|
}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-25 01:56:48 +00:00
|
|
|
return N->getKind() == Scope;
|
2010-02-15 08:04:42 +00:00
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const { return false; }
|
2010-02-25 19:00:39 +00:00
|
|
|
virtual unsigned getHashImpl() const { return 12312; }
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// RecordMatcher - Save the current node in the operand list.
|
|
|
|
class RecordMatcher : public Matcher {
|
2010-02-17 01:03:09 +00:00
|
|
|
/// WhatFor - This is a string indicating why we're recording this. This
|
|
|
|
/// should only be used for comment generation not anything semantic.
|
|
|
|
std::string WhatFor;
|
2010-03-01 02:24:17 +00:00
|
|
|
|
|
|
|
/// ResultNo - The slot number in the RecordedNodes vector that this will be,
|
|
|
|
/// just printed as a comment.
|
|
|
|
unsigned ResultNo;
|
2010-02-15 08:04:42 +00:00
|
|
|
public:
|
2010-03-01 02:24:17 +00:00
|
|
|
RecordMatcher(const std::string &whatfor, unsigned resultNo)
|
|
|
|
: Matcher(RecordNode), WhatFor(whatfor), ResultNo(resultNo) {}
|
2010-02-17 01:03:09 +00:00
|
|
|
|
2010-02-17 01:27:29 +00:00
|
|
|
const std::string &getWhatFor() const { return WhatFor; }
|
2010-03-01 02:24:17 +00:00
|
|
|
unsigned getResultNo() const { return ResultNo; }
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-18 22:03:03 +00:00
|
|
|
return N->getKind() == RecordNode;
|
2010-02-15 08:04:42 +00:00
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const { return true; }
|
|
|
|
virtual unsigned getHashImpl() const { return 0; }
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// RecordChildMatcher - Save a numbered child of the current node, or fail
|
2010-02-24 07:31:45 +00:00
|
|
|
/// the match if it doesn't exist. This is logically equivalent to:
|
|
|
|
/// MoveChild N + RecordNode + MoveParent.
|
2010-02-25 02:04:40 +00:00
|
|
|
class RecordChildMatcher : public Matcher {
|
2010-02-24 07:31:45 +00:00
|
|
|
unsigned ChildNo;
|
|
|
|
|
|
|
|
/// WhatFor - This is a string indicating why we're recording this. This
|
|
|
|
/// should only be used for comment generation not anything semantic.
|
|
|
|
std::string WhatFor;
|
2010-03-01 02:24:17 +00:00
|
|
|
|
|
|
|
/// ResultNo - The slot number in the RecordedNodes vector that this will be,
|
|
|
|
/// just printed as a comment.
|
|
|
|
unsigned ResultNo;
|
2010-02-24 07:31:45 +00:00
|
|
|
public:
|
2010-03-01 02:24:17 +00:00
|
|
|
RecordChildMatcher(unsigned childno, const std::string &whatfor,
|
|
|
|
unsigned resultNo)
|
|
|
|
: Matcher(RecordChild), ChildNo(childno), WhatFor(whatfor),
|
|
|
|
ResultNo(resultNo) {}
|
2010-02-24 07:31:45 +00:00
|
|
|
|
|
|
|
unsigned getChildNo() const { return ChildNo; }
|
|
|
|
const std::string &getWhatFor() const { return WhatFor; }
|
2010-03-01 02:24:17 +00:00
|
|
|
unsigned getResultNo() const { return ResultNo; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-24 07:31:45 +00:00
|
|
|
return N->getKind() == RecordChild;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<RecordChildMatcher>(M)->getChildNo() == getChildNo();
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return getChildNo(); }
|
2010-02-24 07:31:45 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// RecordMemRefMatcher - Save the current node's memref.
|
|
|
|
class RecordMemRefMatcher : public Matcher {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
RecordMemRefMatcher() : Matcher(RecordMemRef) {}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
return N->getKind() == RecordMemRef;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const { return true; }
|
|
|
|
virtual unsigned getHashImpl() const { return 0; }
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CaptureFlagInputMatcher - If the current record has a flag input, record
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
/// it so that it is used as an input to the generated code.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CaptureFlagInputMatcher : public Matcher {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CaptureFlagInputMatcher() : Matcher(CaptureFlagInput) {}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
return N->getKind() == CaptureFlagInput;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const { return true; }
|
|
|
|
virtual unsigned getHashImpl() const { return 0; }
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// MoveChildMatcher - This tells the interpreter to move into the
|
2010-02-15 08:04:42 +00:00
|
|
|
/// specified child node.
|
2010-02-25 02:04:40 +00:00
|
|
|
class MoveChildMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
unsigned ChildNo;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
MoveChildMatcher(unsigned childNo) : Matcher(MoveChild), ChildNo(childNo) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
unsigned getChildNo() const { return ChildNo; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == MoveChild;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<MoveChildMatcher>(M)->getChildNo() == getChildNo();
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return getChildNo(); }
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// MoveParentMatcher - This tells the interpreter to move to the parent
|
2010-02-15 08:04:42 +00:00
|
|
|
/// of the current node.
|
2010-02-25 02:04:40 +00:00
|
|
|
class MoveParentMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
MoveParentMatcher() : Matcher(MoveParent) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == MoveParent;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const { return true; }
|
|
|
|
virtual unsigned getHashImpl() const { return 0; }
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckSameMatcher - This checks to see if this node is exactly the same
|
2010-02-15 08:04:42 +00:00
|
|
|
/// node as the specified match that was recorded with 'Record'. This is used
|
|
|
|
/// when patterns have the same name in them, like '(mul GPR:$in, GPR:$in)'.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckSameMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
unsigned MatchNumber;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckSameMatcher(unsigned matchnumber)
|
2010-02-25 06:49:58 +00:00
|
|
|
: Matcher(CheckSame), MatchNumber(matchnumber) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
unsigned getMatchNumber() const { return MatchNumber; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckSame;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<CheckSameMatcher>(M)->getMatchNumber() == getMatchNumber();
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return getMatchNumber(); }
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckPatternPredicateMatcher - This checks the target-specific predicate
|
2010-02-15 08:04:42 +00:00
|
|
|
/// to see if the entire pattern is capable of matching. This predicate does
|
|
|
|
/// not take a node as input. This is used for subtarget feature checks etc.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckPatternPredicateMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
std::string Predicate;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckPatternPredicateMatcher(StringRef predicate)
|
2010-02-25 06:49:58 +00:00
|
|
|
: Matcher(CheckPatternPredicate), Predicate(predicate) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
StringRef getPredicate() const { return Predicate; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckPatternPredicate;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<CheckPatternPredicateMatcher>(M)->getPredicate() == Predicate;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const;
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckPredicateMatcher - This checks the target-specific predicate to
|
2010-02-15 08:04:42 +00:00
|
|
|
/// see if the node is acceptable.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckPredicateMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
StringRef PredName;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckPredicateMatcher(StringRef predname)
|
|
|
|
: Matcher(CheckPredicate), PredName(predname) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
StringRef getPredicateName() const { return PredName; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckPredicate;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
// TODO: Ok?
|
|
|
|
//virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<CheckPredicateMatcher>(M)->PredName == PredName;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const;
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckOpcodeMatcher - This checks to see if the current node has the
|
2010-02-15 08:04:42 +00:00
|
|
|
/// specified opcode, if not it fails to match.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckOpcodeMatcher : public Matcher {
|
2010-02-27 21:48:43 +00:00
|
|
|
const SDNodeInfo &Opcode;
|
2010-02-15 08:04:42 +00:00
|
|
|
public:
|
2010-02-27 21:48:43 +00:00
|
|
|
CheckOpcodeMatcher(const SDNodeInfo &opcode)
|
|
|
|
: Matcher(CheckOpcode), Opcode(opcode) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-27 21:48:43 +00:00
|
|
|
const SDNodeInfo &getOpcode() const { return Opcode; }
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckOpcode;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-03-01 06:59:22 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual unsigned getHashImpl() const;
|
2010-02-27 07:49:13 +00:00
|
|
|
virtual bool isContradictoryImpl(const Matcher *M) const;
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
2010-03-01 06:59:22 +00:00
|
|
|
|
|
|
|
/// SwitchOpcodeMatcher - Switch based on the current node's opcode, dispatching
|
|
|
|
/// to one matcher per opcode. If the opcode doesn't match any of the cases,
|
|
|
|
/// then the match fails. This is semantically equivalent to a Scope node where
|
|
|
|
/// every child does a CheckOpcode, but is much faster.
|
|
|
|
class SwitchOpcodeMatcher : public Matcher {
|
|
|
|
SmallVector<std::pair<const SDNodeInfo*, Matcher*>, 8> Cases;
|
|
|
|
public:
|
|
|
|
SwitchOpcodeMatcher(const std::pair<const SDNodeInfo*, Matcher*> *cases,
|
|
|
|
unsigned numcases)
|
|
|
|
: Matcher(SwitchOpcode), Cases(cases, cases+numcases) {}
|
|
|
|
|
|
|
|
static inline bool classof(const Matcher *N) {
|
|
|
|
return N->getKind() == SwitchOpcode;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned getNumCases() const { return Cases.size(); }
|
|
|
|
|
|
|
|
const SDNodeInfo &getCaseOpcode(unsigned i) const { return *Cases[i].first; }
|
|
|
|
Matcher *getCaseMatcher(unsigned i) { return Cases[i].second; }
|
|
|
|
const Matcher *getCaseMatcher(unsigned i) const { return Cases[i].second; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
|
|
|
virtual bool isEqualImpl(const Matcher *M) const { return false; }
|
|
|
|
virtual unsigned getHashImpl() const { return 4123; }
|
|
|
|
};
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckTypeMatcher - This checks to see if the current node has the
|
2010-02-15 08:04:42 +00:00
|
|
|
/// specified type, if not it fails to match.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckTypeMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
MVT::SimpleValueType Type;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckTypeMatcher(MVT::SimpleValueType type)
|
|
|
|
: Matcher(CheckType), Type(type) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
MVT::SimpleValueType getType() const { return Type; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckType;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
2010-02-26 08:05:36 +00:00
|
|
|
return cast<CheckTypeMatcher>(M)->Type == Type;
|
2010-02-25 06:49:58 +00:00
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return Type; }
|
2010-02-27 07:49:13 +00:00
|
|
|
virtual bool isContradictoryImpl(const Matcher *M) const;
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
2010-02-24 20:15:25 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckChildTypeMatcher - This checks to see if a child node has the
|
2010-02-24 20:15:25 +00:00
|
|
|
/// specified type, if not it fails to match.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckChildTypeMatcher : public Matcher {
|
2010-02-24 20:15:25 +00:00
|
|
|
unsigned ChildNo;
|
|
|
|
MVT::SimpleValueType Type;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckChildTypeMatcher(unsigned childno, MVT::SimpleValueType type)
|
|
|
|
: Matcher(CheckChildType), ChildNo(childno), Type(type) {}
|
2010-02-24 20:15:25 +00:00
|
|
|
|
|
|
|
unsigned getChildNo() const { return ChildNo; }
|
|
|
|
MVT::SimpleValueType getType() const { return Type; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-24 20:15:25 +00:00
|
|
|
return N->getKind() == CheckChildType;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<CheckChildTypeMatcher>(M)->ChildNo == ChildNo &&
|
|
|
|
cast<CheckChildTypeMatcher>(M)->Type == Type;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return (Type << 3) | ChildNo; }
|
2010-02-27 07:49:13 +00:00
|
|
|
virtual bool isContradictoryImpl(const Matcher *M) const;
|
2010-02-24 20:15:25 +00:00
|
|
|
};
|
|
|
|
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckIntegerMatcher - This checks to see if the current node is a
|
2010-02-15 08:04:42 +00:00
|
|
|
/// ConstantSDNode with the specified integer value, if not it fails to match.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckIntegerMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
int64_t Value;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckIntegerMatcher(int64_t value)
|
|
|
|
: Matcher(CheckInteger), Value(value) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
int64_t getValue() const { return Value; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckInteger;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<CheckIntegerMatcher>(M)->Value == Value;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return Value; }
|
2010-02-27 08:11:15 +00:00
|
|
|
virtual bool isContradictoryImpl(const Matcher *M) const;
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckCondCodeMatcher - This checks to see if the current node is a
|
2010-02-15 08:04:42 +00:00
|
|
|
/// CondCodeSDNode with the specified condition, if not it fails to match.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckCondCodeMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
StringRef CondCodeName;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckCondCodeMatcher(StringRef condcodename)
|
|
|
|
: Matcher(CheckCondCode), CondCodeName(condcodename) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
StringRef getCondCodeName() const { return CondCodeName; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckCondCode;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<CheckCondCodeMatcher>(M)->CondCodeName == CondCodeName;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const;
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckValueTypeMatcher - This checks to see if the current node is a
|
2010-02-15 08:04:42 +00:00
|
|
|
/// VTSDNode with the specified type, if not it fails to match.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckValueTypeMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
StringRef TypeName;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckValueTypeMatcher(StringRef type_name)
|
|
|
|
: Matcher(CheckValueType), TypeName(type_name) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
StringRef getTypeName() const { return TypeName; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckValueType;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<CheckValueTypeMatcher>(M)->TypeName == TypeName;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const;
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckComplexPatMatcher - This node runs the specified ComplexPattern on
|
2010-02-15 08:04:42 +00:00
|
|
|
/// the current node.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckComplexPatMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
const ComplexPattern &Pattern;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckComplexPatMatcher(const ComplexPattern &pattern)
|
|
|
|
: Matcher(CheckComplexPat), Pattern(pattern) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
2010-02-17 00:31:50 +00:00
|
|
|
const ComplexPattern &getPattern() const { return Pattern; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckComplexPat;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
// Not safe to move a pattern predicate past a complex pattern.
|
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return false; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return &cast<CheckComplexPatMatcher>(M)->Pattern == &Pattern;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const {
|
|
|
|
return (unsigned)(intptr_t)&Pattern;
|
|
|
|
}
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckAndImmMatcher - This checks to see if the current node is an 'and'
|
2010-02-15 08:04:42 +00:00
|
|
|
/// with something equivalent to the specified immediate.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckAndImmMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
int64_t Value;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckAndImmMatcher(int64_t value)
|
|
|
|
: Matcher(CheckAndImm), Value(value) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
int64_t getValue() const { return Value; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckAndImm;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<CheckAndImmMatcher>(M)->Value == Value;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return Value; }
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckOrImmMatcher - This checks to see if the current node is an 'and'
|
2010-02-15 08:04:42 +00:00
|
|
|
/// with something equivalent to the specified immediate.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckOrImmMatcher : public Matcher {
|
2010-02-15 08:04:42 +00:00
|
|
|
int64_t Value;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckOrImmMatcher(int64_t value)
|
|
|
|
: Matcher(CheckOrImm), Value(value) {}
|
2010-02-15 08:04:42 +00:00
|
|
|
|
|
|
|
int64_t getValue() const { return Value; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-15 08:04:42 +00:00
|
|
|
return N->getKind() == CheckOrImm;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<CheckOrImmMatcher>(M)->Value == Value;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return Value; }
|
2010-02-15 08:04:42 +00:00
|
|
|
};
|
2010-02-16 06:10:58 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckFoldableChainNodeMatcher - This checks to see if the current node
|
2010-02-16 19:15:55 +00:00
|
|
|
/// (which defines a chain operand) is safe to fold into a larger pattern.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckFoldableChainNodeMatcher : public Matcher {
|
2010-02-16 06:10:58 +00:00
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckFoldableChainNodeMatcher()
|
|
|
|
: Matcher(CheckFoldableChainNode) {}
|
2010-02-16 06:10:58 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-16 19:15:55 +00:00
|
|
|
return N->getKind() == CheckFoldableChainNode;
|
2010-02-16 06:10:58 +00:00
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const { return true; }
|
|
|
|
virtual unsigned getHashImpl() const { return 0; }
|
2010-02-16 06:10:58 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CheckChainCompatibleMatcher - Verify that the current node's chain
|
2010-02-17 06:23:39 +00:00
|
|
|
/// operand is 'compatible' with the specified recorded node's.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CheckChainCompatibleMatcher : public Matcher {
|
2010-02-17 06:23:39 +00:00
|
|
|
unsigned PreviousOp;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CheckChainCompatibleMatcher(unsigned previousop)
|
|
|
|
: Matcher(CheckChainCompatible), PreviousOp(previousop) {}
|
2010-02-17 06:23:39 +00:00
|
|
|
|
|
|
|
unsigned getPreviousOp() const { return PreviousOp; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-17 06:23:39 +00:00
|
|
|
return N->getKind() == CheckChainCompatible;
|
|
|
|
}
|
|
|
|
|
2010-02-27 06:22:57 +00:00
|
|
|
virtual bool isSafeToReorderWithPatternPredicate() const { return true; }
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
2010-02-26 08:06:02 +00:00
|
|
|
return cast<CheckChainCompatibleMatcher>(M)->PreviousOp == PreviousOp;
|
2010-02-25 06:49:58 +00:00
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return PreviousOp; }
|
2010-02-17 06:23:39 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// EmitIntegerMatcher - This creates a new TargetConstant.
|
|
|
|
class EmitIntegerMatcher : public Matcher {
|
2010-02-18 22:03:03 +00:00
|
|
|
int64_t Val;
|
|
|
|
MVT::SimpleValueType VT;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
EmitIntegerMatcher(int64_t val, MVT::SimpleValueType vt)
|
|
|
|
: Matcher(EmitInteger), Val(val), VT(vt) {}
|
2010-02-18 22:03:03 +00:00
|
|
|
|
2010-02-19 07:49:56 +00:00
|
|
|
int64_t getValue() const { return Val; }
|
2010-02-18 22:03:03 +00:00
|
|
|
MVT::SimpleValueType getVT() const { return VT; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-18 22:03:03 +00:00
|
|
|
return N->getKind() == EmitInteger;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<EmitIntegerMatcher>(M)->Val == Val &&
|
|
|
|
cast<EmitIntegerMatcher>(M)->VT == VT;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return (Val << 4) | VT; }
|
2010-02-18 22:03:03 +00:00
|
|
|
};
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// EmitStringIntegerMatcher - A target constant whose value is represented
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
/// by a string.
|
2010-02-25 02:04:40 +00:00
|
|
|
class EmitStringIntegerMatcher : public Matcher {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
std::string Val;
|
|
|
|
MVT::SimpleValueType VT;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
EmitStringIntegerMatcher(const std::string &val, MVT::SimpleValueType vt)
|
|
|
|
: Matcher(EmitStringInteger), Val(val), VT(vt) {}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
const std::string &getValue() const { return Val; }
|
|
|
|
MVT::SimpleValueType getVT() const { return VT; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
return N->getKind() == EmitStringInteger;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<EmitStringIntegerMatcher>(M)->Val == Val &&
|
|
|
|
cast<EmitStringIntegerMatcher>(M)->VT == VT;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const;
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
};
|
2010-02-18 22:03:03 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// EmitRegisterMatcher - This creates a new TargetConstant.
|
|
|
|
class EmitRegisterMatcher : public Matcher {
|
2010-02-18 22:03:03 +00:00
|
|
|
/// Reg - The def for the register that we're emitting. If this is null, then
|
|
|
|
/// this is a reference to zero_reg.
|
|
|
|
Record *Reg;
|
|
|
|
MVT::SimpleValueType VT;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
EmitRegisterMatcher(Record *reg, MVT::SimpleValueType vt)
|
|
|
|
: Matcher(EmitRegister), Reg(reg), VT(vt) {}
|
2010-02-18 22:03:03 +00:00
|
|
|
|
|
|
|
Record *getReg() const { return Reg; }
|
|
|
|
MVT::SimpleValueType getVT() const { return VT; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-18 22:03:03 +00:00
|
|
|
return N->getKind() == EmitRegister;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<EmitRegisterMatcher>(M)->Reg == Reg &&
|
|
|
|
cast<EmitRegisterMatcher>(M)->VT == VT;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const {
|
|
|
|
return ((unsigned)(intptr_t)Reg) << 4 | VT;
|
|
|
|
}
|
2010-02-18 22:03:03 +00:00
|
|
|
};
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// EmitConvertToTargetMatcher - Emit an operation that reads a specified
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
/// recorded node and converts it from being a ISD::Constant to
|
|
|
|
/// ISD::TargetConstant, likewise for ConstantFP.
|
2010-02-25 02:04:40 +00:00
|
|
|
class EmitConvertToTargetMatcher : public Matcher {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
unsigned Slot;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
EmitConvertToTargetMatcher(unsigned slot)
|
|
|
|
: Matcher(EmitConvertToTarget), Slot(slot) {}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
unsigned getSlot() const { return Slot; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
return N->getKind() == EmitConvertToTarget;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<EmitConvertToTargetMatcher>(M)->Slot == Slot;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const { return Slot; }
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// EmitMergeInputChainsMatcher - Emit a node that merges a list of input
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
/// chains together with a token factor. The list of nodes are the nodes in the
|
|
|
|
/// matched pattern that have chain input/outputs. This node adds all input
|
|
|
|
/// chains of these nodes if they are not themselves a node in the pattern.
|
2010-02-25 02:04:40 +00:00
|
|
|
class EmitMergeInputChainsMatcher : public Matcher {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
SmallVector<unsigned, 3> ChainNodes;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
EmitMergeInputChainsMatcher(const unsigned *nodes, unsigned NumNodes)
|
|
|
|
: Matcher(EmitMergeInputChains), ChainNodes(nodes, nodes+NumNodes) {}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
unsigned getNumNodes() const { return ChainNodes.size(); }
|
|
|
|
|
|
|
|
unsigned getNode(unsigned i) const {
|
|
|
|
assert(i < ChainNodes.size());
|
|
|
|
return ChainNodes[i];
|
|
|
|
}
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
return N->getKind() == EmitMergeInputChains;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<EmitMergeInputChainsMatcher>(M)->ChainNodes == ChainNodes;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const;
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// EmitCopyToRegMatcher - Emit a CopyToReg node from a value to a physreg,
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
/// pushing the chain and flag results.
|
|
|
|
///
|
2010-02-25 02:04:40 +00:00
|
|
|
class EmitCopyToRegMatcher : public Matcher {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
unsigned SrcSlot; // Value to copy into the physreg.
|
|
|
|
Record *DestPhysReg;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
EmitCopyToRegMatcher(unsigned srcSlot, Record *destPhysReg)
|
|
|
|
: Matcher(EmitCopyToReg), SrcSlot(srcSlot), DestPhysReg(destPhysReg) {}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
unsigned getSrcSlot() const { return SrcSlot; }
|
|
|
|
Record *getDestPhysReg() const { return DestPhysReg; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
return N->getKind() == EmitCopyToReg;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<EmitCopyToRegMatcher>(M)->SrcSlot == SrcSlot &&
|
|
|
|
cast<EmitCopyToRegMatcher>(M)->DestPhysReg == DestPhysReg;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const {
|
|
|
|
return SrcSlot ^ ((unsigned)(intptr_t)DestPhysReg << 4);
|
|
|
|
}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// EmitNodeXFormMatcher - Emit an operation that runs an SDNodeXForm on a
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
/// recorded node and records the result.
|
2010-02-25 02:04:40 +00:00
|
|
|
class EmitNodeXFormMatcher : public Matcher {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
unsigned Slot;
|
|
|
|
Record *NodeXForm;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
EmitNodeXFormMatcher(unsigned slot, Record *nodeXForm)
|
|
|
|
: Matcher(EmitNodeXForm), Slot(slot), NodeXForm(nodeXForm) {}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
unsigned getSlot() const { return Slot; }
|
|
|
|
Record *getNodeXForm() const { return NodeXForm; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
return N->getKind() == EmitNodeXForm;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<EmitNodeXFormMatcher>(M)->Slot == Slot &&
|
|
|
|
cast<EmitNodeXFormMatcher>(M)->NodeXForm == NodeXForm;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const {
|
|
|
|
return Slot ^ ((unsigned)(intptr_t)NodeXForm << 4);
|
|
|
|
}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
};
|
2010-02-18 22:03:03 +00:00
|
|
|
|
2010-02-28 02:31:26 +00:00
|
|
|
/// EmitNodeMatcherCommon - Common class shared between EmitNode and
|
2010-02-28 20:55:18 +00:00
|
|
|
/// MorphNodeTo.
|
2010-02-28 02:31:26 +00:00
|
|
|
class EmitNodeMatcherCommon : public Matcher {
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
std::string OpcodeName;
|
|
|
|
const SmallVector<MVT::SimpleValueType, 3> VTs;
|
|
|
|
const SmallVector<unsigned, 6> Operands;
|
2010-02-28 21:53:42 +00:00
|
|
|
bool HasChain, HasInFlag, HasOutFlag, HasMemRefs;
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
/// NumFixedArityOperands - If this is a fixed arity node, this is set to -1.
|
|
|
|
/// If this is a varidic node, this is set to the number of fixed arity
|
|
|
|
/// operands in the root of the pattern. The rest are appended to this node.
|
|
|
|
int NumFixedArityOperands;
|
|
|
|
public:
|
2010-02-28 02:31:26 +00:00
|
|
|
EmitNodeMatcherCommon(const std::string &opcodeName,
|
|
|
|
const MVT::SimpleValueType *vts, unsigned numvts,
|
|
|
|
const unsigned *operands, unsigned numops,
|
2010-02-28 21:53:42 +00:00
|
|
|
bool hasChain, bool hasInFlag, bool hasOutFlag,
|
|
|
|
bool hasmemrefs,
|
2010-02-28 20:55:18 +00:00
|
|
|
int numfixedarityoperands, bool isMorphNodeTo)
|
|
|
|
: Matcher(isMorphNodeTo ? MorphNodeTo : EmitNode), OpcodeName(opcodeName),
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
VTs(vts, vts+numvts), Operands(operands, operands+numops),
|
2010-02-28 21:53:42 +00:00
|
|
|
HasChain(hasChain), HasInFlag(hasInFlag), HasOutFlag(hasOutFlag),
|
|
|
|
HasMemRefs(hasmemrefs), NumFixedArityOperands(numfixedarityoperands) {}
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
const std::string &getOpcodeName() const { return OpcodeName; }
|
|
|
|
|
|
|
|
unsigned getNumVTs() const { return VTs.size(); }
|
|
|
|
MVT::SimpleValueType getVT(unsigned i) const {
|
|
|
|
assert(i < VTs.size());
|
|
|
|
return VTs[i];
|
|
|
|
}
|
2010-02-28 20:49:53 +00:00
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
unsigned getNumOperands() const { return Operands.size(); }
|
|
|
|
unsigned getOperand(unsigned i) const {
|
|
|
|
assert(i < Operands.size());
|
|
|
|
return Operands[i];
|
2010-02-28 20:49:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const SmallVectorImpl<MVT::SimpleValueType> &getVTList() const { return VTs; }
|
|
|
|
const SmallVectorImpl<unsigned> &getOperandList() const { return Operands; }
|
|
|
|
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
|
|
|
|
bool hasChain() const { return HasChain; }
|
2010-02-28 21:53:42 +00:00
|
|
|
bool hasInFlag() const { return HasInFlag; }
|
|
|
|
bool hasOutFlag() const { return HasOutFlag; }
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
bool hasMemRefs() const { return HasMemRefs; }
|
|
|
|
int getNumFixedArityOperands() const { return NumFixedArityOperands; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-28 20:55:18 +00:00
|
|
|
return N->getKind() == EmitNode || N->getKind() == MorphNodeTo;
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const;
|
|
|
|
virtual unsigned getHashImpl() const;
|
Lots of improvements to the new dagisel emitter. This gets it to
the point where it is to the 95% feature complete mark, it just
needs result updating to be done (then testing, optimization
etc).
More specificallly, this adds support for chain and flag handling
on the result nodes, support for sdnodexforms, support for variadic
nodes, memrefs, pinned physreg inputs, and probably lots of other
stuff.
In the old DAGISelEmitter, this deletes the dead code related to
OperatorMap, cleans up a variety of dead stuff handling "implicit
remapping" from things like globaladdr -> targetglobaladdr (which
is no longer used because globaladdr always needs to be legalized),
and some minor formatting fixes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96716 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-21 03:22:59 +00:00
|
|
|
};
|
2010-02-21 06:03:07 +00:00
|
|
|
|
2010-02-28 02:31:26 +00:00
|
|
|
/// EmitNodeMatcher - This signals a successful match and generates a node.
|
|
|
|
class EmitNodeMatcher : public EmitNodeMatcherCommon {
|
2010-02-28 02:41:25 +00:00
|
|
|
unsigned FirstResultSlot;
|
2010-02-28 02:31:26 +00:00
|
|
|
public:
|
|
|
|
EmitNodeMatcher(const std::string &opcodeName,
|
|
|
|
const MVT::SimpleValueType *vts, unsigned numvts,
|
|
|
|
const unsigned *operands, unsigned numops,
|
2010-02-28 21:53:42 +00:00
|
|
|
bool hasChain, bool hasInFlag, bool hasOutFlag,
|
|
|
|
bool hasmemrefs,
|
2010-02-28 02:41:25 +00:00
|
|
|
int numfixedarityoperands, unsigned firstresultslot)
|
2010-02-28 02:31:26 +00:00
|
|
|
: EmitNodeMatcherCommon(opcodeName, vts, numvts, operands, numops, hasChain,
|
2010-02-28 21:53:42 +00:00
|
|
|
hasInFlag, hasOutFlag, hasmemrefs,
|
|
|
|
numfixedarityoperands, false),
|
2010-02-28 02:41:25 +00:00
|
|
|
FirstResultSlot(firstresultslot) {}
|
|
|
|
|
|
|
|
unsigned getFirstResultSlot() const { return FirstResultSlot; }
|
2010-02-28 02:31:26 +00:00
|
|
|
|
|
|
|
static inline bool classof(const Matcher *N) {
|
|
|
|
return N->getKind() == EmitNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2010-02-28 20:55:18 +00:00
|
|
|
class MorphNodeToMatcher : public EmitNodeMatcherCommon {
|
2010-02-28 02:31:26 +00:00
|
|
|
const PatternToMatch &Pattern;
|
|
|
|
public:
|
2010-02-28 20:55:18 +00:00
|
|
|
MorphNodeToMatcher(const std::string &opcodeName,
|
|
|
|
const MVT::SimpleValueType *vts, unsigned numvts,
|
|
|
|
const unsigned *operands, unsigned numops,
|
2010-02-28 21:53:42 +00:00
|
|
|
bool hasChain, bool hasInFlag, bool hasOutFlag,
|
|
|
|
bool hasmemrefs,
|
2010-02-28 20:55:18 +00:00
|
|
|
int numfixedarityoperands, const PatternToMatch &pattern)
|
2010-02-28 02:31:26 +00:00
|
|
|
: EmitNodeMatcherCommon(opcodeName, vts, numvts, operands, numops, hasChain,
|
2010-02-28 21:53:42 +00:00
|
|
|
hasInFlag, hasOutFlag, hasmemrefs,
|
|
|
|
numfixedarityoperands, true),
|
2010-02-28 02:31:26 +00:00
|
|
|
Pattern(pattern) {
|
|
|
|
}
|
|
|
|
|
|
|
|
const PatternToMatch &getPattern() const { return Pattern; }
|
|
|
|
|
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-28 20:55:18 +00:00
|
|
|
return N->getKind() == MorphNodeTo;
|
2010-02-28 02:31:26 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// MarkFlagResultsMatcher - This node indicates which non-root nodes in the
|
|
|
|
/// pattern produce flags. This allows CompleteMatchMatcher to update them
|
2010-02-24 05:33:42 +00:00
|
|
|
/// with the output flag of the resultant code.
|
2010-02-25 02:04:40 +00:00
|
|
|
class MarkFlagResultsMatcher : public Matcher {
|
2010-02-24 05:33:42 +00:00
|
|
|
SmallVector<unsigned, 3> FlagResultNodes;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
MarkFlagResultsMatcher(const unsigned *nodes, unsigned NumNodes)
|
|
|
|
: Matcher(MarkFlagResults), FlagResultNodes(nodes, nodes+NumNodes) {}
|
2010-02-24 05:33:42 +00:00
|
|
|
|
|
|
|
unsigned getNumNodes() const { return FlagResultNodes.size(); }
|
|
|
|
|
|
|
|
unsigned getNode(unsigned i) const {
|
|
|
|
assert(i < FlagResultNodes.size());
|
|
|
|
return FlagResultNodes[i];
|
|
|
|
}
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-24 05:33:42 +00:00
|
|
|
return N->getKind() == MarkFlagResults;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<MarkFlagResultsMatcher>(M)->FlagResultNodes == FlagResultNodes;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const;
|
2010-02-24 05:33:42 +00:00
|
|
|
};
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
/// CompleteMatchMatcher - Complete a match by replacing the results of the
|
2010-02-21 06:03:07 +00:00
|
|
|
/// pattern with the newly generated nodes. This also prints a comment
|
|
|
|
/// indicating the source and dest patterns.
|
2010-02-25 02:04:40 +00:00
|
|
|
class CompleteMatchMatcher : public Matcher {
|
2010-02-21 06:03:07 +00:00
|
|
|
SmallVector<unsigned, 2> Results;
|
2010-02-18 22:03:03 +00:00
|
|
|
const PatternToMatch &Pattern;
|
|
|
|
public:
|
2010-02-25 02:04:40 +00:00
|
|
|
CompleteMatchMatcher(const unsigned *results, unsigned numresults,
|
2010-02-28 20:49:53 +00:00
|
|
|
const PatternToMatch &pattern)
|
2010-02-25 02:04:40 +00:00
|
|
|
: Matcher(CompleteMatch), Results(results, results+numresults),
|
2010-02-21 06:03:07 +00:00
|
|
|
Pattern(pattern) {}
|
|
|
|
|
|
|
|
unsigned getNumResults() const { return Results.size(); }
|
|
|
|
unsigned getResult(unsigned R) const { return Results[R]; }
|
2010-02-18 22:03:03 +00:00
|
|
|
const PatternToMatch &getPattern() const { return Pattern; }
|
|
|
|
|
2010-02-25 02:04:40 +00:00
|
|
|
static inline bool classof(const Matcher *N) {
|
2010-02-21 06:03:07 +00:00
|
|
|
return N->getKind() == CompleteMatch;
|
2010-02-18 22:03:03 +00:00
|
|
|
}
|
|
|
|
|
2010-02-25 06:49:58 +00:00
|
|
|
private:
|
2010-02-25 06:53:39 +00:00
|
|
|
virtual void printImpl(raw_ostream &OS, unsigned indent) const;
|
2010-02-25 06:49:58 +00:00
|
|
|
virtual bool isEqualImpl(const Matcher *M) const {
|
|
|
|
return cast<CompleteMatchMatcher>(M)->Results == Results &&
|
|
|
|
&cast<CompleteMatchMatcher>(M)->Pattern == &Pattern;
|
|
|
|
}
|
|
|
|
virtual unsigned getHashImpl() const;
|
2010-02-18 22:03:03 +00:00
|
|
|
};
|
2010-02-28 02:31:26 +00:00
|
|
|
|
2010-02-15 08:04:42 +00:00
|
|
|
} // end namespace llvm
|
|
|
|
|
|
|
|
#endif
|