2009-07-11 19:39:44 +00:00
|
|
|
//===- AsmMatcherEmitter.cpp - Generate an assembly matcher ---------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This tablegen backend emits a target specifier matcher for converting parsed
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
// assembly operands in the MCInst structures. It also emits a matcher for
|
|
|
|
// custom operand parsing.
|
|
|
|
//
|
|
|
|
// Converting assembly operands into MCInst structures
|
|
|
|
// ---------------------------------------------------
|
2009-07-11 19:39:44 +00:00
|
|
|
//
|
2009-08-07 08:26:05 +00:00
|
|
|
// The input to the target specific matcher is a list of literal tokens and
|
|
|
|
// operands. The target specific parser should generally eliminate any syntax
|
|
|
|
// which is not relevant for matching; for example, comma tokens should have
|
|
|
|
// already been consumed and eliminated by the parser. Most instructions will
|
|
|
|
// end up with a single literal token (the instruction name) and some number of
|
|
|
|
// operands.
|
|
|
|
//
|
|
|
|
// Some example inputs, for X86:
|
|
|
|
// 'addl' (immediate ...) (register ...)
|
|
|
|
// 'add' (immediate ...) (memory ...)
|
2010-10-29 22:13:48 +00:00
|
|
|
// 'call' '*' %epc
|
2009-08-07 08:26:05 +00:00
|
|
|
//
|
|
|
|
// The assembly matcher is responsible for converting this input into a precise
|
|
|
|
// machine instruction (i.e., an instruction with a well defined encoding). This
|
|
|
|
// mapping has several properties which complicate matching:
|
|
|
|
//
|
|
|
|
// - It may be ambiguous; many architectures can legally encode particular
|
|
|
|
// variants of an instruction in different ways (for example, using a smaller
|
|
|
|
// encoding for small immediates). Such ambiguities should never be
|
|
|
|
// arbitrarily resolved by the assembler, the assembler is always responsible
|
|
|
|
// for choosing the "best" available instruction.
|
|
|
|
//
|
|
|
|
// - It may depend on the subtarget or the assembler context. Instructions
|
|
|
|
// which are invalid for the current mode, but otherwise unambiguous (e.g.,
|
|
|
|
// an SSE instruction in a file being assembled for i486) should be accepted
|
|
|
|
// and rejected by the assembler front end. However, if the proper encoding
|
|
|
|
// for an instruction is dependent on the assembler context then the matcher
|
|
|
|
// is responsible for selecting the correct machine instruction for the
|
|
|
|
// current mode.
|
|
|
|
//
|
|
|
|
// The core matching algorithm attempts to exploit the regularity in most
|
|
|
|
// instruction sets to quickly determine the set of possibly matching
|
|
|
|
// instructions, and the simplify the generated code. Additionally, this helps
|
|
|
|
// to ensure that the ambiguities are intentionally resolved by the user.
|
|
|
|
//
|
|
|
|
// The matching is divided into two distinct phases:
|
|
|
|
//
|
|
|
|
// 1. Classification: Each operand is mapped to the unique set which (a)
|
|
|
|
// contains it, and (b) is the largest such subset for which a single
|
|
|
|
// instruction could match all members.
|
|
|
|
//
|
|
|
|
// For register classes, we can generate these subgroups automatically. For
|
|
|
|
// arbitrary operands, we expect the user to define the classes and their
|
|
|
|
// relations to one another (for example, 8-bit signed immediates as a
|
|
|
|
// subset of 32-bit immediates).
|
|
|
|
//
|
|
|
|
// By partitioning the operands in this way, we guarantee that for any
|
|
|
|
// tuple of classes, any single instruction must match either all or none
|
|
|
|
// of the sets of operands which could classify to that tuple.
|
|
|
|
//
|
|
|
|
// In addition, the subset relation amongst classes induces a partial order
|
|
|
|
// on such tuples, which we use to resolve ambiguities.
|
|
|
|
//
|
|
|
|
// 2. The input can now be treated as a tuple of classes (static tokens are
|
|
|
|
// simple singleton sets). Each such tuple should generally map to a single
|
|
|
|
// instruction (we currently ignore cases where this isn't true, whee!!!),
|
|
|
|
// which we can emit a simple matcher for.
|
|
|
|
//
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
// Custom Operand Parsing
|
|
|
|
// ----------------------
|
|
|
|
//
|
|
|
|
// Some targets need a custom way to parse operands, some specific instructions
|
|
|
|
// can contain arguments that can represent processor flags and other kinds of
|
2012-09-18 01:13:36 +00:00
|
|
|
// identifiers that need to be mapped to specific values in the final encoded
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
// instructions. The target specific custom operand parsing works in the
|
|
|
|
// following way:
|
|
|
|
//
|
|
|
|
// 1. A operand match table is built, each entry contains a mnemonic, an
|
|
|
|
// operand class, a mask for all operand positions for that same
|
|
|
|
// class/mnemonic and target features to be checked while trying to match.
|
|
|
|
//
|
|
|
|
// 2. The operand matcher will try every possible entry with the same
|
|
|
|
// mnemonic and will check if the target feature for this mnemonic also
|
|
|
|
// matches. After that, if the operand to be matched has its index
|
2011-04-15 05:18:47 +00:00
|
|
|
// present in the mask, a successful match occurs. Otherwise, fallback
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
// to the regular operand parsing.
|
|
|
|
//
|
|
|
|
// 3. For a match success, each operand class that has a 'ParserMethod'
|
|
|
|
// becomes part of a switch from where the custom method is called.
|
|
|
|
//
|
2009-07-11 19:39:44 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "CodeGenTarget.h"
|
2010-11-04 02:11:18 +00:00
|
|
|
#include "llvm/ADT/PointerUnion.h"
|
2012-12-04 10:37:14 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2010-11-01 01:47:07 +00:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2009-07-31 02:32:59 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2009-08-07 08:26:05 +00:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
|
|
|
#include "llvm/Support/CommandLine.h"
|
2009-07-31 02:32:59 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2012-02-05 07:21:30 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2011-10-01 16:41:13 +00:00
|
|
|
#include "llvm/TableGen/Error.h"
|
|
|
|
#include "llvm/TableGen/Record.h"
|
2012-05-02 17:32:48 +00:00
|
|
|
#include "llvm/TableGen/StringMatcher.h"
|
2013-08-29 05:09:55 +00:00
|
|
|
#include "llvm/TableGen/StringToOffsetTable.h"
|
2012-06-11 15:37:55 +00:00
|
|
|
#include "llvm/TableGen/TableGenBackend.h"
|
|
|
|
#include <cassert>
|
2013-10-12 00:55:57 +00:00
|
|
|
#include <cctype>
|
2009-08-08 05:24:34 +00:00
|
|
|
#include <map>
|
|
|
|
#include <set>
|
2013-07-15 16:53:32 +00:00
|
|
|
#include <sstream>
|
2014-11-28 20:35:57 +00:00
|
|
|
#include <forward_list>
|
2009-07-11 19:39:44 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-21 22:55:11 +00:00
|
|
|
#define DEBUG_TYPE "asm-matcher-emitter"
|
|
|
|
|
2009-08-07 20:33:39 +00:00
|
|
|
static cl::opt<std::string>
|
2009-08-09 04:00:06 +00:00
|
|
|
MatchPrefix("match-prefix", cl::init(""),
|
|
|
|
cl::desc("Only match instructions with the given prefix"));
|
2009-08-07 08:26:05 +00:00
|
|
|
|
|
|
|
namespace {
|
2011-01-26 21:26:19 +00:00
|
|
|
class AsmMatcherInfo;
|
2010-07-19 05:44:09 +00:00
|
|
|
struct SubtargetFeatureInfo;
|
|
|
|
|
2013-09-16 16:43:19 +00:00
|
|
|
// Register sets are used as keys in some second-order sets TableGen creates
|
|
|
|
// when generating its data structures. This means that the order of two
|
|
|
|
// RegisterSets can be seen in the outputted AsmMatcher tables occasionally, and
|
|
|
|
// can even affect compiler output (at least seen in diagnostics produced when
|
|
|
|
// all matches fail). So we use a type that sorts them consistently.
|
|
|
|
typedef std::set<Record*, LessRecordByID> RegisterSet;
|
|
|
|
|
2012-06-11 15:37:55 +00:00
|
|
|
class AsmMatcherEmitter {
|
|
|
|
RecordKeeper &Records;
|
|
|
|
public:
|
|
|
|
AsmMatcherEmitter(RecordKeeper &R) : Records(R) {}
|
|
|
|
|
|
|
|
void run(raw_ostream &o);
|
|
|
|
};
|
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
/// ClassInfo - Helper class for storing the information about a particular
|
|
|
|
/// class of operands which can be matched.
|
|
|
|
struct ClassInfo {
|
2009-08-09 04:00:06 +00:00
|
|
|
enum ClassInfoKind {
|
2009-08-11 02:59:53 +00:00
|
|
|
/// Invalid kind, for use as a sentinel value.
|
|
|
|
Invalid = 0,
|
|
|
|
|
|
|
|
/// The class for a particular token.
|
|
|
|
Token,
|
|
|
|
|
|
|
|
/// The (first) register class, subsequent register classes are
|
|
|
|
/// RegisterClass0+1, and so on.
|
|
|
|
RegisterClass0,
|
|
|
|
|
|
|
|
/// The (first) user defined class, subsequent user defined classes are
|
|
|
|
/// UserClass0+1, and so on.
|
|
|
|
UserClass0 = 1<<16
|
2009-08-09 04:00:06 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/// Kind - The class kind, which is either a predefined kind, or (UserClass0 +
|
|
|
|
/// N) for the Nth user defined class.
|
|
|
|
unsigned Kind;
|
2009-08-08 07:50:56 +00:00
|
|
|
|
2009-08-11 02:59:53 +00:00
|
|
|
/// SuperClasses - The super classes of this class. Note that for simplicities
|
|
|
|
/// sake user operands only record their immediate super class, while register
|
|
|
|
/// operands include all superclasses.
|
|
|
|
std::vector<ClassInfo*> SuperClasses;
|
2009-08-09 07:20:21 +00:00
|
|
|
|
2009-08-09 05:18:30 +00:00
|
|
|
/// Name - The full class name, suitable for use in an enum.
|
2009-08-08 07:50:56 +00:00
|
|
|
std::string Name;
|
|
|
|
|
2009-08-09 05:18:30 +00:00
|
|
|
/// ClassName - The unadorned generic name for this class (e.g., Token).
|
|
|
|
std::string ClassName;
|
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
/// ValueName - The name of the value this class represents; for a token this
|
|
|
|
/// is the literal token string, for an operand it is the TableGen class (or
|
|
|
|
/// empty if this is a derived class).
|
|
|
|
std::string ValueName;
|
|
|
|
|
|
|
|
/// PredicateMethod - The name of the operand method to test whether the
|
2009-08-11 02:59:53 +00:00
|
|
|
/// operand matches this class; this is not valid for Token or register kinds.
|
2009-08-08 07:50:56 +00:00
|
|
|
std::string PredicateMethod;
|
|
|
|
|
|
|
|
/// RenderMethod - The name of the operand method to add this operand to an
|
2009-08-11 02:59:53 +00:00
|
|
|
/// MCInst; this is not valid for Token or register kinds.
|
2009-08-08 07:50:56 +00:00
|
|
|
std::string RenderMethod;
|
2009-08-09 04:00:06 +00:00
|
|
|
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
/// ParserMethod - The name of the operand method to do a target specific
|
|
|
|
/// parsing on the operand.
|
|
|
|
std::string ParserMethod;
|
|
|
|
|
2014-05-20 17:11:11 +00:00
|
|
|
/// For register classes: the records for all the registers in this class.
|
2013-09-16 16:43:19 +00:00
|
|
|
RegisterSet Registers;
|
2009-08-11 20:10:07 +00:00
|
|
|
|
2014-05-20 17:11:11 +00:00
|
|
|
/// For custom match classes: the diagnostic kind for when the predicate fails.
|
2012-06-22 23:56:44 +00:00
|
|
|
std::string DiagnosticType;
|
2009-08-11 20:10:07 +00:00
|
|
|
public:
|
2009-08-11 02:59:53 +00:00
|
|
|
/// isRegisterClass() - Check if this is a register class.
|
|
|
|
bool isRegisterClass() const {
|
|
|
|
return Kind >= RegisterClass0 && Kind < UserClass0;
|
|
|
|
}
|
|
|
|
|
2009-08-09 07:20:21 +00:00
|
|
|
/// isUserClass() - Check if this is a user defined class.
|
|
|
|
bool isUserClass() const {
|
|
|
|
return Kind >= UserClass0;
|
|
|
|
}
|
|
|
|
|
2012-09-15 20:22:05 +00:00
|
|
|
/// isRelatedTo - Check whether this class is "related" to \p RHS. Classes
|
2009-08-11 02:59:53 +00:00
|
|
|
/// are related if they are in the same class hierarchy.
|
|
|
|
bool isRelatedTo(const ClassInfo &RHS) const {
|
|
|
|
// Tokens are only related to tokens.
|
|
|
|
if (Kind == Token || RHS.Kind == Token)
|
|
|
|
return Kind == Token && RHS.Kind == Token;
|
|
|
|
|
2009-08-11 20:10:07 +00:00
|
|
|
// Registers classes are only related to registers classes, and only if
|
|
|
|
// their intersection is non-empty.
|
|
|
|
if (isRegisterClass() || RHS.isRegisterClass()) {
|
|
|
|
if (!isRegisterClass() || !RHS.isRegisterClass())
|
|
|
|
return false;
|
|
|
|
|
2013-09-16 16:43:19 +00:00
|
|
|
RegisterSet Tmp;
|
|
|
|
std::insert_iterator<RegisterSet> II(Tmp, Tmp.begin());
|
2010-10-29 22:13:48 +00:00
|
|
|
std::set_intersection(Registers.begin(), Registers.end(),
|
2009-08-11 20:10:07 +00:00
|
|
|
RHS.Registers.begin(), RHS.Registers.end(),
|
2013-09-16 16:43:19 +00:00
|
|
|
II, LessRecordByID());
|
2009-08-11 20:10:07 +00:00
|
|
|
|
|
|
|
return !Tmp.empty();
|
|
|
|
}
|
2009-08-11 02:59:53 +00:00
|
|
|
|
|
|
|
// Otherwise we have two users operands; they are related if they are in the
|
|
|
|
// same class hierarchy.
|
2009-08-11 20:10:07 +00:00
|
|
|
//
|
|
|
|
// FIXME: This is an oversimplification, they should only be related if they
|
|
|
|
// intersect, however we don't have that information.
|
2009-08-11 02:59:53 +00:00
|
|
|
assert(isUserClass() && RHS.isUserClass() && "Unexpected class!");
|
|
|
|
const ClassInfo *Root = this;
|
|
|
|
while (!Root->SuperClasses.empty())
|
|
|
|
Root = Root->SuperClasses.front();
|
|
|
|
|
2009-08-11 20:10:07 +00:00
|
|
|
const ClassInfo *RHSRoot = &RHS;
|
2009-08-11 02:59:53 +00:00
|
|
|
while (!RHSRoot->SuperClasses.empty())
|
|
|
|
RHSRoot = RHSRoot->SuperClasses.front();
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2009-08-11 02:59:53 +00:00
|
|
|
return Root == RHSRoot;
|
|
|
|
}
|
|
|
|
|
2012-09-15 20:22:05 +00:00
|
|
|
/// isSubsetOf - Test whether this class is a subset of \p RHS.
|
2009-08-11 02:59:53 +00:00
|
|
|
bool isSubsetOf(const ClassInfo &RHS) const {
|
|
|
|
// This is a subset of RHS if it is the same class...
|
|
|
|
if (this == &RHS)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// ... or if any of its super classes are a subset of RHS.
|
2014-11-25 20:11:31 +00:00
|
|
|
for (const ClassInfo *CI : SuperClasses)
|
|
|
|
if (CI->isSubsetOf(RHS))
|
2009-08-11 02:59:53 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
2009-08-09 07:20:21 +00:00
|
|
|
}
|
|
|
|
|
2009-08-09 04:00:06 +00:00
|
|
|
/// operator< - Compare two classes.
|
|
|
|
bool operator<(const ClassInfo &RHS) const {
|
2010-05-27 05:31:32 +00:00
|
|
|
if (this == &RHS)
|
|
|
|
return false;
|
|
|
|
|
2009-08-11 02:59:53 +00:00
|
|
|
// Unrelated classes can be ordered by kind.
|
|
|
|
if (!isRelatedTo(RHS))
|
2009-08-09 04:00:06 +00:00
|
|
|
return Kind < RHS.Kind;
|
|
|
|
|
|
|
|
switch (Kind) {
|
2009-08-09 05:18:30 +00:00
|
|
|
case Invalid:
|
2012-02-05 07:21:30 +00:00
|
|
|
llvm_unreachable("Invalid kind!");
|
2009-08-09 04:00:06 +00:00
|
|
|
|
|
|
|
default:
|
2011-04-15 05:18:47 +00:00
|
|
|
// This class precedes the RHS if it is a proper subset of the RHS.
|
2010-05-27 05:31:32 +00:00
|
|
|
if (isSubsetOf(RHS))
|
2010-07-12 08:16:59 +00:00
|
|
|
return true;
|
2010-05-27 05:31:32 +00:00
|
|
|
if (RHS.isSubsetOf(*this))
|
2010-07-12 08:16:59 +00:00
|
|
|
return false;
|
2010-05-27 05:31:32 +00:00
|
|
|
|
|
|
|
// Otherwise, order by name to ensure we have a total ordering.
|
|
|
|
return ValueName < RHS.ValueName;
|
2009-08-09 04:00:06 +00:00
|
|
|
}
|
|
|
|
}
|
2009-08-08 07:50:56 +00:00
|
|
|
};
|
|
|
|
|
2010-11-01 05:06:45 +00:00
|
|
|
/// MatchableInfo - Helper class for storing the necessary information for an
|
|
|
|
/// instruction or alias which is capable of being matched.
|
|
|
|
struct MatchableInfo {
|
2010-11-03 19:47:34 +00:00
|
|
|
struct AsmOperand {
|
2010-11-02 17:30:52 +00:00
|
|
|
/// Token - This is the token that the operand came from.
|
|
|
|
StringRef Token;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
/// The unique class instance this operand should match.
|
|
|
|
ClassInfo *Class;
|
|
|
|
|
2010-11-04 01:42:59 +00:00
|
|
|
/// The operand name this is, if anything.
|
|
|
|
StringRef SrcOpName;
|
2011-01-26 19:44:55 +00:00
|
|
|
|
|
|
|
/// The suboperand index within SrcOpName, or -1 for the entire operand.
|
|
|
|
int SubOpIdx;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-01-07 01:33:34 +00:00
|
|
|
/// Register record if this token is singleton register.
|
|
|
|
Record *SingletonReg;
|
|
|
|
|
2014-04-15 07:20:03 +00:00
|
|
|
explicit AsmOperand(StringRef T) : Token(T), Class(nullptr), SubOpIdx(-1),
|
|
|
|
SingletonReg(nullptr) {}
|
2009-08-07 08:26:05 +00:00
|
|
|
};
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-04 00:43:46 +00:00
|
|
|
/// ResOperand - This represents a single operand in the result instruction
|
|
|
|
/// generated by the match. In cases (like addressing modes) where a single
|
|
|
|
/// assembler operand expands to multiple MCOperands, this represents the
|
|
|
|
/// single assembler operand, not the MCOperand.
|
|
|
|
struct ResOperand {
|
|
|
|
enum {
|
|
|
|
/// RenderAsmOperand - This represents an operand result that is
|
|
|
|
/// generated by calling the render method on the assembly operand. The
|
|
|
|
/// corresponding AsmOperand is specified by AsmOperandNum.
|
|
|
|
RenderAsmOperand,
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-04 00:43:46 +00:00
|
|
|
/// TiedOperand - This represents a result operand that is a duplicate of
|
|
|
|
/// a previous result operand.
|
2010-11-06 19:25:43 +00:00
|
|
|
TiedOperand,
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-06 19:25:43 +00:00
|
|
|
/// ImmOperand - This represents an immediate value that is dumped into
|
|
|
|
/// the operand.
|
2010-11-06 19:57:21 +00:00
|
|
|
ImmOperand,
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-06 19:57:21 +00:00
|
|
|
/// RegOperand - This represents a fixed register that is dumped in.
|
|
|
|
RegOperand
|
2010-11-04 00:43:46 +00:00
|
|
|
} Kind;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-04 00:43:46 +00:00
|
|
|
union {
|
|
|
|
/// This is the operand # in the AsmOperands list that this should be
|
|
|
|
/// copied from.
|
|
|
|
unsigned AsmOperandNum;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-04 00:43:46 +00:00
|
|
|
/// TiedOperandNum - This is the (earlier) result operand that should be
|
|
|
|
/// copied from.
|
|
|
|
unsigned TiedOperandNum;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-06 19:25:43 +00:00
|
|
|
/// ImmVal - This is the immediate value added to the instruction.
|
|
|
|
int64_t ImmVal;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-06 19:57:21 +00:00
|
|
|
/// Register - This is the register record.
|
|
|
|
Record *Register;
|
2010-11-04 00:43:46 +00:00
|
|
|
};
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
/// MINumOperands - The number of MCInst operands populated by this
|
|
|
|
/// operand.
|
|
|
|
unsigned MINumOperands;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
static ResOperand getRenderedOp(unsigned AsmOpNum, unsigned NumOperands) {
|
2010-11-04 00:43:46 +00:00
|
|
|
ResOperand X;
|
|
|
|
X.Kind = RenderAsmOperand;
|
|
|
|
X.AsmOperandNum = AsmOpNum;
|
2011-01-26 19:44:55 +00:00
|
|
|
X.MINumOperands = NumOperands;
|
2010-11-04 00:43:46 +00:00
|
|
|
return X;
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
static ResOperand getTiedOp(unsigned TiedOperandNum) {
|
2010-11-04 00:43:46 +00:00
|
|
|
ResOperand X;
|
|
|
|
X.Kind = TiedOperand;
|
|
|
|
X.TiedOperandNum = TiedOperandNum;
|
2011-01-26 19:44:55 +00:00
|
|
|
X.MINumOperands = 1;
|
2010-11-04 00:43:46 +00:00
|
|
|
return X;
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
static ResOperand getImmOp(int64_t Val) {
|
2010-11-06 19:25:43 +00:00
|
|
|
ResOperand X;
|
|
|
|
X.Kind = ImmOperand;
|
|
|
|
X.ImmVal = Val;
|
2011-01-26 19:44:55 +00:00
|
|
|
X.MINumOperands = 1;
|
2010-11-06 19:25:43 +00:00
|
|
|
return X;
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
static ResOperand getRegOp(Record *Reg) {
|
2010-11-06 19:57:21 +00:00
|
|
|
ResOperand X;
|
|
|
|
X.Kind = RegOperand;
|
|
|
|
X.Register = Reg;
|
2011-01-26 19:44:55 +00:00
|
|
|
X.MINumOperands = 1;
|
2010-11-06 19:57:21 +00:00
|
|
|
return X;
|
|
|
|
}
|
2010-11-04 00:43:46 +00:00
|
|
|
};
|
2009-08-07 08:26:05 +00:00
|
|
|
|
2012-01-10 17:50:43 +00:00
|
|
|
/// AsmVariantID - Target's assembly syntax variant no.
|
|
|
|
int AsmVariantID;
|
|
|
|
|
2014-12-22 21:26:26 +00:00
|
|
|
/// AsmString - The assembly string for this instruction (with variants
|
|
|
|
/// removed), e.g. "movsx $src, $dst".
|
|
|
|
std::string AsmString;
|
|
|
|
|
2010-11-02 17:34:28 +00:00
|
|
|
/// TheDef - This is the definition of the instruction or InstAlias that this
|
|
|
|
/// matchable came from.
|
2010-11-01 04:34:44 +00:00
|
|
|
Record *const TheDef;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-04 02:11:18 +00:00
|
|
|
/// DefRec - This is the definition that it came from.
|
|
|
|
PointerUnion<const CodeGenInstruction*, const CodeGenInstAlias*> DefRec;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
Reimplement BuildResultOperands to be in terms of the result instruction's
operand list instead of the operand list redundantly declared on the alias
or instruction.
With this change, we finally remove the ins/outs list on the alias. Before:
def : InstAlias<(outs GR16:$dst), (ins GR8 :$src),
"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
After:
def : InstAlias<"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
This also makes the alias mechanism more general and powerful, which will
be exploited in subsequent patches.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@118329 91177308-0d34-0410-b5e6-96231b3b80d8
2010-11-06 07:14:44 +00:00
|
|
|
const CodeGenInstruction *getResultInst() const {
|
|
|
|
if (DefRec.is<const CodeGenInstruction*>())
|
|
|
|
return DefRec.get<const CodeGenInstruction*>();
|
|
|
|
return DefRec.get<const CodeGenInstAlias*>()->ResultInst;
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-04 00:43:46 +00:00
|
|
|
/// ResOperands - This is the operand list that should be built for the result
|
|
|
|
/// MCInst.
|
2012-04-19 17:52:34 +00:00
|
|
|
SmallVector<ResOperand, 8> ResOperands;
|
2009-08-07 08:26:05 +00:00
|
|
|
|
2010-11-02 17:30:52 +00:00
|
|
|
/// Mnemonic - This is the first token of the matched instruction, its
|
|
|
|
/// mnemonic.
|
|
|
|
StringRef Mnemonic;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-02 01:03:43 +00:00
|
|
|
/// AsmOperands - The textual operands that this instruction matches,
|
2010-11-02 17:34:28 +00:00
|
|
|
/// annotated with a class and where in the OperandList they were defined.
|
|
|
|
/// This directly corresponds to the tokenized AsmString after the mnemonic is
|
|
|
|
/// removed.
|
2012-04-19 17:52:34 +00:00
|
|
|
SmallVector<AsmOperand, 8> AsmOperands;
|
2009-08-07 08:26:05 +00:00
|
|
|
|
2010-07-19 05:44:09 +00:00
|
|
|
/// Predicates - The required subtarget features to match this instruction.
|
2014-11-28 22:15:06 +00:00
|
|
|
SmallVector<const SubtargetFeatureInfo *, 4> RequiredFeatures;
|
2010-07-19 05:44:09 +00:00
|
|
|
|
2009-08-08 05:24:34 +00:00
|
|
|
/// ConversionFnKind - The enum value which is passed to the generated
|
2012-09-05 01:02:38 +00:00
|
|
|
/// convertToMCInst to convert parsed operands into an MCInst for this
|
2009-08-08 05:24:34 +00:00
|
|
|
/// function.
|
|
|
|
std::string ConversionFnKind;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2013-09-12 10:28:05 +00:00
|
|
|
/// If this instruction is deprecated in some form.
|
|
|
|
bool HasDeprecation;
|
|
|
|
|
2010-11-01 05:06:45 +00:00
|
|
|
MatchableInfo(const CodeGenInstruction &CGI)
|
2014-12-22 21:26:26 +00:00
|
|
|
: AsmVariantID(0), AsmString(CGI.AsmString), TheDef(CGI.TheDef), DefRec(&CGI) {
|
2014-11-28 23:00:22 +00:00
|
|
|
}
|
2010-11-01 04:34:44 +00:00
|
|
|
|
2014-12-22 21:26:26 +00:00
|
|
|
MatchableInfo(std::unique_ptr<const CodeGenInstAlias> Alias)
|
|
|
|
: AsmVariantID(0), AsmString(Alias->AsmString), TheDef(Alias->TheDef), DefRec(Alias.release()) {
|
2014-11-28 23:00:22 +00:00
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2014-11-28 23:00:22 +00:00
|
|
|
~MatchableInfo() {
|
2014-12-22 21:26:26 +00:00
|
|
|
delete DefRec.dyn_cast<const CodeGenInstAlias*>();
|
2014-11-28 23:00:22 +00:00
|
|
|
}
|
2014-11-28 05:01:21 +00:00
|
|
|
|
2012-04-19 23:59:23 +00:00
|
|
|
// Two-operand aliases clone from the main matchable, but mark the second
|
|
|
|
// operand as a tied operand of the first for purposes of the assembler.
|
|
|
|
void formTwoOperandAlias(StringRef Constraint);
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
void initialize(const AsmMatcherInfo &Info,
|
2014-08-21 05:55:13 +00:00
|
|
|
SmallPtrSetImpl<Record*> &SingletonRegisters,
|
2012-04-11 21:02:33 +00:00
|
|
|
int AsmVariantNo, std::string &RegisterPrefix);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// validate - Return true if this matchable is a valid thing to match against
|
2010-11-01 05:06:45 +00:00
|
|
|
/// and perform a bunch of validity checking.
|
2012-04-19 17:52:32 +00:00
|
|
|
bool validate(StringRef CommentDelimiter, bool Hack) const;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-01-24 21:06:59 +00:00
|
|
|
/// extractSingletonRegisterForAsmOperand - Extract singleton register,
|
2012-01-07 01:33:34 +00:00
|
|
|
/// if present, from specified token.
|
|
|
|
void
|
|
|
|
extractSingletonRegisterForAsmOperand(unsigned i, const AsmMatcherInfo &Info,
|
|
|
|
std::string &RegisterPrefix);
|
2009-08-07 08:26:05 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// findAsmOperand - Find the AsmOperand with the specified name and
|
2011-01-26 19:44:55 +00:00
|
|
|
/// suboperand index.
|
2012-04-19 17:52:32 +00:00
|
|
|
int findAsmOperand(StringRef N, int SubOpIdx) const {
|
2011-01-26 19:44:55 +00:00
|
|
|
for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i)
|
|
|
|
if (N == AsmOperands[i].SrcOpName &&
|
|
|
|
SubOpIdx == AsmOperands[i].SubOpIdx)
|
|
|
|
return i;
|
|
|
|
return -1;
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// findAsmOperandNamed - Find the first AsmOperand with the specified name.
|
2011-01-26 19:44:55 +00:00
|
|
|
/// This does not check the suboperand index.
|
2012-04-19 17:52:32 +00:00
|
|
|
int findAsmOperandNamed(StringRef N) const {
|
2010-11-04 01:55:23 +00:00
|
|
|
for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i)
|
|
|
|
if (N == AsmOperands[i].SrcOpName)
|
|
|
|
return i;
|
|
|
|
return -1;
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
void buildInstructionResultOperands();
|
|
|
|
void buildAliasResultOperands();
|
2010-11-04 00:43:46 +00:00
|
|
|
|
2010-11-01 05:06:45 +00:00
|
|
|
/// operator< - Compare two matchables.
|
|
|
|
bool operator<(const MatchableInfo &RHS) const {
|
2010-09-06 21:01:37 +00:00
|
|
|
// The primary comparator is the instruction mnemonic.
|
2010-11-02 17:30:52 +00:00
|
|
|
if (Mnemonic != RHS.Mnemonic)
|
|
|
|
return Mnemonic < RHS.Mnemonic;
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2010-11-02 01:03:43 +00:00
|
|
|
if (AsmOperands.size() != RHS.AsmOperands.size())
|
|
|
|
return AsmOperands.size() < RHS.AsmOperands.size();
|
2009-08-09 06:05:33 +00:00
|
|
|
|
2009-08-09 08:23:23 +00:00
|
|
|
// Compare lexicographically by operand. The matcher validates that other
|
2012-04-19 17:52:32 +00:00
|
|
|
// orderings wouldn't be ambiguous using \see couldMatchAmbiguouslyWith().
|
2010-11-02 01:03:43 +00:00
|
|
|
for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
|
|
|
|
if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class)
|
2009-08-09 06:05:33 +00:00
|
|
|
return true;
|
2010-11-02 01:03:43 +00:00
|
|
|
if (*RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
|
2009-08-09 08:23:23 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-08-29 03:52:57 +00:00
|
|
|
// Give matches that require more features higher precedence. This is useful
|
|
|
|
// because we cannot define AssemblerPredicates with the negation of
|
|
|
|
// processor features. For example, ARM v6 "nop" may be either a HINT or
|
|
|
|
// MOV. With v6, we want to match HINT. The assembler has no way to
|
|
|
|
// predicate MOV under "NoV6", but HINT will always match first because it
|
|
|
|
// requires V6 while MOV does not.
|
|
|
|
if (RequiredFeatures.size() != RHS.RequiredFeatures.size())
|
|
|
|
return RequiredFeatures.size() > RHS.RequiredFeatures.size();
|
|
|
|
|
2009-08-09 06:05:33 +00:00
|
|
|
return false;
|
|
|
|
}
|
2009-08-09 04:00:06 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// couldMatchAmbiguouslyWith - Check whether this matchable could
|
2012-09-15 20:22:05 +00:00
|
|
|
/// ambiguously match the same set of operands as \p RHS (without being a
|
2009-08-09 06:05:33 +00:00
|
|
|
/// strictly superior match).
|
2014-11-28 03:53:00 +00:00
|
|
|
bool couldMatchAmbiguouslyWith(const MatchableInfo &RHS) const {
|
2010-11-01 23:57:23 +00:00
|
|
|
// The primary comparator is the instruction mnemonic.
|
2010-11-02 17:30:52 +00:00
|
|
|
if (Mnemonic != RHS.Mnemonic)
|
2010-11-01 23:57:23 +00:00
|
|
|
return false;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2009-08-09 06:05:33 +00:00
|
|
|
// The number of operands is unambiguous.
|
2010-11-02 01:03:43 +00:00
|
|
|
if (AsmOperands.size() != RHS.AsmOperands.size())
|
2009-08-09 06:05:33 +00:00
|
|
|
return false;
|
2009-08-09 04:00:06 +00:00
|
|
|
|
2010-01-23 00:26:16 +00:00
|
|
|
// Otherwise, make sure the ordering of the two instructions is unambiguous
|
|
|
|
// by checking that either (a) a token or operand kind discriminates them,
|
|
|
|
// or (b) the ordering among equivalent kinds is consistent.
|
|
|
|
|
2009-08-09 06:05:33 +00:00
|
|
|
// Tokens and operand kinds are unambiguous (assuming a correct target
|
|
|
|
// specific parser).
|
2010-11-02 01:03:43 +00:00
|
|
|
for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i)
|
|
|
|
if (AsmOperands[i].Class->Kind != RHS.AsmOperands[i].Class->Kind ||
|
|
|
|
AsmOperands[i].Class->Kind == ClassInfo::Token)
|
|
|
|
if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class ||
|
|
|
|
*RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
|
2009-08-09 06:05:33 +00:00
|
|
|
return false;
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2009-08-09 06:05:33 +00:00
|
|
|
// Otherwise, this operand could commute if all operands are equivalent, or
|
|
|
|
// there is a pair of operands that compare less than and a pair that
|
|
|
|
// compare greater than.
|
|
|
|
bool HasLT = false, HasGT = false;
|
2010-11-02 01:03:43 +00:00
|
|
|
for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
|
|
|
|
if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class)
|
2009-08-09 06:05:33 +00:00
|
|
|
HasLT = true;
|
2010-11-02 01:03:43 +00:00
|
|
|
if (*RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
|
2009-08-09 06:05:33 +00:00
|
|
|
HasGT = true;
|
|
|
|
}
|
2009-08-09 04:00:06 +00:00
|
|
|
|
2009-08-09 06:05:33 +00:00
|
|
|
return !(HasLT ^ HasGT);
|
2009-08-09 04:00:06 +00:00
|
|
|
}
|
|
|
|
|
2014-11-28 03:53:00 +00:00
|
|
|
void dump() const;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-02 17:30:52 +00:00
|
|
|
private:
|
2012-04-19 17:52:32 +00:00
|
|
|
void tokenizeAsmString(const AsmMatcherInfo &Info);
|
2009-08-07 08:26:05 +00:00
|
|
|
};
|
|
|
|
|
2010-07-19 05:44:09 +00:00
|
|
|
/// SubtargetFeatureInfo - Helper class for storing information on a subtarget
|
|
|
|
/// feature which participates in instruction matching.
|
|
|
|
struct SubtargetFeatureInfo {
|
|
|
|
/// \brief The predicate record for this feature.
|
|
|
|
Record *TheDef;
|
|
|
|
|
|
|
|
/// \brief An unique index assigned to represent this feature.
|
2014-08-18 11:49:42 +00:00
|
|
|
uint64_t Index;
|
2010-07-19 05:44:09 +00:00
|
|
|
|
2014-08-18 11:49:42 +00:00
|
|
|
SubtargetFeatureInfo(Record *D, uint64_t Idx) : TheDef(D), Index(Idx) {}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-07-19 05:44:09 +00:00
|
|
|
/// \brief The name of the enumerated constant identifying this feature.
|
2010-10-30 20:07:57 +00:00
|
|
|
std::string getEnumName() const {
|
|
|
|
return "Feature_" + TheDef->getName();
|
|
|
|
}
|
2014-05-21 10:11:24 +00:00
|
|
|
|
2014-11-28 03:53:00 +00:00
|
|
|
void dump() const {
|
2014-05-21 10:11:24 +00:00
|
|
|
errs() << getEnumName() << " " << Index << "\n";
|
|
|
|
TheDef->dump();
|
|
|
|
}
|
2010-07-19 05:44:09 +00:00
|
|
|
};
|
|
|
|
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
struct OperandMatchEntry {
|
|
|
|
unsigned OperandMask;
|
2014-11-28 03:53:00 +00:00
|
|
|
const MatchableInfo* MI;
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
ClassInfo *CI;
|
|
|
|
|
2014-11-28 03:53:00 +00:00
|
|
|
static OperandMatchEntry create(const MatchableInfo *mi, ClassInfo *ci,
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
unsigned opMask) {
|
|
|
|
OperandMatchEntry X;
|
|
|
|
X.OperandMask = opMask;
|
|
|
|
X.CI = ci;
|
|
|
|
X.MI = mi;
|
|
|
|
return X;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
class AsmMatcherInfo {
|
|
|
|
public:
|
2010-12-13 00:23:57 +00:00
|
|
|
/// Tracked Records
|
2010-12-15 04:48:22 +00:00
|
|
|
RecordKeeper &Records;
|
2010-12-13 00:23:57 +00:00
|
|
|
|
2009-08-11 20:59:47 +00:00
|
|
|
/// The tablegen AsmParser record.
|
|
|
|
Record *AsmParser;
|
|
|
|
|
2010-11-01 01:37:30 +00:00
|
|
|
/// Target - The target information.
|
|
|
|
CodeGenTarget &Target;
|
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
/// The classes which are needed for matching.
|
2014-11-28 20:35:57 +00:00
|
|
|
std::forward_list<ClassInfo> Classes;
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2010-11-01 05:06:45 +00:00
|
|
|
/// The information on the matchables to match.
|
2014-11-28 23:00:22 +00:00
|
|
|
std::vector<std::unique_ptr<MatchableInfo>> Matchables;
|
2009-08-08 07:50:56 +00:00
|
|
|
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
/// Info for custom matching operands by user defined methods.
|
|
|
|
std::vector<OperandMatchEntry> OperandMatchInfo;
|
|
|
|
|
2009-08-11 02:59:53 +00:00
|
|
|
/// Map of Register records to their class information.
|
2012-09-19 01:47:01 +00:00
|
|
|
typedef std::map<Record*, ClassInfo*, LessRecordByID> RegisterClassesTy;
|
|
|
|
RegisterClassesTy RegisterClasses;
|
2009-08-11 02:59:53 +00:00
|
|
|
|
2010-07-19 05:44:09 +00:00
|
|
|
/// Map of Predicate records to their subtarget information.
|
2014-11-28 22:15:06 +00:00
|
|
|
std::map<Record *, SubtargetFeatureInfo, LessRecordByID> SubtargetFeatures;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-06-22 23:56:44 +00:00
|
|
|
/// Map of AsmOperandClass records to their class information.
|
|
|
|
std::map<Record*, ClassInfo*> AsmOperandClasses;
|
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
private:
|
|
|
|
/// Map of token to class information which has already been constructed.
|
|
|
|
std::map<std::string, ClassInfo*> TokenClasses;
|
|
|
|
|
2009-08-11 02:59:53 +00:00
|
|
|
/// Map of RegisterClass records to their class information.
|
|
|
|
std::map<Record*, ClassInfo*> RegisterClassClasses;
|
2009-08-08 07:50:56 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
/// getTokenClass - Lookup or create the class for the given token.
|
2010-02-09 00:34:28 +00:00
|
|
|
ClassInfo *getTokenClass(StringRef Token);
|
2009-08-08 07:50:56 +00:00
|
|
|
|
|
|
|
/// getOperandClass - Lookup or create the class for the given operand.
|
2011-01-26 19:44:55 +00:00
|
|
|
ClassInfo *getOperandClass(const CGIOperandList::OperandInfo &OI,
|
2011-10-28 22:32:53 +00:00
|
|
|
int SubOpIdx);
|
|
|
|
ClassInfo *getOperandClass(Record *Rec, int SubOpIdx);
|
2009-08-08 07:50:56 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// buildRegisterClasses - Build the ClassInfo* instances for register
|
2009-08-11 02:59:53 +00:00
|
|
|
/// classes.
|
2014-08-21 05:55:13 +00:00
|
|
|
void buildRegisterClasses(SmallPtrSetImpl<Record*> &SingletonRegisters);
|
2009-08-11 02:59:53 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// buildOperandClasses - Build the ClassInfo* instances for user defined
|
2009-08-11 02:59:53 +00:00
|
|
|
/// operand classes.
|
2012-04-19 17:52:32 +00:00
|
|
|
void buildOperandClasses();
|
2009-08-11 02:59:53 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
void buildInstructionOperandReference(MatchableInfo *II, StringRef OpName,
|
2011-01-26 19:44:55 +00:00
|
|
|
unsigned AsmOpIdx);
|
2012-04-19 17:52:32 +00:00
|
|
|
void buildAliasOperandReference(MatchableInfo *II, StringRef OpName,
|
2010-11-04 02:11:18 +00:00
|
|
|
MatchableInfo::AsmOperand &Op);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
public:
|
2011-01-26 21:26:19 +00:00
|
|
|
AsmMatcherInfo(Record *AsmParser,
|
|
|
|
CodeGenTarget &Target,
|
2010-12-15 04:48:22 +00:00
|
|
|
RecordKeeper &Records);
|
2009-08-11 20:59:47 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// buildInfo - Construct the various tables used during matching.
|
|
|
|
void buildInfo();
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// buildOperandMatchInfo - Build the necessary information to handle user
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
/// defined operand parsing methods.
|
2012-04-19 17:52:32 +00:00
|
|
|
void buildOperandMatchInfo();
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
2010-10-30 20:15:02 +00:00
|
|
|
/// getSubtargetFeature - Lookup or create the subtarget feature info for the
|
|
|
|
/// given operand.
|
2014-11-28 22:15:06 +00:00
|
|
|
const SubtargetFeatureInfo *getSubtargetFeature(Record *Def) const {
|
2010-10-30 20:15:02 +00:00
|
|
|
assert(Def->isSubClassOf("Predicate") && "Invalid predicate type!");
|
2014-11-28 03:53:00 +00:00
|
|
|
const auto &I = SubtargetFeatures.find(Def);
|
2014-11-28 22:15:06 +00:00
|
|
|
return I == SubtargetFeatures.end() ? nullptr : &I->second;
|
2010-10-30 20:15:02 +00:00
|
|
|
}
|
2010-12-13 00:23:57 +00:00
|
|
|
|
2010-12-15 04:48:22 +00:00
|
|
|
RecordKeeper &getRecords() const {
|
|
|
|
return Records;
|
2010-12-13 00:23:57 +00:00
|
|
|
}
|
2009-08-08 07:50:56 +00:00
|
|
|
};
|
|
|
|
|
2012-06-11 15:37:55 +00:00
|
|
|
} // End anonymous namespace
|
2009-08-07 08:26:05 +00:00
|
|
|
|
2014-11-28 03:53:00 +00:00
|
|
|
void MatchableInfo::dump() const {
|
2010-11-06 06:43:11 +00:00
|
|
|
errs() << TheDef->getName() << " -- " << "flattened:\"" << AsmString <<"\"\n";
|
2009-07-31 02:32:59 +00:00
|
|
|
|
2010-11-02 01:03:43 +00:00
|
|
|
for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
|
2014-11-28 03:53:00 +00:00
|
|
|
const AsmOperand &Op = AsmOperands[i];
|
2009-08-09 05:18:30 +00:00
|
|
|
errs() << " op[" << i << "] = " << Op.Class->ClassName << " - ";
|
2010-11-04 00:57:06 +00:00
|
|
|
errs() << '\"' << Op.Token << "\"\n";
|
2009-08-07 08:26:05 +00:00
|
|
|
}
|
|
|
|
}
|
2009-07-31 02:32:59 +00:00
|
|
|
|
2012-04-19 23:59:23 +00:00
|
|
|
static std::pair<StringRef, StringRef>
|
Print out the location of expanded multiclass defs in TableGen errors.
When reporting an error for a defm, we would previously only report the
location of the outer defm, which is not always where the error is.
Now we also print the location of the expanded multiclass defs:
lib/Target/X86/X86InstrSSE.td:2902:12: error: foo
defm ADD : basic_sse12_fp_binop_s<0x58, "add", fadd, SSE_ALU_ITINS_S>,
^
lib/Target/X86/X86InstrSSE.td:2801:11: note: instantiated from multiclass
defm PD : sse12_fp_packed<opc, !strconcat(OpcodeStr, "pd"), OpNode, VR128,
^
lib/Target/X86/X86InstrSSE.td:194:5: note: instantiated from multiclass
def rm : PI<opc, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
^
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162409 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-22 23:33:58 +00:00
|
|
|
parseTwoOperandConstraint(StringRef S, ArrayRef<SMLoc> Loc) {
|
2012-04-19 23:59:23 +00:00
|
|
|
// Split via the '='.
|
|
|
|
std::pair<StringRef, StringRef> Ops = S.split('=');
|
|
|
|
if (Ops.second == "")
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(Loc, "missing '=' in two-operand alias constraint");
|
2012-04-19 23:59:23 +00:00
|
|
|
// Trim whitespace and the leading '$' on the operand names.
|
|
|
|
size_t start = Ops.first.find_first_of('$');
|
|
|
|
if (start == std::string::npos)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(Loc, "expected '$' prefix on asm operand name");
|
2012-04-19 23:59:23 +00:00
|
|
|
Ops.first = Ops.first.slice(start + 1, std::string::npos);
|
|
|
|
size_t end = Ops.first.find_last_of(" \t");
|
|
|
|
Ops.first = Ops.first.slice(0, end);
|
|
|
|
// Now the second operand.
|
|
|
|
start = Ops.second.find_first_of('$');
|
|
|
|
if (start == std::string::npos)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(Loc, "expected '$' prefix on asm operand name");
|
2012-04-19 23:59:23 +00:00
|
|
|
Ops.second = Ops.second.slice(start + 1, std::string::npos);
|
|
|
|
end = Ops.second.find_last_of(" \t");
|
|
|
|
Ops.first = Ops.first.slice(0, end);
|
|
|
|
return Ops;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MatchableInfo::formTwoOperandAlias(StringRef Constraint) {
|
|
|
|
// Figure out which operands are aliased and mark them as tied.
|
|
|
|
std::pair<StringRef, StringRef> Ops =
|
|
|
|
parseTwoOperandConstraint(Constraint, TheDef->getLoc());
|
|
|
|
|
|
|
|
// Find the AsmOperands that refer to the operands we're aliasing.
|
|
|
|
int SrcAsmOperand = findAsmOperandNamed(Ops.first);
|
|
|
|
int DstAsmOperand = findAsmOperandNamed(Ops.second);
|
|
|
|
if (SrcAsmOperand == -1)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(),
|
2014-03-29 17:17:15 +00:00
|
|
|
"unknown source two-operand alias operand '" + Ops.first +
|
|
|
|
"'.");
|
2012-04-19 23:59:23 +00:00
|
|
|
if (DstAsmOperand == -1)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(),
|
2014-03-29 17:17:15 +00:00
|
|
|
"unknown destination two-operand alias operand '" +
|
|
|
|
Ops.second + "'.");
|
2012-04-19 23:59:23 +00:00
|
|
|
|
|
|
|
// Find the ResOperand that refers to the operand we're aliasing away
|
|
|
|
// and update it to refer to the combined operand instead.
|
|
|
|
for (unsigned i = 0, e = ResOperands.size(); i != e; ++i) {
|
|
|
|
ResOperand &Op = ResOperands[i];
|
|
|
|
if (Op.Kind == ResOperand::RenderAsmOperand &&
|
|
|
|
Op.AsmOperandNum == (unsigned)SrcAsmOperand) {
|
|
|
|
Op.AsmOperandNum = DstAsmOperand;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Remove the AsmOperand for the alias operand.
|
|
|
|
AsmOperands.erase(AsmOperands.begin() + SrcAsmOperand);
|
|
|
|
// Adjust the ResOperand references to any AsmOperands that followed
|
|
|
|
// the one we just deleted.
|
|
|
|
for (unsigned i = 0, e = ResOperands.size(); i != e; ++i) {
|
|
|
|
ResOperand &Op = ResOperands[i];
|
|
|
|
switch(Op.Kind) {
|
|
|
|
default:
|
|
|
|
// Nothing to do for operands that don't reference AsmOperands.
|
|
|
|
break;
|
|
|
|
case ResOperand::RenderAsmOperand:
|
|
|
|
if (Op.AsmOperandNum > (unsigned)SrcAsmOperand)
|
|
|
|
--Op.AsmOperandNum;
|
|
|
|
break;
|
|
|
|
case ResOperand::TiedOperand:
|
|
|
|
if (Op.TiedOperandNum > (unsigned)SrcAsmOperand)
|
|
|
|
--Op.TiedOperandNum;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
void MatchableInfo::initialize(const AsmMatcherInfo &Info,
|
2014-08-21 05:55:13 +00:00
|
|
|
SmallPtrSetImpl<Record*> &SingletonRegisters,
|
2012-01-07 01:33:34 +00:00
|
|
|
int AsmVariantNo, std::string &RegisterPrefix) {
|
2012-01-10 17:50:43 +00:00
|
|
|
AsmVariantID = AsmVariantNo;
|
2012-01-24 21:06:59 +00:00
|
|
|
AsmString =
|
2012-01-07 01:33:34 +00:00
|
|
|
CodeGenInstruction::FlattenAsmStringVariants(AsmString, AsmVariantNo);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
tokenizeAsmString(Info);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 04:53:48 +00:00
|
|
|
// Compute the require features.
|
|
|
|
std::vector<Record*> Predicates =TheDef->getValueAsListOfDefs("Predicates");
|
|
|
|
for (unsigned i = 0, e = Predicates.size(); i != e; ++i)
|
2014-11-28 22:15:06 +00:00
|
|
|
if (const SubtargetFeatureInfo *Feature =
|
|
|
|
Info.getSubtargetFeature(Predicates[i]))
|
2010-11-01 04:53:48 +00:00
|
|
|
RequiredFeatures.push_back(Feature);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 04:53:48 +00:00
|
|
|
// Collect singleton registers, if used.
|
2010-11-02 17:30:52 +00:00
|
|
|
for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
|
2012-01-07 01:33:34 +00:00
|
|
|
extractSingletonRegisterForAsmOperand(i, Info, RegisterPrefix);
|
|
|
|
if (Record *Reg = AsmOperands[i].SingletonReg)
|
2010-11-01 04:53:48 +00:00
|
|
|
SingletonRegisters.insert(Reg);
|
|
|
|
}
|
2013-09-12 10:28:05 +00:00
|
|
|
|
|
|
|
const RecordVal *DepMask = TheDef->getValue("DeprecatedFeatureMask");
|
|
|
|
if (!DepMask)
|
|
|
|
DepMask = TheDef->getValue("ComplexDeprecationPredicate");
|
|
|
|
|
|
|
|
HasDeprecation =
|
|
|
|
DepMask ? !DepMask->getValue()->getAsUnquotedString().empty() : false;
|
2010-11-01 04:53:48 +00:00
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// tokenizeAsmString - Tokenize a simplified assembly string.
|
|
|
|
void MatchableInfo::tokenizeAsmString(const AsmMatcherInfo &Info) {
|
2010-11-02 17:30:52 +00:00
|
|
|
StringRef String = AsmString;
|
|
|
|
unsigned Prev = 0;
|
|
|
|
bool InTok = true;
|
|
|
|
for (unsigned i = 0, e = String.size(); i != e; ++i) {
|
|
|
|
switch (String[i]) {
|
|
|
|
case '[':
|
|
|
|
case ']':
|
|
|
|
case '*':
|
|
|
|
case '!':
|
|
|
|
case ' ':
|
|
|
|
case '\t':
|
|
|
|
case ',':
|
|
|
|
if (InTok) {
|
2010-11-03 19:47:34 +00:00
|
|
|
AsmOperands.push_back(AsmOperand(String.slice(Prev, i)));
|
2010-11-02 17:30:52 +00:00
|
|
|
InTok = false;
|
|
|
|
}
|
|
|
|
if (!isspace(String[i]) && String[i] != ',')
|
2010-11-03 19:47:34 +00:00
|
|
|
AsmOperands.push_back(AsmOperand(String.substr(i, 1)));
|
2010-11-02 17:30:52 +00:00
|
|
|
Prev = i + 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '\\':
|
|
|
|
if (InTok) {
|
2010-11-03 19:47:34 +00:00
|
|
|
AsmOperands.push_back(AsmOperand(String.slice(Prev, i)));
|
2010-11-02 17:30:52 +00:00
|
|
|
InTok = false;
|
|
|
|
}
|
|
|
|
++i;
|
|
|
|
assert(i != String.size() && "Invalid quoted character");
|
2010-11-03 19:47:34 +00:00
|
|
|
AsmOperands.push_back(AsmOperand(String.substr(i, 1)));
|
2010-11-02 17:30:52 +00:00
|
|
|
Prev = i + 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '$': {
|
2010-11-06 22:06:03 +00:00
|
|
|
if (InTok) {
|
|
|
|
AsmOperands.push_back(AsmOperand(String.slice(Prev, i)));
|
|
|
|
InTok = false;
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-02 17:30:52 +00:00
|
|
|
// If this isn't "${", treat like a normal token.
|
|
|
|
if (i + 1 == String.size() || String[i + 1] != '{') {
|
|
|
|
Prev = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
StringRef::iterator End = std::find(String.begin() + i, String.end(),'}');
|
|
|
|
assert(End != String.end() && "Missing brace in operand reference!");
|
|
|
|
size_t EndPos = End - String.begin();
|
2010-11-03 19:47:34 +00:00
|
|
|
AsmOperands.push_back(AsmOperand(String.slice(i, EndPos+1)));
|
2010-11-02 17:30:52 +00:00
|
|
|
Prev = EndPos + 1;
|
|
|
|
i = EndPos;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case '.':
|
2013-08-01 09:25:27 +00:00
|
|
|
if (!Info.AsmParser->getValueAsBit("MnemonicContainsDot")) {
|
2013-07-16 09:22:38 +00:00
|
|
|
if (InTok)
|
|
|
|
AsmOperands.push_back(AsmOperand(String.slice(Prev, i)));
|
|
|
|
Prev = i;
|
|
|
|
}
|
2010-11-02 17:30:52 +00:00
|
|
|
InTok = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
InTok = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (InTok && Prev != String.size())
|
2010-11-03 19:47:34 +00:00
|
|
|
AsmOperands.push_back(AsmOperand(String.substr(Prev)));
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-02 17:30:52 +00:00
|
|
|
// The first token of the instruction is the mnemonic, which must be a
|
|
|
|
// simple string, not a $foo variable or a singleton register.
|
2011-11-30 23:16:25 +00:00
|
|
|
if (AsmOperands.empty())
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(),
|
2011-11-30 23:16:25 +00:00
|
|
|
"Instruction '" + TheDef->getName() + "' has no tokens");
|
2010-11-02 17:30:52 +00:00
|
|
|
Mnemonic = AsmOperands[0].Token;
|
2012-05-06 17:33:14 +00:00
|
|
|
if (Mnemonic.empty())
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(),
|
2012-05-06 17:33:14 +00:00
|
|
|
"Missing instruction mnemonic");
|
2012-01-07 01:33:34 +00:00
|
|
|
// FIXME : Check and raise an error if it is a register.
|
2012-01-07 01:22:23 +00:00
|
|
|
if (Mnemonic[0] == '$')
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(),
|
2014-03-29 17:17:15 +00:00
|
|
|
"Invalid instruction mnemonic '" + Mnemonic + "'!");
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-02 17:30:52 +00:00
|
|
|
// Remove the first operand, it is tracked in the mnemonic field.
|
|
|
|
AsmOperands.erase(AsmOperands.begin());
|
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
bool MatchableInfo::validate(StringRef CommentDelimiter, bool Hack) const {
|
2010-11-01 05:06:45 +00:00
|
|
|
// Reject matchables with no .s string.
|
2010-11-01 04:34:44 +00:00
|
|
|
if (AsmString.empty())
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(), "instruction with empty asm string");
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 05:06:45 +00:00
|
|
|
// Reject any matchables with a newline in them, they should be marked
|
2010-11-01 04:34:44 +00:00
|
|
|
// isCodeGenOnly if they are pseudo instructions.
|
|
|
|
if (AsmString.find('\n') != std::string::npos)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(),
|
2010-11-01 04:34:44 +00:00
|
|
|
"multiline instruction is not valid for the asmparser, "
|
|
|
|
"mark it isCodeGenOnly");
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 04:44:29 +00:00
|
|
|
// Remove comments from the asm string. We know that the asmstring only
|
|
|
|
// has one line.
|
|
|
|
if (!CommentDelimiter.empty() &&
|
|
|
|
StringRef(AsmString).find(CommentDelimiter) != StringRef::npos)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(),
|
2010-11-01 04:44:29 +00:00
|
|
|
"asmstring for instruction has comment character in it, "
|
|
|
|
"mark it isCodeGenOnly");
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 05:06:45 +00:00
|
|
|
// Reject matchables with operand modifiers, these aren't something we can
|
2011-01-20 18:38:07 +00:00
|
|
|
// handle, the target should be refactored to use operands instead of
|
|
|
|
// modifiers.
|
2010-11-01 04:34:44 +00:00
|
|
|
//
|
|
|
|
// Also, check for instructions which reference the operand multiple times;
|
|
|
|
// this implies a constraint we would not honor.
|
|
|
|
std::set<std::string> OperandNames;
|
2010-11-02 17:30:52 +00:00
|
|
|
for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
|
|
|
|
StringRef Tok = AsmOperands[i].Token;
|
|
|
|
if (Tok[0] == '$' && Tok.find(':') != StringRef::npos)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(),
|
2014-03-29 17:17:15 +00:00
|
|
|
"matchable with operand modifier '" + Tok +
|
|
|
|
"' not supported by asm matcher. Mark isCodeGenOnly!");
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 05:06:45 +00:00
|
|
|
// Verify that any operand is only mentioned once.
|
2010-11-02 23:18:43 +00:00
|
|
|
// We reject aliases and ignore instructions for now.
|
2010-11-02 17:30:52 +00:00
|
|
|
if (Tok[0] == '$' && !OperandNames.insert(Tok).second) {
|
2010-11-01 05:06:45 +00:00
|
|
|
if (!Hack)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(),
|
2014-03-29 17:17:15 +00:00
|
|
|
"ERROR: matchable with tied operand '" + Tok +
|
|
|
|
"' can never be matched!");
|
2010-11-01 05:06:45 +00:00
|
|
|
// FIXME: Should reject these. The ARM backend hits this with $lane in a
|
|
|
|
// bunch of instructions. It is unclear what the right answer is.
|
2010-11-01 04:34:44 +00:00
|
|
|
DEBUG({
|
2010-11-06 06:43:11 +00:00
|
|
|
errs() << "warning: '" << TheDef->getName() << "': "
|
2010-11-01 05:06:45 +00:00
|
|
|
<< "ignoring instruction with tied operand '"
|
2014-03-29 17:17:15 +00:00
|
|
|
<< Tok << "'\n";
|
2010-11-01 04:34:44 +00:00
|
|
|
});
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 04:34:44 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-01-24 21:06:59 +00:00
|
|
|
/// extractSingletonRegisterForAsmOperand - Extract singleton register,
|
2012-01-09 21:30:46 +00:00
|
|
|
/// if present, from specified token.
|
2012-01-07 01:33:34 +00:00
|
|
|
void MatchableInfo::
|
2012-01-24 21:06:59 +00:00
|
|
|
extractSingletonRegisterForAsmOperand(unsigned OperandNo,
|
2012-01-09 21:30:46 +00:00
|
|
|
const AsmMatcherInfo &Info,
|
2012-04-11 21:02:33 +00:00
|
|
|
std::string &RegisterPrefix) {
|
2012-01-09 21:30:46 +00:00
|
|
|
StringRef Tok = AsmOperands[OperandNo].Token;
|
2012-01-07 01:33:34 +00:00
|
|
|
if (RegisterPrefix.empty()) {
|
2012-01-09 21:30:46 +00:00
|
|
|
std::string LoweredTok = Tok.lower();
|
|
|
|
if (const CodeGenRegister *Reg = Info.Target.getRegisterByName(LoweredTok))
|
|
|
|
AsmOperands[OperandNo].SingletonReg = Reg->TheDef;
|
2012-01-07 01:33:34 +00:00
|
|
|
return;
|
2012-01-24 21:06:59 +00:00
|
|
|
}
|
2012-01-07 01:33:34 +00:00
|
|
|
|
|
|
|
if (!Tok.startswith(RegisterPrefix))
|
|
|
|
return;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-01-07 01:33:34 +00:00
|
|
|
StringRef RegName = Tok.substr(RegisterPrefix.size());
|
2010-11-02 18:10:06 +00:00
|
|
|
if (const CodeGenRegister *Reg = Info.Target.getRegisterByName(RegName))
|
2012-01-09 21:30:46 +00:00
|
|
|
AsmOperands[OperandNo].SingletonReg = Reg->TheDef;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 01:47:07 +00:00
|
|
|
// If there is no register prefix (i.e. "%" in "%eax"), then this may
|
|
|
|
// be some random non-register token, just ignore it.
|
2012-01-07 01:33:34 +00:00
|
|
|
return;
|
2010-11-01 01:37:30 +00:00
|
|
|
}
|
|
|
|
|
2010-02-09 00:34:28 +00:00
|
|
|
static std::string getEnumNameForToken(StringRef Str) {
|
2009-08-08 07:50:56 +00:00
|
|
|
std::string Res;
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
for (StringRef::iterator it = Str.begin(), ie = Str.end(); it != ie; ++it) {
|
|
|
|
switch (*it) {
|
|
|
|
case '*': Res += "_STAR_"; break;
|
|
|
|
case '%': Res += "_PCT_"; break;
|
|
|
|
case ':': Res += "_COLON_"; break;
|
2010-11-18 23:36:54 +00:00
|
|
|
case '!': Res += "_EXCLAIM_"; break;
|
2011-01-22 09:44:32 +00:00
|
|
|
case '.': Res += "_DOT_"; break;
|
2013-01-10 16:47:31 +00:00
|
|
|
case '<': Res += "_LT_"; break;
|
|
|
|
case '>': Res += "_GT_"; break;
|
2015-01-15 01:33:00 +00:00
|
|
|
case '-': Res += "_MINUS_"; break;
|
2009-08-08 07:50:56 +00:00
|
|
|
default:
|
2013-01-10 16:47:31 +00:00
|
|
|
if ((*it >= 'A' && *it <= 'Z') ||
|
|
|
|
(*it >= 'a' && *it <= 'z') ||
|
|
|
|
(*it >= '0' && *it <= '9'))
|
2009-08-08 07:50:56 +00:00
|
|
|
Res += *it;
|
2010-10-31 19:10:56 +00:00
|
|
|
else
|
2009-08-08 07:50:56 +00:00
|
|
|
Res += "_" + utostr((unsigned) *it) + "_";
|
|
|
|
}
|
|
|
|
}
|
2009-08-07 08:26:05 +00:00
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
return Res;
|
|
|
|
}
|
|
|
|
|
2010-02-09 00:34:28 +00:00
|
|
|
ClassInfo *AsmMatcherInfo::getTokenClass(StringRef Token) {
|
2009-08-08 07:50:56 +00:00
|
|
|
ClassInfo *&Entry = TokenClasses[Token];
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
if (!Entry) {
|
2014-11-28 20:35:57 +00:00
|
|
|
Classes.emplace_front();
|
|
|
|
Entry = &Classes.front();
|
2009-08-08 07:50:56 +00:00
|
|
|
Entry->Kind = ClassInfo::Token;
|
2009-08-09 05:18:30 +00:00
|
|
|
Entry->ClassName = "Token";
|
2009-08-08 07:50:56 +00:00
|
|
|
Entry->Name = "MCK_" + getEnumNameForToken(Token);
|
|
|
|
Entry->ValueName = Token;
|
|
|
|
Entry->PredicateMethod = "<invalid>";
|
|
|
|
Entry->RenderMethod = "<invalid>";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
Entry->ParserMethod = "";
|
2012-06-22 23:56:44 +00:00
|
|
|
Entry->DiagnosticType = "";
|
2009-08-08 07:50:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return Entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
ClassInfo *
|
2011-01-26 19:44:55 +00:00
|
|
|
AsmMatcherInfo::getOperandClass(const CGIOperandList::OperandInfo &OI,
|
|
|
|
int SubOpIdx) {
|
|
|
|
Record *Rec = OI.Rec;
|
|
|
|
if (SubOpIdx != -1)
|
2012-10-10 20:24:47 +00:00
|
|
|
Rec = cast<DefInit>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef();
|
2011-10-28 22:32:53 +00:00
|
|
|
return getOperandClass(Rec, SubOpIdx);
|
|
|
|
}
|
2011-01-26 19:44:55 +00:00
|
|
|
|
2011-10-28 22:32:53 +00:00
|
|
|
ClassInfo *
|
|
|
|
AsmMatcherInfo::getOperandClass(Record *Rec, int SubOpIdx) {
|
2011-06-27 21:06:21 +00:00
|
|
|
if (Rec->isSubClassOf("RegisterOperand")) {
|
|
|
|
// RegisterOperand may have an associated ParserMatchClass. If it does,
|
|
|
|
// use it, else just fall back to the underlying register class.
|
|
|
|
const RecordVal *R = Rec->getValue("ParserMatchClass");
|
2014-04-15 07:20:03 +00:00
|
|
|
if (!R || !R->getValue())
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError("Record `" + Rec->getName() +
|
|
|
|
"' does not have a ParserMatchClass!\n");
|
2011-06-27 21:06:21 +00:00
|
|
|
|
2012-10-10 20:24:43 +00:00
|
|
|
if (DefInit *DI= dyn_cast<DefInit>(R->getValue())) {
|
2011-06-27 21:06:21 +00:00
|
|
|
Record *MatchClass = DI->getDef();
|
|
|
|
if (ClassInfo *CI = AsmOperandClasses[MatchClass])
|
|
|
|
return CI;
|
|
|
|
}
|
|
|
|
|
|
|
|
// No custom match class. Just use the register class.
|
|
|
|
Record *ClassRec = Rec->getValueAsDef("RegClass");
|
|
|
|
if (!ClassRec)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(Rec->getLoc(), "RegisterOperand `" + Rec->getName() +
|
2011-06-27 21:06:21 +00:00
|
|
|
"' has no associated register class!\n");
|
|
|
|
if (ClassInfo *CI = RegisterClassClasses[ClassRec])
|
|
|
|
return CI;
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(Rec->getLoc(), "register class has no class info!");
|
2011-06-27 21:06:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
if (Rec->isSubClassOf("RegisterClass")) {
|
|
|
|
if (ClassInfo *CI = RegisterClassClasses[Rec])
|
2010-11-02 18:10:06 +00:00
|
|
|
return CI;
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(Rec->getLoc(), "register class has no class info!");
|
2009-08-11 02:59:53 +00:00
|
|
|
}
|
2009-08-10 18:41:10 +00:00
|
|
|
|
2012-09-12 17:40:25 +00:00
|
|
|
if (!Rec->isSubClassOf("Operand"))
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(Rec->getLoc(), "Operand `" + Rec->getName() +
|
2012-09-12 17:40:25 +00:00
|
|
|
"' does not derive from class Operand!\n");
|
2011-01-26 19:44:55 +00:00
|
|
|
Record *MatchClass = Rec->getValueAsDef("ParserMatchClass");
|
2010-11-02 18:10:06 +00:00
|
|
|
if (ClassInfo *CI = AsmOperandClasses[MatchClass])
|
|
|
|
return CI;
|
2009-08-08 07:50:56 +00:00
|
|
|
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(Rec->getLoc(), "operand has no match class!");
|
2009-08-10 18:41:10 +00:00
|
|
|
}
|
|
|
|
|
2013-09-16 16:43:19 +00:00
|
|
|
struct LessRegisterSet {
|
2013-09-16 17:33:40 +00:00
|
|
|
bool operator() (const RegisterSet &LHS, const RegisterSet & RHS) const {
|
2013-09-16 16:43:19 +00:00
|
|
|
// std::set<T> defines its own compariso "operator<", but it
|
|
|
|
// performs a lexicographical comparison by T's innate comparison
|
|
|
|
// for some reason. We don't want non-deterministic pointer
|
|
|
|
// comparisons so use this instead.
|
|
|
|
return std::lexicographical_compare(LHS.begin(), LHS.end(),
|
|
|
|
RHS.begin(), RHS.end(),
|
|
|
|
LessRecordByID());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-11-01 01:47:07 +00:00
|
|
|
void AsmMatcherInfo::
|
2014-08-21 05:55:13 +00:00
|
|
|
buildRegisterClasses(SmallPtrSetImpl<Record*> &SingletonRegisters) {
|
2014-11-29 18:13:39 +00:00
|
|
|
const auto &Registers = Target.getRegBank().getRegisters();
|
2014-12-03 19:58:41 +00:00
|
|
|
auto &RegClassList = Target.getRegBank().getRegClasses();
|
2009-08-10 18:41:10 +00:00
|
|
|
|
2013-09-16 16:43:19 +00:00
|
|
|
typedef std::set<RegisterSet, LessRegisterSet> RegisterSetSet;
|
|
|
|
|
2009-08-11 02:59:53 +00:00
|
|
|
// The register sets used for matching.
|
2013-09-16 16:43:19 +00:00
|
|
|
RegisterSetSet RegisterSets;
|
2009-08-11 02:59:53 +00:00
|
|
|
|
2010-10-29 22:13:48 +00:00
|
|
|
// Gather the defined sets.
|
2014-12-03 19:58:45 +00:00
|
|
|
for (const CodeGenRegisterClass &RC : RegClassList)
|
|
|
|
RegisterSets.insert(
|
|
|
|
RegisterSet(RC.getOrder().begin(), RC.getOrder().end()));
|
2009-08-11 23:23:44 +00:00
|
|
|
|
|
|
|
// Add any required singleton sets.
|
2014-11-25 20:11:31 +00:00
|
|
|
for (Record *Rec : SingletonRegisters) {
|
2013-09-16 16:43:19 +00:00
|
|
|
RegisterSets.insert(RegisterSet(&Rec, &Rec + 1));
|
2010-11-01 01:47:07 +00:00
|
|
|
}
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2009-08-11 02:59:53 +00:00
|
|
|
// Introduce derived sets where necessary (when a register does not determine
|
|
|
|
// a unique register set class), and build the mapping of registers to the set
|
|
|
|
// they should classify to.
|
2013-09-16 16:43:19 +00:00
|
|
|
std::map<Record*, RegisterSet> RegisterMap;
|
2014-11-29 18:13:39 +00:00
|
|
|
for (const CodeGenRegister &CGR : Registers) {
|
2009-08-11 02:59:53 +00:00
|
|
|
// Compute the intersection of all sets containing this register.
|
2013-09-16 16:43:19 +00:00
|
|
|
RegisterSet ContainingSet;
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2014-11-25 20:11:31 +00:00
|
|
|
for (const RegisterSet &RS : RegisterSets) {
|
2014-11-29 18:13:39 +00:00
|
|
|
if (!RS.count(CGR.TheDef))
|
2009-08-11 02:59:53 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ContainingSet.empty()) {
|
2014-11-25 20:11:31 +00:00
|
|
|
ContainingSet = RS;
|
2010-11-02 18:10:06 +00:00
|
|
|
continue;
|
2009-08-11 02:59:53 +00:00
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2013-09-16 16:43:19 +00:00
|
|
|
RegisterSet Tmp;
|
2010-11-02 18:10:06 +00:00
|
|
|
std::swap(Tmp, ContainingSet);
|
2013-09-16 16:43:19 +00:00
|
|
|
std::insert_iterator<RegisterSet> II(ContainingSet,
|
|
|
|
ContainingSet.begin());
|
2014-11-25 20:11:31 +00:00
|
|
|
std::set_intersection(Tmp.begin(), Tmp.end(), RS.begin(), RS.end(), II,
|
2013-09-16 16:43:19 +00:00
|
|
|
LessRecordByID());
|
2009-08-11 02:59:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!ContainingSet.empty()) {
|
|
|
|
RegisterSets.insert(ContainingSet);
|
2014-11-29 18:13:39 +00:00
|
|
|
RegisterMap.insert(std::make_pair(CGR.TheDef, ContainingSet));
|
2009-08-11 02:59:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Construct the register classes.
|
2013-09-16 16:43:19 +00:00
|
|
|
std::map<RegisterSet, ClassInfo*, LessRegisterSet> RegisterSetClasses;
|
2009-08-11 02:59:53 +00:00
|
|
|
unsigned Index = 0;
|
2014-11-25 20:11:31 +00:00
|
|
|
for (const RegisterSet &RS : RegisterSets) {
|
2014-11-28 20:35:57 +00:00
|
|
|
Classes.emplace_front();
|
|
|
|
ClassInfo *CI = &Classes.front();
|
2009-08-11 02:59:53 +00:00
|
|
|
CI->Kind = ClassInfo::RegisterClass0 + Index;
|
|
|
|
CI->ClassName = "Reg" + utostr(Index);
|
|
|
|
CI->Name = "MCK_Reg" + utostr(Index);
|
|
|
|
CI->ValueName = "";
|
|
|
|
CI->PredicateMethod = ""; // unused
|
|
|
|
CI->RenderMethod = "addRegOperands";
|
2014-11-25 20:11:31 +00:00
|
|
|
CI->Registers = RS;
|
2012-06-22 23:56:44 +00:00
|
|
|
// FIXME: diagnostic type.
|
|
|
|
CI->DiagnosticType = "";
|
2014-11-25 20:11:31 +00:00
|
|
|
RegisterSetClasses.insert(std::make_pair(RS, CI));
|
|
|
|
++Index;
|
2009-08-11 02:59:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Find the superclasses; we could compute only the subgroup lattice edges,
|
|
|
|
// but there isn't really a point.
|
2014-11-25 20:11:31 +00:00
|
|
|
for (const RegisterSet &RS : RegisterSets) {
|
|
|
|
ClassInfo *CI = RegisterSetClasses[RS];
|
|
|
|
for (const RegisterSet &RS2 : RegisterSets)
|
|
|
|
if (RS != RS2 &&
|
|
|
|
std::includes(RS2.begin(), RS2.end(), RS.begin(), RS.end(),
|
2013-09-16 16:43:19 +00:00
|
|
|
LessRecordByID()))
|
2014-11-25 20:11:31 +00:00
|
|
|
CI->SuperClasses.push_back(RegisterSetClasses[RS2]);
|
2009-08-11 02:59:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Name the register classes which correspond to a user defined RegisterClass.
|
2014-12-03 19:58:45 +00:00
|
|
|
for (const CodeGenRegisterClass &RC : RegClassList) {
|
2011-10-04 15:28:08 +00:00
|
|
|
// Def will be NULL for non-user defined register classes.
|
2014-12-03 19:58:45 +00:00
|
|
|
Record *Def = RC.getDef();
|
2011-10-04 15:28:08 +00:00
|
|
|
if (!Def)
|
|
|
|
continue;
|
2014-12-03 19:58:45 +00:00
|
|
|
ClassInfo *CI = RegisterSetClasses[RegisterSet(RC.getOrder().begin(),
|
|
|
|
RC.getOrder().end())];
|
2009-08-11 02:59:53 +00:00
|
|
|
if (CI->ValueName.empty()) {
|
2014-12-03 19:58:45 +00:00
|
|
|
CI->ClassName = RC.getName();
|
|
|
|
CI->Name = "MCK_" + RC.getName();
|
|
|
|
CI->ValueName = RC.getName();
|
2009-08-11 02:59:53 +00:00
|
|
|
} else
|
2014-12-03 19:58:45 +00:00
|
|
|
CI->ValueName = CI->ValueName + "," + RC.getName();
|
2009-08-11 02:59:53 +00:00
|
|
|
|
2011-10-04 15:28:08 +00:00
|
|
|
RegisterClassClasses.insert(std::make_pair(Def, CI));
|
2009-08-11 02:59:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Populate the map for individual registers.
|
2013-09-16 16:43:19 +00:00
|
|
|
for (std::map<Record*, RegisterSet>::iterator it = RegisterMap.begin(),
|
2009-08-11 02:59:53 +00:00
|
|
|
ie = RegisterMap.end(); it != ie; ++it)
|
2010-11-02 18:10:06 +00:00
|
|
|
RegisterClasses[it->first] = RegisterSetClasses[it->second];
|
2009-08-11 23:23:44 +00:00
|
|
|
|
|
|
|
// Name the register classes which correspond to singleton registers.
|
2014-11-25 20:11:31 +00:00
|
|
|
for (Record *Rec : SingletonRegisters) {
|
2010-11-02 18:10:06 +00:00
|
|
|
ClassInfo *CI = RegisterClasses[Rec];
|
2010-11-01 01:47:07 +00:00
|
|
|
assert(CI && "Missing singleton register class info!");
|
|
|
|
|
|
|
|
if (CI->ValueName.empty()) {
|
|
|
|
CI->ClassName = Rec->getName();
|
|
|
|
CI->Name = "MCK_" + Rec->getName();
|
|
|
|
CI->ValueName = Rec->getName();
|
|
|
|
} else
|
|
|
|
CI->ValueName = CI->ValueName + "," + Rec->getName();
|
2009-08-11 23:23:44 +00:00
|
|
|
}
|
2009-08-11 02:59:53 +00:00
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
void AsmMatcherInfo::buildOperandClasses() {
|
2010-11-01 23:57:23 +00:00
|
|
|
std::vector<Record*> AsmOperands =
|
|
|
|
Records.getAllDerivedDefinitions("AsmOperandClass");
|
2010-01-30 01:02:37 +00:00
|
|
|
|
|
|
|
// Pre-populate AsmOperandClasses map.
|
2014-11-28 20:35:57 +00:00
|
|
|
for (Record *Rec : AsmOperands) {
|
|
|
|
Classes.emplace_front();
|
|
|
|
AsmOperandClasses[Rec] = &Classes.front();
|
|
|
|
}
|
2010-01-30 01:02:37 +00:00
|
|
|
|
2009-08-10 18:41:10 +00:00
|
|
|
unsigned Index = 0;
|
2014-11-25 20:11:31 +00:00
|
|
|
for (Record *Rec : AsmOperands) {
|
|
|
|
ClassInfo *CI = AsmOperandClasses[Rec];
|
2009-08-10 18:41:10 +00:00
|
|
|
CI->Kind = ClassInfo::UserClass0 + Index;
|
|
|
|
|
2014-11-25 20:11:31 +00:00
|
|
|
ListInit *Supers = Rec->getValueAsListInit("SuperClasses");
|
2010-05-22 21:02:29 +00:00
|
|
|
for (unsigned i = 0, e = Supers->getSize(); i != e; ++i) {
|
2012-10-10 20:24:43 +00:00
|
|
|
DefInit *DI = dyn_cast<DefInit>(Supers->getElement(i));
|
2010-05-22 21:02:29 +00:00
|
|
|
if (!DI) {
|
2014-11-25 20:11:31 +00:00
|
|
|
PrintError(Rec->getLoc(), "Invalid super class reference!");
|
2010-05-22 21:02:29 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2009-08-11 02:59:53 +00:00
|
|
|
ClassInfo *SC = AsmOperandClasses[DI->getDef()];
|
|
|
|
if (!SC)
|
2014-11-25 20:11:31 +00:00
|
|
|
PrintError(Rec->getLoc(), "Invalid super class reference!");
|
2009-08-11 02:59:53 +00:00
|
|
|
else
|
|
|
|
CI->SuperClasses.push_back(SC);
|
2009-08-08 07:50:56 +00:00
|
|
|
}
|
2014-11-25 20:11:31 +00:00
|
|
|
CI->ClassName = Rec->getValueAsString("Name");
|
2009-08-10 18:41:10 +00:00
|
|
|
CI->Name = "MCK_" + CI->ClassName;
|
2014-11-25 20:11:31 +00:00
|
|
|
CI->ValueName = Rec->getName();
|
2009-08-10 21:00:45 +00:00
|
|
|
|
|
|
|
// Get or construct the predicate method name.
|
2014-11-25 20:11:31 +00:00
|
|
|
Init *PMName = Rec->getValueInit("PredicateMethod");
|
2012-10-10 20:24:43 +00:00
|
|
|
if (StringInit *SI = dyn_cast<StringInit>(PMName)) {
|
2009-08-10 21:00:45 +00:00
|
|
|
CI->PredicateMethod = SI->getValue();
|
|
|
|
} else {
|
2012-10-10 20:24:47 +00:00
|
|
|
assert(isa<UnsetInit>(PMName) && "Unexpected PredicateMethod field!");
|
2009-08-10 21:00:45 +00:00
|
|
|
CI->PredicateMethod = "is" + CI->ClassName;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get or construct the render method name.
|
2014-11-25 20:11:31 +00:00
|
|
|
Init *RMName = Rec->getValueInit("RenderMethod");
|
2012-10-10 20:24:43 +00:00
|
|
|
if (StringInit *SI = dyn_cast<StringInit>(RMName)) {
|
2009-08-10 21:00:45 +00:00
|
|
|
CI->RenderMethod = SI->getValue();
|
|
|
|
} else {
|
2012-10-10 20:24:47 +00:00
|
|
|
assert(isa<UnsetInit>(RMName) && "Unexpected RenderMethod field!");
|
2009-08-10 21:00:45 +00:00
|
|
|
CI->RenderMethod = "add" + CI->ClassName + "Operands";
|
|
|
|
}
|
|
|
|
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
// Get the parse method name or leave it as empty.
|
2014-11-25 20:11:31 +00:00
|
|
|
Init *PRMName = Rec->getValueInit("ParserMethod");
|
2012-10-10 20:24:43 +00:00
|
|
|
if (StringInit *SI = dyn_cast<StringInit>(PRMName))
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
CI->ParserMethod = SI->getValue();
|
|
|
|
|
2012-06-22 23:56:44 +00:00
|
|
|
// Get the diagnostic type or leave it as empty.
|
|
|
|
// Get the parse method name or leave it as empty.
|
2014-11-25 20:11:31 +00:00
|
|
|
Init *DiagnosticType = Rec->getValueInit("DiagnosticType");
|
2012-10-10 20:24:43 +00:00
|
|
|
if (StringInit *SI = dyn_cast<StringInit>(DiagnosticType))
|
2012-06-22 23:56:44 +00:00
|
|
|
CI->DiagnosticType = SI->getValue();
|
|
|
|
|
2014-11-25 20:11:31 +00:00
|
|
|
++Index;
|
2009-08-08 07:50:56 +00:00
|
|
|
}
|
2009-08-11 02:59:53 +00:00
|
|
|
}
|
|
|
|
|
2011-01-26 21:26:19 +00:00
|
|
|
AsmMatcherInfo::AsmMatcherInfo(Record *asmParser,
|
|
|
|
CodeGenTarget &target,
|
2010-12-15 04:48:22 +00:00
|
|
|
RecordKeeper &records)
|
2012-01-07 01:33:34 +00:00
|
|
|
: Records(records), AsmParser(asmParser), Target(target) {
|
2009-08-11 20:59:47 +00:00
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// buildOperandMatchInfo - Build the necessary information to handle user
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
/// defined operand parsing methods.
|
2012-04-19 17:52:32 +00:00
|
|
|
void AsmMatcherInfo::buildOperandMatchInfo() {
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
2012-04-18 23:46:25 +00:00
|
|
|
/// Map containing a mask with all operands indices that can be found for
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
/// that class inside a instruction.
|
2014-03-01 11:47:00 +00:00
|
|
|
typedef std::map<ClassInfo *, unsigned, less_ptr<ClassInfo>> OpClassMaskTy;
|
2012-09-19 01:47:03 +00:00
|
|
|
OpClassMaskTy OpClassMask;
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
2014-11-28 03:53:02 +00:00
|
|
|
for (const auto &MI : Matchables) {
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OpClassMask.clear();
|
|
|
|
|
|
|
|
// Keep track of all operands of this instructions which belong to the
|
|
|
|
// same class.
|
2014-11-28 23:00:22 +00:00
|
|
|
for (unsigned i = 0, e = MI->AsmOperands.size(); i != e; ++i) {
|
|
|
|
const MatchableInfo::AsmOperand &Op = MI->AsmOperands[i];
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
if (Op.Class->ParserMethod.empty())
|
|
|
|
continue;
|
|
|
|
unsigned &OperandMask = OpClassMask[Op.Class];
|
|
|
|
OperandMask |= (1 << i);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Generate operand match info for each mnemonic/operand class pair.
|
2014-11-28 03:53:00 +00:00
|
|
|
for (const auto &OCM : OpClassMask) {
|
|
|
|
unsigned OpMask = OCM.second;
|
|
|
|
ClassInfo *CI = OCM.first;
|
2014-11-28 23:00:22 +00:00
|
|
|
OperandMatchInfo.push_back(OperandMatchEntry::create(MI.get(), CI,
|
|
|
|
OpMask));
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
void AsmMatcherInfo::buildInfo() {
|
2010-10-30 20:07:57 +00:00
|
|
|
// Build information about all of the AssemblerPredicates.
|
|
|
|
std::vector<Record*> AllPredicates =
|
|
|
|
Records.getAllDerivedDefinitions("Predicate");
|
|
|
|
for (unsigned i = 0, e = AllPredicates.size(); i != e; ++i) {
|
|
|
|
Record *Pred = AllPredicates[i];
|
|
|
|
// Ignore predicates that are not intended for the assembler.
|
|
|
|
if (!Pred->getValueAsBit("AssemblerMatcherPredicate"))
|
|
|
|
continue;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 04:44:29 +00:00
|
|
|
if (Pred->getName().empty())
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(Pred->getLoc(), "Predicate has no name!");
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2014-11-28 22:15:06 +00:00
|
|
|
SubtargetFeatures.insert(std::make_pair(
|
|
|
|
Pred, SubtargetFeatureInfo(Pred, SubtargetFeatures.size())));
|
|
|
|
DEBUG(SubtargetFeatures.find(Pred)->second.dump());
|
|
|
|
assert(SubtargetFeatures.size() <= 64 && "Too many subtarget features!");
|
2010-10-30 20:07:57 +00:00
|
|
|
}
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2010-10-31 19:10:56 +00:00
|
|
|
// Parse the instructions; we need to do this first so that we can gather the
|
|
|
|
// singleton register classes.
|
2010-11-01 01:47:07 +00:00
|
|
|
SmallPtrSet<Record*, 16> SingletonRegisters;
|
2012-01-09 19:13:28 +00:00
|
|
|
unsigned VariantCount = Target.getAsmParserVariantCount();
|
|
|
|
for (unsigned VC = 0; VC != VariantCount; ++VC) {
|
|
|
|
Record *AsmVariant = Target.getAsmParserVariant(VC);
|
2012-04-17 00:01:04 +00:00
|
|
|
std::string CommentDelimiter =
|
|
|
|
AsmVariant->getValueAsString("CommentDelimiter");
|
2012-01-09 19:13:28 +00:00
|
|
|
std::string RegisterPrefix = AsmVariant->getValueAsString("RegisterPrefix");
|
|
|
|
int AsmVariantNo = AsmVariant->getValueAsInt("Variant");
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2014-11-25 20:11:31 +00:00
|
|
|
for (const CodeGenInstruction *CGI : Target.instructions()) {
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2012-01-09 19:13:28 +00:00
|
|
|
// If the tblgen -match-prefix option is specified (for tblgen hackers),
|
|
|
|
// filter the set of instructions we consider.
|
2014-11-25 20:11:31 +00:00
|
|
|
if (!StringRef(CGI->TheDef->getName()).startswith(MatchPrefix))
|
2012-04-11 21:02:33 +00:00
|
|
|
continue;
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2012-01-09 19:13:28 +00:00
|
|
|
// Ignore "codegen only" instructions.
|
2014-11-25 20:11:31 +00:00
|
|
|
if (CGI->TheDef->getValueAsBit("isCodeGenOnly"))
|
2012-04-11 21:02:33 +00:00
|
|
|
continue;
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2014-11-28 23:00:22 +00:00
|
|
|
std::unique_ptr<MatchableInfo> II(new MatchableInfo(*CGI));
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
II->initialize(*this, SingletonRegisters, AsmVariantNo, RegisterPrefix);
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2012-01-09 19:13:28 +00:00
|
|
|
// Ignore instructions which shouldn't be matched and diagnose invalid
|
|
|
|
// instruction definitions with an error.
|
2012-04-19 17:52:32 +00:00
|
|
|
if (!II->validate(CommentDelimiter, true))
|
2014-11-28 23:00:22 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
Matchables.push_back(std::move(II));
|
2012-01-09 19:13:28 +00:00
|
|
|
}
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2012-01-09 19:13:28 +00:00
|
|
|
// Parse all of the InstAlias definitions and stick them in the list of
|
|
|
|
// matchables.
|
|
|
|
std::vector<Record*> AllInstAliases =
|
|
|
|
Records.getAllDerivedDefinitions("InstAlias");
|
|
|
|
for (unsigned i = 0, e = AllInstAliases.size(); i != e; ++i) {
|
2014-12-22 21:26:26 +00:00
|
|
|
auto Alias = llvm::make_unique<CodeGenInstAlias>(AllInstAliases[i],
|
|
|
|
AsmVariantNo, Target);
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2012-01-09 19:13:28 +00:00
|
|
|
// If the tblgen -match-prefix option is specified (for tblgen hackers),
|
|
|
|
// filter the set of instruction aliases we consider, based on the target
|
|
|
|
// instruction.
|
2012-04-17 00:01:04 +00:00
|
|
|
if (!StringRef(Alias->ResultInst->TheDef->getName())
|
|
|
|
.startswith( MatchPrefix))
|
2012-04-11 21:02:33 +00:00
|
|
|
continue;
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2014-12-22 21:26:26 +00:00
|
|
|
std::unique_ptr<MatchableInfo> II(new MatchableInfo(std::move(Alias)));
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
II->initialize(*this, SingletonRegisters, AsmVariantNo, RegisterPrefix);
|
2012-01-24 21:06:59 +00:00
|
|
|
|
2012-01-09 19:13:28 +00:00
|
|
|
// Validate the alias definitions.
|
2012-04-19 17:52:32 +00:00
|
|
|
II->validate(CommentDelimiter, false);
|
2014-11-28 23:00:22 +00:00
|
|
|
|
|
|
|
Matchables.push_back(std::move(II));
|
2010-11-04 00:43:46 +00:00
|
|
|
}
|
2010-11-01 04:05:41 +00:00
|
|
|
}
|
2010-11-01 04:03:32 +00:00
|
|
|
|
2009-08-11 23:23:44 +00:00
|
|
|
// Build info for the register classes.
|
2012-04-19 17:52:32 +00:00
|
|
|
buildRegisterClasses(SingletonRegisters);
|
2009-08-11 23:23:44 +00:00
|
|
|
|
|
|
|
// Build info for the user defined assembly operand classes.
|
2012-04-19 17:52:32 +00:00
|
|
|
buildOperandClasses();
|
2009-08-11 23:23:44 +00:00
|
|
|
|
2010-11-04 00:57:06 +00:00
|
|
|
// Build the information about matchables, now that we have fully formed
|
|
|
|
// classes.
|
2014-11-28 23:00:22 +00:00
|
|
|
std::vector<std::unique_ptr<MatchableInfo>> NewMatchables;
|
2014-11-28 03:53:02 +00:00
|
|
|
for (auto &II : Matchables) {
|
2010-09-06 21:01:37 +00:00
|
|
|
// Parse the tokens after the mnemonic.
|
2012-04-19 17:52:32 +00:00
|
|
|
// Note: buildInstructionOperandReference may insert new AsmOperands, so
|
2011-01-26 19:44:55 +00:00
|
|
|
// don't precompute the loop bound.
|
2014-11-28 23:00:22 +00:00
|
|
|
for (unsigned i = 0; i != II->AsmOperands.size(); ++i) {
|
|
|
|
MatchableInfo::AsmOperand &Op = II->AsmOperands[i];
|
2010-11-02 17:30:52 +00:00
|
|
|
StringRef Token = Op.Token;
|
2009-08-07 08:26:05 +00:00
|
|
|
|
2009-08-11 23:23:44 +00:00
|
|
|
// Check for singleton registers.
|
2014-11-28 23:00:22 +00:00
|
|
|
if (Record *RegRecord = II->AsmOperands[i].SingletonReg) {
|
2010-11-02 17:30:52 +00:00
|
|
|
Op.Class = RegisterClasses[RegRecord];
|
2010-11-01 01:37:30 +00:00
|
|
|
assert(Op.Class && Op.Class->Registers.size() == 1 &&
|
|
|
|
"Unexpected class for singleton register");
|
|
|
|
continue;
|
2009-08-11 23:23:44 +00:00
|
|
|
}
|
|
|
|
|
2009-08-07 08:26:05 +00:00
|
|
|
// Check for simple tokens.
|
|
|
|
if (Token[0] != '$') {
|
2010-11-02 17:30:52 +00:00
|
|
|
Op.Class = getTokenClass(Token);
|
2009-08-07 08:26:05 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-07-31 02:32:59 +00:00
|
|
|
|
2010-11-06 22:06:03 +00:00
|
|
|
if (Token.size() > 1 && isdigit(Token[1])) {
|
|
|
|
Op.Class = getTokenClass(Token);
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-04 02:11:18 +00:00
|
|
|
// Otherwise this is an operand reference.
|
2010-11-04 01:58:23 +00:00
|
|
|
StringRef OperandName;
|
|
|
|
if (Token[1] == '{')
|
|
|
|
OperandName = Token.substr(2, Token.size() - 3);
|
|
|
|
else
|
|
|
|
OperandName = Token.substr(1);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2014-11-28 23:00:22 +00:00
|
|
|
if (II->DefRec.is<const CodeGenInstruction*>())
|
|
|
|
buildInstructionOperandReference(II.get(), OperandName, i);
|
2010-11-04 02:11:18 +00:00
|
|
|
else
|
2014-11-28 23:00:22 +00:00
|
|
|
buildAliasOperandReference(II.get(), OperandName, Op);
|
2009-08-04 20:36:45 +00:00
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2014-11-28 23:00:22 +00:00
|
|
|
if (II->DefRec.is<const CodeGenInstruction*>()) {
|
|
|
|
II->buildInstructionResultOperands();
|
2012-04-19 23:59:23 +00:00
|
|
|
// If the instruction has a two-operand alias, build up the
|
|
|
|
// matchable here. We'll add them in bulk at the end to avoid
|
|
|
|
// confusing this loop.
|
|
|
|
std::string Constraint =
|
2014-11-28 23:00:22 +00:00
|
|
|
II->TheDef->getValueAsString("TwoOperandAliasConstraint");
|
2012-04-19 23:59:23 +00:00
|
|
|
if (Constraint != "") {
|
|
|
|
// Start by making a copy of the original matchable.
|
2014-11-28 23:00:22 +00:00
|
|
|
std::unique_ptr<MatchableInfo> AliasII(new MatchableInfo(*II));
|
2012-04-19 23:59:23 +00:00
|
|
|
|
|
|
|
// Adjust it to be a two-operand alias.
|
2014-11-28 23:00:22 +00:00
|
|
|
AliasII->formTwoOperandAlias(Constraint);
|
|
|
|
|
|
|
|
// Add the alias to the matchables list.
|
|
|
|
NewMatchables.push_back(std::move(AliasII));
|
2012-04-19 23:59:23 +00:00
|
|
|
}
|
|
|
|
} else
|
2014-11-28 23:00:22 +00:00
|
|
|
II->buildAliasResultOperands();
|
2009-08-07 08:26:05 +00:00
|
|
|
}
|
2014-11-28 23:00:22 +00:00
|
|
|
if (!NewMatchables.empty())
|
|
|
|
std::move(NewMatchables.begin(), NewMatchables.end(),
|
|
|
|
std::back_inserter(Matchables));
|
2009-08-09 07:20:21 +00:00
|
|
|
|
2011-12-06 23:43:54 +00:00
|
|
|
// Process token alias definitions and set up the associated superclass
|
|
|
|
// information.
|
|
|
|
std::vector<Record*> AllTokenAliases =
|
|
|
|
Records.getAllDerivedDefinitions("TokenAlias");
|
|
|
|
for (unsigned i = 0, e = AllTokenAliases.size(); i != e; ++i) {
|
|
|
|
Record *Rec = AllTokenAliases[i];
|
|
|
|
ClassInfo *FromClass = getTokenClass(Rec->getValueAsString("FromToken"));
|
|
|
|
ClassInfo *ToClass = getTokenClass(Rec->getValueAsString("ToToken"));
|
2012-04-17 21:23:52 +00:00
|
|
|
if (FromClass == ToClass)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(Rec->getLoc(),
|
2012-04-17 21:23:52 +00:00
|
|
|
"error: Destination value identical to source value.");
|
2011-12-06 23:43:54 +00:00
|
|
|
FromClass->SuperClasses.push_back(ToClass);
|
|
|
|
}
|
|
|
|
|
2011-04-15 05:18:47 +00:00
|
|
|
// Reorder classes so that classes precede super classes.
|
2014-11-28 20:35:57 +00:00
|
|
|
Classes.sort();
|
2009-08-07 08:26:05 +00:00
|
|
|
}
|
2009-07-31 02:32:59 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// buildInstructionOperandReference - The specified operand is a reference to a
|
2010-11-04 00:57:06 +00:00
|
|
|
/// named operand such as $src. Resolve the Class and OperandInfo pointers.
|
|
|
|
void AsmMatcherInfo::
|
2012-04-19 17:52:32 +00:00
|
|
|
buildInstructionOperandReference(MatchableInfo *II,
|
2010-11-04 01:58:23 +00:00
|
|
|
StringRef OperandName,
|
2011-01-26 19:44:55 +00:00
|
|
|
unsigned AsmOpIdx) {
|
2010-11-04 02:11:18 +00:00
|
|
|
const CodeGenInstruction &CGI = *II->DefRec.get<const CodeGenInstruction*>();
|
|
|
|
const CGIOperandList &Operands = CGI.Operands;
|
2011-01-26 19:44:55 +00:00
|
|
|
MatchableInfo::AsmOperand *Op = &II->AsmOperands[AsmOpIdx];
|
2011-01-26 21:26:19 +00:00
|
|
|
|
Reimplement BuildResultOperands to be in terms of the result instruction's
operand list instead of the operand list redundantly declared on the alias
or instruction.
With this change, we finally remove the ins/outs list on the alias. Before:
def : InstAlias<(outs GR16:$dst), (ins GR8 :$src),
"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
After:
def : InstAlias<"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
This also makes the alias mechanism more general and powerful, which will
be exploited in subsequent patches.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@118329 91177308-0d34-0410-b5e6-96231b3b80d8
2010-11-06 07:14:44 +00:00
|
|
|
// Map this token to an operand.
|
2010-11-04 00:57:06 +00:00
|
|
|
unsigned Idx;
|
|
|
|
if (!Operands.hasOperandNamed(OperandName, Idx))
|
2014-03-29 17:17:15 +00:00
|
|
|
PrintFatalError(II->TheDef->getLoc(),
|
|
|
|
"error: unable to find operand: '" + OperandName + "'");
|
2010-11-04 01:55:23 +00:00
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
// If the instruction operand has multiple suboperands, but the parser
|
|
|
|
// match class for the asm operand is still the default "ImmAsmOperand",
|
|
|
|
// then handle each suboperand separately.
|
|
|
|
if (Op->SubOpIdx == -1 && Operands[Idx].MINumOperands > 1) {
|
|
|
|
Record *Rec = Operands[Idx].Rec;
|
|
|
|
assert(Rec->isSubClassOf("Operand") && "Unexpected operand!");
|
|
|
|
Record *MatchClass = Rec->getValueAsDef("ParserMatchClass");
|
|
|
|
if (MatchClass && MatchClass->getValueAsString("Name") == "Imm") {
|
|
|
|
// Insert remaining suboperands after AsmOpIdx in II->AsmOperands.
|
|
|
|
StringRef Token = Op->Token; // save this in case Op gets moved
|
|
|
|
for (unsigned SI = 1, SE = Operands[Idx].MINumOperands; SI != SE; ++SI) {
|
|
|
|
MatchableInfo::AsmOperand NewAsmOp(Token);
|
|
|
|
NewAsmOp.SubOpIdx = SI;
|
|
|
|
II->AsmOperands.insert(II->AsmOperands.begin()+AsmOpIdx+SI, NewAsmOp);
|
|
|
|
}
|
|
|
|
// Replace Op with first suboperand.
|
|
|
|
Op = &II->AsmOperands[AsmOpIdx]; // update the pointer in case it moved
|
|
|
|
Op->SubOpIdx = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-04 01:55:23 +00:00
|
|
|
// Set up the operand class.
|
2011-01-26 19:44:55 +00:00
|
|
|
Op->Class = getOperandClass(Operands[Idx], Op->SubOpIdx);
|
2010-11-04 01:55:23 +00:00
|
|
|
|
|
|
|
// If the named operand is tied, canonicalize it to the untied operand.
|
|
|
|
// For example, something like:
|
|
|
|
// (outs GPR:$dst), (ins GPR:$src)
|
|
|
|
// with an asmstring of
|
|
|
|
// "inc $src"
|
|
|
|
// we want to canonicalize to:
|
2010-11-04 02:11:18 +00:00
|
|
|
// "inc $dst"
|
|
|
|
// so that we know how to provide the $dst operand when filling in the result.
|
Handle tied sub-operands in AsmMatcherEmitter
The problem this patch addresses is the handling of register tie
constraints in AsmMatcherEmitter, where one operand is tied to a
sub-operand of another operand. The typical scenario for this to
happen is the tie between the "write-back" register of a pre-inc
instruction, and the base register sub-operand of the memory address
operand of that instruction.
The current AsmMatcherEmitter code attempts to handle tied
operands by emitting the operand as usual first, and emitting
a CVT_Tied node when handling the second (tied) operand. However,
this really only works correctly if the tied operand does not
have sub-operands (and isn't a sub-operand itself). Under those
circumstances, a wrong MC operand list is generated.
In discussions with Jim Grosbach, it turned out that the MC operand
list really ought not to contain tied operands in the first place;
instead, it ought to consist of exactly those operands that are
named in the AsmString. However, getting there requires significant
rework of (some) targets.
This patch fixes the immediate problem, and at the same time makes
one (small) step in the direction of the long-term solution, by
implementing two changes:
1. Restricts the AsmMatcherEmitter handling of tied operands to
apply solely to simple operands (not complex operands or
sub-operand of such).
This means that at least we don't get silently corrupt MC operand
lists as output. However, if we do have tied sub-operands, they
would now no longer be handled at all, except for:
2. If we have an operand that does not occur in the AsmString,
and also isn't handled as tied operand, simply emit a dummy
MC operand (constant 0).
This works as long as target code never attempts to access
MC operands that do no not occur in the AsmString (and are
not tied simple operands), which happens to be the case for
all targets where this situation can occur (ARM and PowerPC).
[ Note that this change means that many of the ARM custom
converters are now superfluous, since the implement the
same "hack" now performed already by common code. ]
Longer term, we ought to fix targets to never access *any*
MC operand that does not occur in the AsmString (including
tied simple operands), and then finally completely remove
all such operands from the MC operand list.
Patch approved by Jim Grosbach.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180677 91177308-0d34-0410-b5e6-96231b3b80d8
2013-04-27 18:48:23 +00:00
|
|
|
int OITied = -1;
|
|
|
|
if (Operands[Idx].MINumOperands == 1)
|
|
|
|
OITied = Operands[Idx].getTiedRegister();
|
2010-11-04 02:11:18 +00:00
|
|
|
if (OITied != -1) {
|
|
|
|
// The tied operand index is an MIOperand index, find the operand that
|
|
|
|
// contains it.
|
2011-01-26 19:44:55 +00:00
|
|
|
std::pair<unsigned, unsigned> Idx = Operands.getSubOperandNumber(OITied);
|
|
|
|
OperandName = Operands[Idx.first].Name;
|
|
|
|
Op->SubOpIdx = Idx.second;
|
2010-11-04 02:11:18 +00:00
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
Op->SrcOpName = OperandName;
|
2010-11-04 02:11:18 +00:00
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// buildAliasOperandReference - When parsing an operand reference out of the
|
2010-11-06 07:06:09 +00:00
|
|
|
/// matching string (e.g. "movsx $src, $dst"), determine what the class of the
|
|
|
|
/// operand reference is by looking it up in the result pattern definition.
|
2012-04-19 17:52:32 +00:00
|
|
|
void AsmMatcherInfo::buildAliasOperandReference(MatchableInfo *II,
|
2010-11-04 02:11:18 +00:00
|
|
|
StringRef OperandName,
|
|
|
|
MatchableInfo::AsmOperand &Op) {
|
|
|
|
const CodeGenInstAlias &CGA = *II->DefRec.get<const CodeGenInstAlias*>();
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-04 02:11:18 +00:00
|
|
|
// Set up the operand class.
|
2010-11-06 07:06:09 +00:00
|
|
|
for (unsigned i = 0, e = CGA.ResultOperands.size(); i != e; ++i)
|
2010-11-06 19:25:43 +00:00
|
|
|
if (CGA.ResultOperands[i].isRecord() &&
|
|
|
|
CGA.ResultOperands[i].getName() == OperandName) {
|
Reimplement BuildResultOperands to be in terms of the result instruction's
operand list instead of the operand list redundantly declared on the alias
or instruction.
With this change, we finally remove the ins/outs list on the alias. Before:
def : InstAlias<(outs GR16:$dst), (ins GR8 :$src),
"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
After:
def : InstAlias<"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
This also makes the alias mechanism more general and powerful, which will
be exploited in subsequent patches.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@118329 91177308-0d34-0410-b5e6-96231b3b80d8
2010-11-06 07:14:44 +00:00
|
|
|
// It's safe to go with the first one we find, because CodeGenInstAlias
|
|
|
|
// validates that all operands with the same name have the same record.
|
2011-01-26 19:44:55 +00:00
|
|
|
Op.SubOpIdx = CGA.ResultInstOperandIndex[i].second;
|
2011-10-28 22:32:53 +00:00
|
|
|
// Use the match class from the Alias definition, not the
|
|
|
|
// destination instruction, as we may have an immediate that's
|
|
|
|
// being munged by the match class.
|
|
|
|
Op.Class = getOperandClass(CGA.ResultOperands[i].getRecord(),
|
2011-01-26 19:44:55 +00:00
|
|
|
Op.SubOpIdx);
|
2010-11-06 07:06:09 +00:00
|
|
|
Op.SrcOpName = OperandName;
|
|
|
|
return;
|
2010-11-04 00:57:06 +00:00
|
|
|
}
|
2010-11-06 07:06:09 +00:00
|
|
|
|
2014-03-29 17:17:15 +00:00
|
|
|
PrintFatalError(II->TheDef->getLoc(),
|
|
|
|
"error: unable to find operand: '" + OperandName + "'");
|
2010-11-04 00:57:06 +00:00
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
void MatchableInfo::buildInstructionResultOperands() {
|
Reimplement BuildResultOperands to be in terms of the result instruction's
operand list instead of the operand list redundantly declared on the alias
or instruction.
With this change, we finally remove the ins/outs list on the alias. Before:
def : InstAlias<(outs GR16:$dst), (ins GR8 :$src),
"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
After:
def : InstAlias<"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
This also makes the alias mechanism more general and powerful, which will
be exploited in subsequent patches.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@118329 91177308-0d34-0410-b5e6-96231b3b80d8
2010-11-06 07:14:44 +00:00
|
|
|
const CodeGenInstruction *ResultInst = getResultInst();
|
2011-01-26 21:26:19 +00:00
|
|
|
|
Reimplement BuildResultOperands to be in terms of the result instruction's
operand list instead of the operand list redundantly declared on the alias
or instruction.
With this change, we finally remove the ins/outs list on the alias. Before:
def : InstAlias<(outs GR16:$dst), (ins GR8 :$src),
"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
After:
def : InstAlias<"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
This also makes the alias mechanism more general and powerful, which will
be exploited in subsequent patches.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@118329 91177308-0d34-0410-b5e6-96231b3b80d8
2010-11-06 07:14:44 +00:00
|
|
|
// Loop over all operands of the result instruction, determining how to
|
|
|
|
// populate them.
|
|
|
|
for (unsigned i = 0, e = ResultInst->Operands.size(); i != e; ++i) {
|
|
|
|
const CGIOperandList::OperandInfo &OpInfo = ResultInst->Operands[i];
|
2010-11-04 01:42:59 +00:00
|
|
|
|
|
|
|
// If this is a tied operand, just copy from the previously handled operand.
|
Handle tied sub-operands in AsmMatcherEmitter
The problem this patch addresses is the handling of register tie
constraints in AsmMatcherEmitter, where one operand is tied to a
sub-operand of another operand. The typical scenario for this to
happen is the tie between the "write-back" register of a pre-inc
instruction, and the base register sub-operand of the memory address
operand of that instruction.
The current AsmMatcherEmitter code attempts to handle tied
operands by emitting the operand as usual first, and emitting
a CVT_Tied node when handling the second (tied) operand. However,
this really only works correctly if the tied operand does not
have sub-operands (and isn't a sub-operand itself). Under those
circumstances, a wrong MC operand list is generated.
In discussions with Jim Grosbach, it turned out that the MC operand
list really ought not to contain tied operands in the first place;
instead, it ought to consist of exactly those operands that are
named in the AsmString. However, getting there requires significant
rework of (some) targets.
This patch fixes the immediate problem, and at the same time makes
one (small) step in the direction of the long-term solution, by
implementing two changes:
1. Restricts the AsmMatcherEmitter handling of tied operands to
apply solely to simple operands (not complex operands or
sub-operand of such).
This means that at least we don't get silently corrupt MC operand
lists as output. However, if we do have tied sub-operands, they
would now no longer be handled at all, except for:
2. If we have an operand that does not occur in the AsmString,
and also isn't handled as tied operand, simply emit a dummy
MC operand (constant 0).
This works as long as target code never attempts to access
MC operands that do no not occur in the AsmString (and are
not tied simple operands), which happens to be the case for
all targets where this situation can occur (ARM and PowerPC).
[ Note that this change means that many of the ARM custom
converters are now superfluous, since the implement the
same "hack" now performed already by common code. ]
Longer term, we ought to fix targets to never access *any*
MC operand that does not occur in the AsmString (including
tied simple operands), and then finally completely remove
all such operands from the MC operand list.
Patch approved by Jim Grosbach.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180677 91177308-0d34-0410-b5e6-96231b3b80d8
2013-04-27 18:48:23 +00:00
|
|
|
int TiedOp = -1;
|
|
|
|
if (OpInfo.MINumOperands == 1)
|
|
|
|
TiedOp = OpInfo.getTiedRegister();
|
2010-11-04 01:42:59 +00:00
|
|
|
if (TiedOp != -1) {
|
2011-01-26 19:44:55 +00:00
|
|
|
ResOperands.push_back(ResOperand::getTiedOp(TiedOp));
|
2010-11-04 01:42:59 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
// Find out what operand from the asmparser this MCInst operand comes from.
|
2012-04-19 17:52:32 +00:00
|
|
|
int SrcOperand = findAsmOperandNamed(OpInfo.Name);
|
Handle tied sub-operands in AsmMatcherEmitter
The problem this patch addresses is the handling of register tie
constraints in AsmMatcherEmitter, where one operand is tied to a
sub-operand of another operand. The typical scenario for this to
happen is the tie between the "write-back" register of a pre-inc
instruction, and the base register sub-operand of the memory address
operand of that instruction.
The current AsmMatcherEmitter code attempts to handle tied
operands by emitting the operand as usual first, and emitting
a CVT_Tied node when handling the second (tied) operand. However,
this really only works correctly if the tied operand does not
have sub-operands (and isn't a sub-operand itself). Under those
circumstances, a wrong MC operand list is generated.
In discussions with Jim Grosbach, it turned out that the MC operand
list really ought not to contain tied operands in the first place;
instead, it ought to consist of exactly those operands that are
named in the AsmString. However, getting there requires significant
rework of (some) targets.
This patch fixes the immediate problem, and at the same time makes
one (small) step in the direction of the long-term solution, by
implementing two changes:
1. Restricts the AsmMatcherEmitter handling of tied operands to
apply solely to simple operands (not complex operands or
sub-operand of such).
This means that at least we don't get silently corrupt MC operand
lists as output. However, if we do have tied sub-operands, they
would now no longer be handled at all, except for:
2. If we have an operand that does not occur in the AsmString,
and also isn't handled as tied operand, simply emit a dummy
MC operand (constant 0).
This works as long as target code never attempts to access
MC operands that do no not occur in the AsmString (and are
not tied simple operands), which happens to be the case for
all targets where this situation can occur (ARM and PowerPC).
[ Note that this change means that many of the ARM custom
converters are now superfluous, since the implement the
same "hack" now performed already by common code. ]
Longer term, we ought to fix targets to never access *any*
MC operand that does not occur in the AsmString (including
tied simple operands), and then finally completely remove
all such operands from the MC operand list.
Patch approved by Jim Grosbach.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180677 91177308-0d34-0410-b5e6-96231b3b80d8
2013-04-27 18:48:23 +00:00
|
|
|
if (OpInfo.Name.empty() || SrcOperand == -1) {
|
|
|
|
// This may happen for operands that are tied to a suboperand of a
|
|
|
|
// complex operand. Simply use a dummy value here; nobody should
|
|
|
|
// use this operand slot.
|
|
|
|
// FIXME: The long term goal is for the MCOperand list to not contain
|
|
|
|
// tied operands at all.
|
|
|
|
ResOperands.push_back(ResOperand::getImmOp(0));
|
|
|
|
continue;
|
|
|
|
}
|
2010-11-04 01:42:59 +00:00
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
// Check if the one AsmOperand populates the entire operand.
|
|
|
|
unsigned NumOperands = OpInfo.MINumOperands;
|
|
|
|
if (AsmOperands[SrcOperand].SubOpIdx == -1) {
|
|
|
|
ResOperands.push_back(ResOperand::getRenderedOp(SrcOperand, NumOperands));
|
2010-11-04 00:43:46 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-01-26 19:44:55 +00:00
|
|
|
|
|
|
|
// Add a separate ResOperand for each suboperand.
|
|
|
|
for (unsigned AI = 0; AI < NumOperands; ++AI) {
|
|
|
|
assert(AsmOperands[SrcOperand+AI].SubOpIdx == (int)AI &&
|
|
|
|
AsmOperands[SrcOperand+AI].SrcOpName == OpInfo.Name &&
|
|
|
|
"unexpected AsmOperands for suboperands");
|
|
|
|
ResOperands.push_back(ResOperand::getRenderedOp(SrcOperand + AI, 1));
|
|
|
|
}
|
2010-11-04 00:43:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
void MatchableInfo::buildAliasResultOperands() {
|
2010-11-06 07:31:43 +00:00
|
|
|
const CodeGenInstAlias &CGA = *DefRec.get<const CodeGenInstAlias*>();
|
|
|
|
const CodeGenInstruction *ResultInst = getResultInst();
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-06 07:31:43 +00:00
|
|
|
// Loop over all operands of the result instruction, determining how to
|
|
|
|
// populate them.
|
|
|
|
unsigned AliasOpNo = 0;
|
2011-01-26 19:44:55 +00:00
|
|
|
unsigned LastOpNo = CGA.ResultInstOperandIndex.size();
|
2010-11-06 07:31:43 +00:00
|
|
|
for (unsigned i = 0, e = ResultInst->Operands.size(); i != e; ++i) {
|
2011-01-26 19:44:55 +00:00
|
|
|
const CGIOperandList::OperandInfo *OpInfo = &ResultInst->Operands[i];
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-06 07:31:43 +00:00
|
|
|
// If this is a tied operand, just copy from the previously handled operand.
|
Handle tied sub-operands in AsmMatcherEmitter
The problem this patch addresses is the handling of register tie
constraints in AsmMatcherEmitter, where one operand is tied to a
sub-operand of another operand. The typical scenario for this to
happen is the tie between the "write-back" register of a pre-inc
instruction, and the base register sub-operand of the memory address
operand of that instruction.
The current AsmMatcherEmitter code attempts to handle tied
operands by emitting the operand as usual first, and emitting
a CVT_Tied node when handling the second (tied) operand. However,
this really only works correctly if the tied operand does not
have sub-operands (and isn't a sub-operand itself). Under those
circumstances, a wrong MC operand list is generated.
In discussions with Jim Grosbach, it turned out that the MC operand
list really ought not to contain tied operands in the first place;
instead, it ought to consist of exactly those operands that are
named in the AsmString. However, getting there requires significant
rework of (some) targets.
This patch fixes the immediate problem, and at the same time makes
one (small) step in the direction of the long-term solution, by
implementing two changes:
1. Restricts the AsmMatcherEmitter handling of tied operands to
apply solely to simple operands (not complex operands or
sub-operand of such).
This means that at least we don't get silently corrupt MC operand
lists as output. However, if we do have tied sub-operands, they
would now no longer be handled at all, except for:
2. If we have an operand that does not occur in the AsmString,
and also isn't handled as tied operand, simply emit a dummy
MC operand (constant 0).
This works as long as target code never attempts to access
MC operands that do no not occur in the AsmString (and are
not tied simple operands), which happens to be the case for
all targets where this situation can occur (ARM and PowerPC).
[ Note that this change means that many of the ARM custom
converters are now superfluous, since the implement the
same "hack" now performed already by common code. ]
Longer term, we ought to fix targets to never access *any*
MC operand that does not occur in the AsmString (including
tied simple operands), and then finally completely remove
all such operands from the MC operand list.
Patch approved by Jim Grosbach.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180677 91177308-0d34-0410-b5e6-96231b3b80d8
2013-04-27 18:48:23 +00:00
|
|
|
int TiedOp = -1;
|
|
|
|
if (OpInfo->MINumOperands == 1)
|
|
|
|
TiedOp = OpInfo->getTiedRegister();
|
2010-11-06 07:31:43 +00:00
|
|
|
if (TiedOp != -1) {
|
2011-01-26 19:44:55 +00:00
|
|
|
ResOperands.push_back(ResOperand::getTiedOp(TiedOp));
|
2010-11-06 19:57:21 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-01-26 19:44:55 +00:00
|
|
|
// Handle all the suboperands for this operand.
|
|
|
|
const std::string &OpName = OpInfo->Name;
|
|
|
|
for ( ; AliasOpNo < LastOpNo &&
|
|
|
|
CGA.ResultInstOperandIndex[AliasOpNo].first == i; ++AliasOpNo) {
|
|
|
|
int SubIdx = CGA.ResultInstOperandIndex[AliasOpNo].second;
|
|
|
|
|
|
|
|
// Find out what operand from the asmparser that this MCInst operand
|
|
|
|
// comes from.
|
|
|
|
switch (CGA.ResultOperands[AliasOpNo].Kind) {
|
|
|
|
case CodeGenInstAlias::ResultOperand::K_Record: {
|
|
|
|
StringRef Name = CGA.ResultOperands[AliasOpNo].getName();
|
2012-04-19 17:52:32 +00:00
|
|
|
int SrcOperand = findAsmOperand(Name, SubIdx);
|
2011-01-26 19:44:55 +00:00
|
|
|
if (SrcOperand == -1)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(TheDef->getLoc(), "Instruction '" +
|
2011-01-26 19:44:55 +00:00
|
|
|
TheDef->getName() + "' has operand '" + OpName +
|
|
|
|
"' that doesn't appear in asm string!");
|
|
|
|
unsigned NumOperands = (SubIdx == -1 ? OpInfo->MINumOperands : 1);
|
|
|
|
ResOperands.push_back(ResOperand::getRenderedOp(SrcOperand,
|
|
|
|
NumOperands));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CodeGenInstAlias::ResultOperand::K_Imm: {
|
|
|
|
int64_t ImmVal = CGA.ResultOperands[AliasOpNo].getImm();
|
|
|
|
ResOperands.push_back(ResOperand::getImmOp(ImmVal));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CodeGenInstAlias::ResultOperand::K_Reg: {
|
|
|
|
Record *Reg = CGA.ResultOperands[AliasOpNo].getRegister();
|
|
|
|
ResOperands.push_back(ResOperand::getRegOp(Reg));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-11-06 19:57:21 +00:00
|
|
|
}
|
2010-11-06 07:31:43 +00:00
|
|
|
}
|
|
|
|
}
|
2010-11-04 00:43:46 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
static unsigned getConverterOperandID(const std::string &Name,
|
|
|
|
SetVector<std::string> &Table,
|
|
|
|
bool &IsNew) {
|
|
|
|
IsNew = Table.insert(Name);
|
|
|
|
|
|
|
|
unsigned ID = IsNew ? Table.size() - 1 :
|
|
|
|
std::find(Table.begin(), Table.end(), Name) - Table.begin();
|
|
|
|
|
|
|
|
assert(ID < Table.size());
|
|
|
|
|
|
|
|
return ID;
|
|
|
|
}
|
|
|
|
|
2014-11-28 23:00:22 +00:00
|
|
|
|
2012-10-01 23:45:51 +00:00
|
|
|
static void emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
|
2014-11-28 23:00:22 +00:00
|
|
|
std::vector<std::unique_ptr<MatchableInfo>> &Infos,
|
2012-10-01 23:45:51 +00:00
|
|
|
raw_ostream &OS) {
|
2012-08-22 01:06:23 +00:00
|
|
|
SetVector<std::string> OperandConversionKinds;
|
|
|
|
SetVector<std::string> InstructionConversionKinds;
|
|
|
|
std::vector<std::vector<uint8_t> > ConversionTable;
|
|
|
|
size_t MaxRowLength = 2; // minimum is custom converter plus terminator.
|
|
|
|
|
|
|
|
// TargetOperandClass - This is the target's operand class, like X86Operand.
|
|
|
|
std::string TargetOperandClass = Target.getName() + "Operand";
|
|
|
|
|
2009-08-08 05:24:34 +00:00
|
|
|
// Write the convert function to a separate stream, so we can drop it after
|
2012-08-22 01:06:23 +00:00
|
|
|
// the enum. We'll build up the conversion handlers for the individual
|
|
|
|
// operand types opportunistically as we encounter them.
|
2009-08-08 05:24:34 +00:00
|
|
|
std::string ConvertFnBody;
|
|
|
|
raw_string_ostream CvtOS(ConvertFnBody);
|
|
|
|
// Start the unified conversion function.
|
2012-08-31 00:03:31 +00:00
|
|
|
CvtOS << "void " << Target.getName() << ClassName << "::\n"
|
2012-09-05 01:02:38 +00:00
|
|
|
<< "convertToMCInst(unsigned Kind, MCInst &Inst, "
|
2009-08-08 05:24:34 +00:00
|
|
|
<< "unsigned Opcode,\n"
|
2014-06-08 16:18:35 +00:00
|
|
|
<< " const OperandVector"
|
|
|
|
<< " &Operands) {\n"
|
2012-08-31 00:03:31 +00:00
|
|
|
<< " assert(Kind < CVT_NUM_SIGNATURES && \"Invalid signature!\");\n"
|
2012-09-18 01:41:49 +00:00
|
|
|
<< " const uint8_t *Converter = ConversionTable[Kind];\n"
|
2012-08-22 01:06:23 +00:00
|
|
|
<< " Inst.setOpcode(Opcode);\n"
|
2012-09-18 01:41:49 +00:00
|
|
|
<< " for (const uint8_t *p = Converter; *p; p+= 2) {\n"
|
2012-08-22 01:06:23 +00:00
|
|
|
<< " switch (*p) {\n"
|
|
|
|
<< " default: llvm_unreachable(\"invalid conversion entry!\");\n"
|
|
|
|
<< " case CVT_Reg:\n"
|
|
|
|
<< " static_cast<" << TargetOperandClass
|
2014-06-08 16:18:35 +00:00
|
|
|
<< "&>(*Operands[*(p + 1)]).addRegOperands(Inst, 1);\n"
|
2012-08-22 01:06:23 +00:00
|
|
|
<< " break;\n"
|
|
|
|
<< " case CVT_Tied:\n"
|
|
|
|
<< " Inst.addOperand(Inst.getOperand(*(p + 1)));\n"
|
|
|
|
<< " break;\n";
|
|
|
|
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
std::string OperandFnBody;
|
|
|
|
raw_string_ostream OpOS(OperandFnBody);
|
|
|
|
// Start the operand number lookup function.
|
2012-10-01 23:45:51 +00:00
|
|
|
OpOS << "void " << Target.getName() << ClassName << "::\n"
|
|
|
|
<< "convertToMapAndConstraints(unsigned Kind,\n";
|
2012-10-02 00:25:57 +00:00
|
|
|
OpOS.indent(27);
|
2014-06-08 16:18:35 +00:00
|
|
|
OpOS << "const OperandVector &Operands) {\n"
|
2012-08-31 00:03:31 +00:00
|
|
|
<< " assert(Kind < CVT_NUM_SIGNATURES && \"Invalid signature!\");\n"
|
2012-10-01 23:45:51 +00:00
|
|
|
<< " unsigned NumMCOperands = 0;\n"
|
2012-09-18 01:41:49 +00:00
|
|
|
<< " const uint8_t *Converter = ConversionTable[Kind];\n"
|
|
|
|
<< " for (const uint8_t *p = Converter; *p; p+= 2) {\n"
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
<< " switch (*p) {\n"
|
|
|
|
<< " default: llvm_unreachable(\"invalid conversion entry!\");\n"
|
|
|
|
<< " case CVT_Reg:\n"
|
2012-10-12 22:53:36 +00:00
|
|
|
<< " Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);\n"
|
2013-01-15 23:07:53 +00:00
|
|
|
<< " Operands[*(p + 1)]->setConstraint(\"r\");\n"
|
2012-10-12 22:53:36 +00:00
|
|
|
<< " ++NumMCOperands;\n"
|
|
|
|
<< " break;\n"
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
<< " case CVT_Tied:\n"
|
2012-10-01 23:45:51 +00:00
|
|
|
<< " ++NumMCOperands;\n"
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
<< " break;\n";
|
2012-08-22 01:06:23 +00:00
|
|
|
|
|
|
|
// Pre-populate the operand conversion kinds with the standard always
|
|
|
|
// available entries.
|
|
|
|
OperandConversionKinds.insert("CVT_Done");
|
|
|
|
OperandConversionKinds.insert("CVT_Reg");
|
|
|
|
OperandConversionKinds.insert("CVT_Tied");
|
|
|
|
enum { CVT_Done, CVT_Reg, CVT_Tied };
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2014-11-28 03:53:02 +00:00
|
|
|
for (auto &II : Infos) {
|
2011-02-04 17:12:15 +00:00
|
|
|
// Check if we have a custom match function.
|
2011-04-01 20:23:52 +00:00
|
|
|
std::string AsmMatchConverter =
|
2014-11-28 23:00:22 +00:00
|
|
|
II->getResultInst()->TheDef->getValueAsString("AsmMatchConverter");
|
2011-02-04 17:12:15 +00:00
|
|
|
if (!AsmMatchConverter.empty()) {
|
2011-04-01 20:23:52 +00:00
|
|
|
std::string Signature = "ConvertCustom_" + AsmMatchConverter;
|
2014-11-28 23:00:22 +00:00
|
|
|
II->ConversionFnKind = Signature;
|
2011-02-04 17:12:15 +00:00
|
|
|
|
|
|
|
// Check if we have already generated this signature.
|
2012-08-22 01:06:23 +00:00
|
|
|
if (!InstructionConversionKinds.insert(Signature))
|
2011-02-04 17:12:15 +00:00
|
|
|
continue;
|
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
// Remember this converter for the kind enum.
|
|
|
|
unsigned KindID = OperandConversionKinds.size();
|
2013-01-10 16:47:31 +00:00
|
|
|
OperandConversionKinds.insert("CVT_" +
|
|
|
|
getEnumNameForToken(AsmMatchConverter));
|
2012-08-22 01:06:23 +00:00
|
|
|
|
|
|
|
// Add the converter row for this instruction.
|
|
|
|
ConversionTable.push_back(std::vector<uint8_t>());
|
|
|
|
ConversionTable.back().push_back(KindID);
|
|
|
|
ConversionTable.back().push_back(CVT_Done);
|
2011-02-04 17:12:15 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
// Add the handler to the conversion driver function.
|
2013-01-10 16:47:31 +00:00
|
|
|
CvtOS << " case CVT_"
|
|
|
|
<< getEnumNameForToken(AsmMatchConverter) << ":\n"
|
2012-08-31 22:12:31 +00:00
|
|
|
<< " " << AsmMatchConverter << "(Inst, Operands);\n"
|
2012-08-31 00:03:31 +00:00
|
|
|
<< " break;\n";
|
2012-08-22 01:06:23 +00:00
|
|
|
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
// FIXME: Handle the operand number lookup for custom match functions.
|
2011-02-04 17:12:15 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2009-08-07 08:26:05 +00:00
|
|
|
// Build the conversion function signature.
|
|
|
|
std::string Signature = "Convert";
|
2012-08-22 01:06:23 +00:00
|
|
|
|
|
|
|
std::vector<uint8_t> ConversionRow;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-02 21:49:44 +00:00
|
|
|
// Compute the convert enum and the case body.
|
2014-11-28 23:00:22 +00:00
|
|
|
MaxRowLength = std::max(MaxRowLength, II->ResOperands.size()*2 + 1 );
|
2012-08-22 01:06:23 +00:00
|
|
|
|
2014-11-28 23:00:22 +00:00
|
|
|
for (unsigned i = 0, e = II->ResOperands.size(); i != e; ++i) {
|
|
|
|
const MatchableInfo::ResOperand &OpInfo = II->ResOperands[i];
|
2010-11-04 00:43:46 +00:00
|
|
|
|
|
|
|
// Generate code to populate each result operand.
|
|
|
|
switch (OpInfo.Kind) {
|
|
|
|
case MatchableInfo::ResOperand::RenderAsmOperand: {
|
|
|
|
// This comes from something we parsed.
|
2014-11-25 20:11:31 +00:00
|
|
|
const MatchableInfo::AsmOperand &Op =
|
2014-11-28 23:00:22 +00:00
|
|
|
II->AsmOperands[OpInfo.AsmOperandNum];
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-02 22:55:03 +00:00
|
|
|
// Registers are always converted the same, don't duplicate the
|
|
|
|
// conversion function based on them.
|
|
|
|
Signature += "__";
|
2012-08-22 01:06:23 +00:00
|
|
|
std::string Class;
|
|
|
|
Class = Op.Class->isRegisterClass() ? "Reg" : Op.Class->ClassName;
|
|
|
|
Signature += Class;
|
2011-01-26 19:44:55 +00:00
|
|
|
Signature += utostr(OpInfo.MINumOperands);
|
2010-11-04 00:43:46 +00:00
|
|
|
Signature += "_" + itostr(OpInfo.AsmOperandNum);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
// Add the conversion kind, if necessary, and get the associated ID
|
|
|
|
// the index of its entry in the vector).
|
|
|
|
std::string Name = "CVT_" + (Op.Class->isRegisterClass() ? "Reg" :
|
|
|
|
Op.Class->RenderMethod);
|
2013-01-10 16:47:31 +00:00
|
|
|
Name = getEnumNameForToken(Name);
|
2012-08-22 01:06:23 +00:00
|
|
|
|
|
|
|
bool IsNewConverter = false;
|
|
|
|
unsigned ID = getConverterOperandID(Name, OperandConversionKinds,
|
|
|
|
IsNewConverter);
|
|
|
|
|
|
|
|
// Add the operand entry to the instruction kind conversion row.
|
|
|
|
ConversionRow.push_back(ID);
|
|
|
|
ConversionRow.push_back(OpInfo.AsmOperandNum + 1);
|
|
|
|
|
|
|
|
if (!IsNewConverter)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// This is a new operand kind. Add a handler for it to the
|
|
|
|
// converter driver.
|
|
|
|
CvtOS << " case " << Name << ":\n"
|
|
|
|
<< " static_cast<" << TargetOperandClass
|
2014-06-08 16:18:35 +00:00
|
|
|
<< "&>(*Operands[*(p + 1)])." << Op.Class->RenderMethod
|
|
|
|
<< "(Inst, " << OpInfo.MINumOperands << ");\n"
|
2012-08-22 01:06:23 +00:00
|
|
|
<< " break;\n";
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
|
|
|
|
// Add a handler for the operand number lookup.
|
|
|
|
OpOS << " case " << Name << ":\n"
|
2013-01-15 23:07:53 +00:00
|
|
|
<< " Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);\n";
|
|
|
|
|
|
|
|
if (Op.Class->isRegisterClass())
|
|
|
|
OpOS << " Operands[*(p + 1)]->setConstraint(\"r\");\n";
|
|
|
|
else
|
|
|
|
OpOS << " Operands[*(p + 1)]->setConstraint(\"m\");\n";
|
|
|
|
OpOS << " NumMCOperands += " << OpInfo.MINumOperands << ";\n"
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
<< " break;\n";
|
2010-11-04 00:43:46 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MatchableInfo::ResOperand::TiedOperand: {
|
|
|
|
// If this operand is tied to a previous one, just copy the MCInst
|
|
|
|
// operand from the earlier one.We can only tie single MCOperand values.
|
Handle tied sub-operands in AsmMatcherEmitter
The problem this patch addresses is the handling of register tie
constraints in AsmMatcherEmitter, where one operand is tied to a
sub-operand of another operand. The typical scenario for this to
happen is the tie between the "write-back" register of a pre-inc
instruction, and the base register sub-operand of the memory address
operand of that instruction.
The current AsmMatcherEmitter code attempts to handle tied
operands by emitting the operand as usual first, and emitting
a CVT_Tied node when handling the second (tied) operand. However,
this really only works correctly if the tied operand does not
have sub-operands (and isn't a sub-operand itself). Under those
circumstances, a wrong MC operand list is generated.
In discussions with Jim Grosbach, it turned out that the MC operand
list really ought not to contain tied operands in the first place;
instead, it ought to consist of exactly those operands that are
named in the AsmString. However, getting there requires significant
rework of (some) targets.
This patch fixes the immediate problem, and at the same time makes
one (small) step in the direction of the long-term solution, by
implementing two changes:
1. Restricts the AsmMatcherEmitter handling of tied operands to
apply solely to simple operands (not complex operands or
sub-operand of such).
This means that at least we don't get silently corrupt MC operand
lists as output. However, if we do have tied sub-operands, they
would now no longer be handled at all, except for:
2. If we have an operand that does not occur in the AsmString,
and also isn't handled as tied operand, simply emit a dummy
MC operand (constant 0).
This works as long as target code never attempts to access
MC operands that do no not occur in the AsmString (and are
not tied simple operands), which happens to be the case for
all targets where this situation can occur (ARM and PowerPC).
[ Note that this change means that many of the ARM custom
converters are now superfluous, since the implement the
same "hack" now performed already by common code. ]
Longer term, we ought to fix targets to never access *any*
MC operand that does not occur in the AsmString (including
tied simple operands), and then finally completely remove
all such operands from the MC operand list.
Patch approved by Jim Grosbach.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180677 91177308-0d34-0410-b5e6-96231b3b80d8
2013-04-27 18:48:23 +00:00
|
|
|
assert(OpInfo.MINumOperands == 1 && "Not a singular MCOperand");
|
2010-11-04 00:43:46 +00:00
|
|
|
unsigned TiedOp = OpInfo.TiedOperandNum;
|
2011-04-15 05:18:47 +00:00
|
|
|
assert(i > TiedOp && "Tied operand precedes its target!");
|
2010-11-04 00:43:46 +00:00
|
|
|
Signature += "__Tie" + utostr(TiedOp);
|
2012-08-22 01:06:23 +00:00
|
|
|
ConversionRow.push_back(CVT_Tied);
|
|
|
|
ConversionRow.push_back(TiedOp);
|
2010-11-04 00:43:46 +00:00
|
|
|
break;
|
|
|
|
}
|
2010-11-06 19:25:43 +00:00
|
|
|
case MatchableInfo::ResOperand::ImmOperand: {
|
|
|
|
int64_t Val = OpInfo.ImmVal;
|
2012-08-22 01:06:23 +00:00
|
|
|
std::string Ty = "imm_" + itostr(Val);
|
2015-01-15 01:33:00 +00:00
|
|
|
Ty = getEnumNameForToken(Ty);
|
2012-08-22 01:06:23 +00:00
|
|
|
Signature += "__" + Ty;
|
|
|
|
|
|
|
|
std::string Name = "CVT_" + Ty;
|
|
|
|
bool IsNewConverter = false;
|
|
|
|
unsigned ID = getConverterOperandID(Name, OperandConversionKinds,
|
|
|
|
IsNewConverter);
|
|
|
|
// Add the operand entry to the instruction kind conversion row.
|
|
|
|
ConversionRow.push_back(ID);
|
|
|
|
ConversionRow.push_back(0);
|
|
|
|
|
|
|
|
if (!IsNewConverter)
|
|
|
|
break;
|
|
|
|
|
|
|
|
CvtOS << " case " << Name << ":\n"
|
|
|
|
<< " Inst.addOperand(MCOperand::CreateImm(" << Val << "));\n"
|
|
|
|
<< " break;\n";
|
|
|
|
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
OpOS << " case " << Name << ":\n"
|
2012-10-12 22:53:36 +00:00
|
|
|
<< " Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);\n"
|
|
|
|
<< " Operands[*(p + 1)]->setConstraint(\"\");\n"
|
2012-10-01 23:45:51 +00:00
|
|
|
<< " ++NumMCOperands;\n"
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
<< " break;\n";
|
2010-11-06 19:25:43 +00:00
|
|
|
break;
|
|
|
|
}
|
2010-11-06 19:57:21 +00:00
|
|
|
case MatchableInfo::ResOperand::RegOperand: {
|
2012-08-22 01:06:23 +00:00
|
|
|
std::string Reg, Name;
|
2014-04-15 07:20:03 +00:00
|
|
|
if (!OpInfo.Register) {
|
2012-08-22 01:06:23 +00:00
|
|
|
Name = "reg0";
|
|
|
|
Reg = "0";
|
2011-01-14 22:58:09 +00:00
|
|
|
} else {
|
2012-08-22 01:06:23 +00:00
|
|
|
Reg = getQualifiedName(OpInfo.Register);
|
|
|
|
Name = "reg" + OpInfo.Register->getName();
|
2011-01-14 22:58:09 +00:00
|
|
|
}
|
2012-08-22 01:06:23 +00:00
|
|
|
Signature += "__" + Name;
|
|
|
|
Name = "CVT_" + Name;
|
|
|
|
bool IsNewConverter = false;
|
|
|
|
unsigned ID = getConverterOperandID(Name, OperandConversionKinds,
|
|
|
|
IsNewConverter);
|
|
|
|
// Add the operand entry to the instruction kind conversion row.
|
|
|
|
ConversionRow.push_back(ID);
|
|
|
|
ConversionRow.push_back(0);
|
|
|
|
|
|
|
|
if (!IsNewConverter)
|
|
|
|
break;
|
|
|
|
CvtOS << " case " << Name << ":\n"
|
|
|
|
<< " Inst.addOperand(MCOperand::CreateReg(" << Reg << "));\n"
|
|
|
|
<< " break;\n";
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
|
|
|
|
OpOS << " case " << Name << ":\n"
|
2012-10-12 22:53:36 +00:00
|
|
|
<< " Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);\n"
|
|
|
|
<< " Operands[*(p + 1)]->setConstraint(\"m\");\n"
|
2012-10-01 23:45:51 +00:00
|
|
|
<< " ++NumMCOperands;\n"
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
<< " break;\n";
|
2011-01-26 21:26:19 +00:00
|
|
|
}
|
2010-02-10 08:15:48 +00:00
|
|
|
}
|
2010-11-02 22:55:03 +00:00
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
// If there were no operands, add to the signature to that effect
|
|
|
|
if (Signature == "Convert")
|
|
|
|
Signature += "_NoOperands";
|
|
|
|
|
2014-11-28 23:00:22 +00:00
|
|
|
II->ConversionFnKind = Signature;
|
2009-07-31 02:32:59 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
// Save the signature. If we already have it, don't add a new row
|
|
|
|
// to the table.
|
|
|
|
if (!InstructionConversionKinds.insert(Signature))
|
2009-08-07 08:26:05 +00:00
|
|
|
continue;
|
2009-07-31 02:32:59 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
// Add the row to the table.
|
|
|
|
ConversionTable.push_back(ConversionRow);
|
2009-07-31 02:32:59 +00:00
|
|
|
}
|
2009-08-08 05:24:34 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
// Finish up the converter driver function.
|
2012-09-03 17:39:57 +00:00
|
|
|
CvtOS << " }\n }\n}\n\n";
|
2009-08-08 05:24:34 +00:00
|
|
|
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
// Finish up the operand number lookup function.
|
2012-10-01 23:45:51 +00:00
|
|
|
OpOS << " }\n }\n}\n\n";
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
OS << "namespace {\n";
|
2009-08-08 05:24:34 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
// Output the operand conversion kind enum.
|
|
|
|
OS << "enum OperatorConversionKind {\n";
|
|
|
|
for (unsigned i = 0, e = OperandConversionKinds.size(); i != e; ++i)
|
|
|
|
OS << " " << OperandConversionKinds[i] << ",\n";
|
|
|
|
OS << " CVT_NUM_CONVERTERS\n";
|
|
|
|
OS << "};\n\n";
|
2009-08-08 05:24:34 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
// Output the instruction conversion kind enum.
|
|
|
|
OS << "enum InstructionConversionKind {\n";
|
|
|
|
for (SetVector<std::string>::const_iterator
|
|
|
|
i = InstructionConversionKinds.begin(),
|
|
|
|
e = InstructionConversionKinds.end(); i != e; ++i)
|
|
|
|
OS << " " << *i << ",\n";
|
|
|
|
OS << " CVT_NUM_SIGNATURES\n";
|
2009-08-08 05:24:34 +00:00
|
|
|
OS << "};\n\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2012-08-22 01:06:23 +00:00
|
|
|
|
|
|
|
OS << "} // end anonymous namespace\n\n";
|
|
|
|
|
|
|
|
// Output the conversion table.
|
2012-09-18 01:41:49 +00:00
|
|
|
OS << "static const uint8_t ConversionTable[CVT_NUM_SIGNATURES]["
|
2012-08-22 01:06:23 +00:00
|
|
|
<< MaxRowLength << "] = {\n";
|
|
|
|
|
|
|
|
for (unsigned Row = 0, ERow = ConversionTable.size(); Row != ERow; ++Row) {
|
|
|
|
assert(ConversionTable[Row].size() % 2 == 0 && "bad conversion row!");
|
|
|
|
OS << " // " << InstructionConversionKinds[Row] << "\n";
|
|
|
|
OS << " { ";
|
|
|
|
for (unsigned i = 0, e = ConversionTable[Row].size(); i != e; i += 2)
|
|
|
|
OS << OperandConversionKinds[ConversionTable[Row][i]] << ", "
|
|
|
|
<< (unsigned)(ConversionTable[Row][i + 1]) << ", ";
|
|
|
|
OS << "CVT_Done },\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
OS << "};\n\n";
|
|
|
|
|
|
|
|
// Spit out the conversion driver function.
|
2009-08-08 05:24:34 +00:00
|
|
|
OS << CvtOS.str();
|
2012-08-22 01:06:23 +00:00
|
|
|
|
[ms-inline asm] Add a new function, GetMCInstOperandNum, to the
AsmMatcherEmitter. This function maps inline assembly operands to MCInst
operands.
For example, '__asm mov j, eax' is represented by the follow MCInst:
<MCInst 1460 <MCOperand Reg:0> <MCOperand Imm:1> <MCOperand Reg:0>
<MCOperand Expr:(j)> <MCOperand Reg:0> <MCOperand Reg:43>>
The first 5 MCInst operands are a result of j matching as a memory operand
consisting of a BaseReg (Reg:0), MemScale (Imm:1), MemIndexReg(Reg:0),
Expr (Expr:(j), and a MemSegReg (Reg:0). The 6th MCInst operand represents
the eax register (Reg:43).
This translation is necessary to determine the Input and Output Exprs. If a
single asm operand maps to multiple MCInst operands, the index of the first
MCInst operand is returned. Ideally, it would return the operand we really
care out (i.e., the Expr:(j) in this case), but I haven't found an easy way
of doing this yet.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@162920 91177308-0d34-0410-b5e6-96231b3b80d8
2012-08-30 17:59:25 +00:00
|
|
|
// Spit out the operand number lookup function.
|
|
|
|
OS << OpOS.str();
|
2009-08-07 08:26:05 +00:00
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// emitMatchClassEnumeration - Emit the enumeration for match class kinds.
|
|
|
|
static void emitMatchClassEnumeration(CodeGenTarget &Target,
|
2014-11-28 20:35:57 +00:00
|
|
|
std::forward_list<ClassInfo> &Infos,
|
|
|
|
raw_ostream &OS) {
|
2009-08-08 07:50:56 +00:00
|
|
|
OS << "namespace {\n\n";
|
|
|
|
|
|
|
|
OS << "/// MatchClassKind - The kinds of classes which participate in\n"
|
|
|
|
<< "/// instruction matching.\n";
|
|
|
|
OS << "enum MatchClassKind {\n";
|
|
|
|
OS << " InvalidMatchClass = 0,\n";
|
2014-11-28 03:53:02 +00:00
|
|
|
for (const auto &CI : Infos) {
|
2014-11-28 20:35:57 +00:00
|
|
|
OS << " " << CI.Name << ", // ";
|
|
|
|
if (CI.Kind == ClassInfo::Token) {
|
|
|
|
OS << "'" << CI.ValueName << "'\n";
|
|
|
|
} else if (CI.isRegisterClass()) {
|
|
|
|
if (!CI.ValueName.empty())
|
|
|
|
OS << "register class '" << CI.ValueName << "'\n";
|
2009-08-08 07:50:56 +00:00
|
|
|
else
|
|
|
|
OS << "derived register class\n";
|
|
|
|
} else {
|
2014-11-28 20:35:57 +00:00
|
|
|
OS << "user defined class '" << CI.ValueName << "'\n";
|
2009-08-08 07:50:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
OS << " NumMatchClassKinds\n";
|
|
|
|
OS << "};\n\n";
|
|
|
|
|
|
|
|
OS << "}\n\n";
|
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// emitValidateOperandClass - Emit the function to validate an operand class.
|
|
|
|
static void emitValidateOperandClass(AsmMatcherInfo &Info,
|
2011-02-10 00:08:28 +00:00
|
|
|
raw_ostream &OS) {
|
2014-06-08 16:18:35 +00:00
|
|
|
OS << "static unsigned validateOperandClass(MCParsedAsmOperand &GOp, "
|
2011-02-10 00:08:28 +00:00
|
|
|
<< "MatchClassKind Kind) {\n";
|
2014-06-08 16:18:35 +00:00
|
|
|
OS << " " << Info.Target.getName() << "Operand &Operand = ("
|
|
|
|
<< Info.Target.getName() << "Operand&)GOp;\n";
|
2009-08-11 02:59:53 +00:00
|
|
|
|
2011-07-15 18:30:43 +00:00
|
|
|
// The InvalidMatchClass is not to match any operand.
|
|
|
|
OS << " if (Kind == InvalidMatchClass)\n";
|
2012-06-22 23:56:44 +00:00
|
|
|
OS << " return MCTargetAsmParser::Match_InvalidOperand;\n\n";
|
2011-07-15 18:30:43 +00:00
|
|
|
|
2011-02-10 00:08:28 +00:00
|
|
|
// Check for Token operands first.
|
2012-06-22 23:56:44 +00:00
|
|
|
// FIXME: Use a more specific diagnostic type.
|
2009-08-08 07:50:56 +00:00
|
|
|
OS << " if (Operand.isToken())\n";
|
2012-06-22 23:56:44 +00:00
|
|
|
OS << " return isSubclass(matchTokenString(Operand.getToken()), Kind) ?\n"
|
|
|
|
<< " MCTargetAsmParser::Match_Success :\n"
|
|
|
|
<< " MCTargetAsmParser::Match_InvalidOperand;\n\n";
|
2009-08-11 02:59:53 +00:00
|
|
|
|
2011-02-10 00:08:28 +00:00
|
|
|
// Check the user classes. We don't care what order since we're only
|
|
|
|
// actually matching against one of them.
|
2014-11-28 03:53:02 +00:00
|
|
|
for (const auto &CI : Info.Classes) {
|
2014-11-28 20:35:57 +00:00
|
|
|
if (!CI.isUserClass())
|
2009-08-11 02:59:53 +00:00
|
|
|
continue;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2014-11-28 20:35:57 +00:00
|
|
|
OS << " // '" << CI.ClassName << "' class\n";
|
|
|
|
OS << " if (Kind == " << CI.Name << ") {\n";
|
|
|
|
OS << " if (Operand." << CI.PredicateMethod << "())\n";
|
2012-06-22 23:56:44 +00:00
|
|
|
OS << " return MCTargetAsmParser::Match_Success;\n";
|
2014-11-28 20:35:57 +00:00
|
|
|
if (!CI.DiagnosticType.empty())
|
2012-06-22 23:56:44 +00:00
|
|
|
OS << " return " << Info.Target.getName() << "AsmParser::Match_"
|
2014-11-28 20:35:57 +00:00
|
|
|
<< CI.DiagnosticType << ";\n";
|
2009-08-11 02:59:53 +00:00
|
|
|
OS << " }\n\n";
|
2009-08-08 07:50:56 +00:00
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-07-16 23:20:09 +00:00
|
|
|
// Check for register operands, including sub-classes.
|
|
|
|
OS << " if (Operand.isReg()) {\n";
|
|
|
|
OS << " MatchClassKind OpKind;\n";
|
|
|
|
OS << " switch (Operand.getReg()) {\n";
|
|
|
|
OS << " default: OpKind = InvalidMatchClass; break;\n";
|
2014-11-25 20:11:31 +00:00
|
|
|
for (const auto &RC : Info.RegisterClasses)
|
2012-07-16 23:20:09 +00:00
|
|
|
OS << " case " << Info.Target.getName() << "::"
|
2014-11-25 20:11:31 +00:00
|
|
|
<< RC.first->getName() << ": OpKind = " << RC.second->Name
|
2012-07-16 23:20:09 +00:00
|
|
|
<< "; break;\n";
|
|
|
|
OS << " }\n";
|
|
|
|
OS << " return isSubclass(OpKind, Kind) ? "
|
|
|
|
<< "MCTargetAsmParser::Match_Success :\n "
|
|
|
|
<< " MCTargetAsmParser::Match_InvalidOperand;\n }\n\n";
|
|
|
|
|
2012-06-22 23:56:44 +00:00
|
|
|
// Generic fallthrough match failure case for operands that don't have
|
|
|
|
// specialized diagnostic types.
|
|
|
|
OS << " return MCTargetAsmParser::Match_InvalidOperand;\n";
|
2009-08-08 07:50:56 +00:00
|
|
|
OS << "}\n\n";
|
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// emitIsSubclass - Emit the subclass predicate function.
|
|
|
|
static void emitIsSubclass(CodeGenTarget &Target,
|
2014-11-28 20:35:57 +00:00
|
|
|
std::forward_list<ClassInfo> &Infos,
|
2009-08-10 16:05:47 +00:00
|
|
|
raw_ostream &OS) {
|
2012-09-15 20:22:05 +00:00
|
|
|
OS << "/// isSubclass - Compute whether \\p A is a subclass of \\p B.\n";
|
2011-12-06 22:07:02 +00:00
|
|
|
OS << "static bool isSubclass(MatchClassKind A, MatchClassKind B) {\n";
|
2009-08-10 16:05:47 +00:00
|
|
|
OS << " if (A == B)\n";
|
|
|
|
OS << " return true;\n\n";
|
|
|
|
|
2013-08-06 22:51:21 +00:00
|
|
|
std::string OStr;
|
|
|
|
raw_string_ostream SS(OStr);
|
2013-07-15 16:53:32 +00:00
|
|
|
unsigned Count = 0;
|
|
|
|
SS << " switch (A) {\n";
|
|
|
|
SS << " default:\n";
|
|
|
|
SS << " return false;\n";
|
2014-11-28 03:53:02 +00:00
|
|
|
for (const auto &A : Infos) {
|
2011-12-06 23:43:54 +00:00
|
|
|
std::vector<StringRef> SuperClasses;
|
2014-11-28 03:53:02 +00:00
|
|
|
for (const auto &B : Infos) {
|
2014-11-28 20:35:57 +00:00
|
|
|
if (&A != &B && A.isSubsetOf(B))
|
|
|
|
SuperClasses.push_back(B.Name);
|
2011-12-06 23:43:54 +00:00
|
|
|
}
|
2009-08-10 16:05:47 +00:00
|
|
|
|
2011-12-06 23:43:54 +00:00
|
|
|
if (SuperClasses.empty())
|
|
|
|
continue;
|
2013-07-15 16:53:32 +00:00
|
|
|
++Count;
|
2009-08-10 16:05:47 +00:00
|
|
|
|
2014-11-28 20:35:57 +00:00
|
|
|
SS << "\n case " << A.Name << ":\n";
|
2009-08-10 16:05:47 +00:00
|
|
|
|
2011-12-06 23:43:54 +00:00
|
|
|
if (SuperClasses.size() == 1) {
|
2013-07-15 16:53:32 +00:00
|
|
|
SS << " return B == " << SuperClasses.back().str() << ";\n";
|
2011-12-06 23:43:54 +00:00
|
|
|
continue;
|
2009-08-10 16:05:47 +00:00
|
|
|
}
|
2011-12-06 23:43:54 +00:00
|
|
|
|
2013-07-15 16:53:32 +00:00
|
|
|
if (!SuperClasses.empty()) {
|
|
|
|
SS << " switch (B) {\n";
|
|
|
|
SS << " default: return false;\n";
|
|
|
|
for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
|
|
|
|
SS << " case " << SuperClasses[i].str() << ": return true;\n";
|
|
|
|
SS << " }\n";
|
|
|
|
} else {
|
|
|
|
// No case statement to emit
|
|
|
|
SS << " return false;\n";
|
|
|
|
}
|
2009-08-10 16:05:47 +00:00
|
|
|
}
|
2013-07-15 16:53:32 +00:00
|
|
|
SS << " }\n";
|
|
|
|
|
|
|
|
// If there were case statements emitted into the string stream, write them
|
|
|
|
// to the output stream, otherwise write the default.
|
|
|
|
if (Count)
|
|
|
|
OS << SS.str();
|
|
|
|
else
|
|
|
|
OS << " return false;\n";
|
|
|
|
|
2009-08-10 16:05:47 +00:00
|
|
|
OS << "}\n\n";
|
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// emitMatchTokenString - Emit the function to match a token string to the
|
2009-08-08 21:22:41 +00:00
|
|
|
/// appropriate match class value.
|
2012-04-19 17:52:32 +00:00
|
|
|
static void emitMatchTokenString(CodeGenTarget &Target,
|
2014-11-28 20:35:57 +00:00
|
|
|
std::forward_list<ClassInfo> &Infos,
|
2009-08-08 21:22:41 +00:00
|
|
|
raw_ostream &OS) {
|
|
|
|
// Construct the match list.
|
2010-09-06 02:01:51 +00:00
|
|
|
std::vector<StringMatcher::StringPair> Matches;
|
2014-11-28 03:53:02 +00:00
|
|
|
for (const auto &CI : Infos) {
|
2014-11-28 20:35:57 +00:00
|
|
|
if (CI.Kind == ClassInfo::Token)
|
2014-11-28 21:20:22 +00:00
|
|
|
Matches.push_back(
|
|
|
|
StringMatcher::StringPair(CI.ValueName, "return " + CI.Name + ";"));
|
2009-08-08 21:22:41 +00:00
|
|
|
}
|
|
|
|
|
2011-12-06 22:07:02 +00:00
|
|
|
OS << "static MatchClassKind matchTokenString(StringRef Name) {\n";
|
2009-08-08 21:22:41 +00:00
|
|
|
|
2010-09-06 02:01:51 +00:00
|
|
|
StringMatcher("Name", Matches, OS).Emit();
|
2009-08-08 21:22:41 +00:00
|
|
|
|
|
|
|
OS << " return InvalidMatchClass;\n";
|
|
|
|
OS << "}\n\n";
|
|
|
|
}
|
2009-08-08 20:02:57 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// emitMatchRegisterName - Emit the function to match a string to the target
|
2009-08-07 21:01:44 +00:00
|
|
|
/// specific register enum.
|
2012-04-19 17:52:32 +00:00
|
|
|
static void emitMatchRegisterName(CodeGenTarget &Target, Record *AsmParser,
|
2009-08-07 21:01:44 +00:00
|
|
|
raw_ostream &OS) {
|
2009-08-08 21:22:41 +00:00
|
|
|
// Construct the match list.
|
2010-09-06 02:01:51 +00:00
|
|
|
std::vector<StringMatcher::StringPair> Matches;
|
2014-11-29 18:13:39 +00:00
|
|
|
const auto &Regs = Target.getRegBank().getRegisters();
|
|
|
|
for (const CodeGenRegister &Reg : Regs) {
|
|
|
|
if (Reg.TheDef->getValueAsString("AsmName").empty())
|
2009-08-07 08:26:05 +00:00
|
|
|
continue;
|
|
|
|
|
2014-11-29 18:13:39 +00:00
|
|
|
Matches.push_back(
|
|
|
|
StringMatcher::StringPair(Reg.TheDef->getValueAsString("AsmName"),
|
|
|
|
"return " + utostr(Reg.EnumValue) + ";"));
|
2009-08-07 08:26:05 +00:00
|
|
|
}
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2010-02-09 00:34:28 +00:00
|
|
|
OS << "static unsigned MatchRegisterName(StringRef Name) {\n";
|
2009-08-08 21:22:41 +00:00
|
|
|
|
2010-09-06 02:01:51 +00:00
|
|
|
StringMatcher("Name", Matches, OS).Emit();
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2009-08-08 21:22:41 +00:00
|
|
|
OS << " return 0;\n";
|
2009-08-07 08:26:05 +00:00
|
|
|
OS << "}\n\n";
|
2009-08-07 21:01:44 +00:00
|
|
|
}
|
|
|
|
|
2014-05-21 10:11:24 +00:00
|
|
|
static const char *getMinimalTypeForRange(uint64_t Range) {
|
2014-08-18 11:49:42 +00:00
|
|
|
assert(Range <= 0xFFFFFFFFFFFFFFFFULL && "Enum too large");
|
|
|
|
if (Range > 0xFFFFFFFFULL)
|
|
|
|
return "uint64_t";
|
2014-05-21 10:11:24 +00:00
|
|
|
if (Range > 0xFFFF)
|
|
|
|
return "uint32_t";
|
|
|
|
if (Range > 0xFF)
|
|
|
|
return "uint16_t";
|
|
|
|
return "uint8_t";
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *getMinimalRequiredFeaturesType(const AsmMatcherInfo &Info) {
|
|
|
|
uint64_t MaxIndex = Info.SubtargetFeatures.size();
|
|
|
|
if (MaxIndex > 0)
|
|
|
|
MaxIndex--;
|
|
|
|
return getMinimalTypeForRange(1ULL << MaxIndex);
|
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// emitSubtargetFeatureFlagEnumeration - Emit the subtarget feature flag
|
2010-07-19 05:44:09 +00:00
|
|
|
/// definitions.
|
2012-04-19 17:52:32 +00:00
|
|
|
static void emitSubtargetFeatureFlagEnumeration(AsmMatcherInfo &Info,
|
2010-07-19 05:44:09 +00:00
|
|
|
raw_ostream &OS) {
|
|
|
|
OS << "// Flags for subtarget features that participate in "
|
|
|
|
<< "instruction matching.\n";
|
2014-05-21 10:11:24 +00:00
|
|
|
OS << "enum SubtargetFeatureFlag : " << getMinimalRequiredFeaturesType(Info)
|
|
|
|
<< " {\n";
|
2014-11-28 03:53:00 +00:00
|
|
|
for (const auto &SF : Info.SubtargetFeatures) {
|
2014-11-28 22:15:06 +00:00
|
|
|
const SubtargetFeatureInfo &SFI = SF.second;
|
2014-08-18 11:49:42 +00:00
|
|
|
OS << " " << SFI.getEnumName() << " = (1ULL << " << SFI.Index << "),\n";
|
2010-07-19 05:44:09 +00:00
|
|
|
}
|
|
|
|
OS << " Feature_None = 0\n";
|
|
|
|
OS << "};\n\n";
|
|
|
|
}
|
|
|
|
|
2012-06-22 23:56:44 +00:00
|
|
|
/// emitOperandDiagnosticTypes - Emit the operand matching diagnostic types.
|
|
|
|
static void emitOperandDiagnosticTypes(AsmMatcherInfo &Info, raw_ostream &OS) {
|
|
|
|
// Get the set of diagnostic types from all of the operand classes.
|
|
|
|
std::set<StringRef> Types;
|
|
|
|
for (std::map<Record*, ClassInfo*>::const_iterator
|
|
|
|
I = Info.AsmOperandClasses.begin(),
|
|
|
|
E = Info.AsmOperandClasses.end(); I != E; ++I) {
|
|
|
|
if (!I->second->DiagnosticType.empty())
|
|
|
|
Types.insert(I->second->DiagnosticType);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Types.empty()) return;
|
|
|
|
|
|
|
|
// Now emit the enum entries.
|
|
|
|
for (std::set<StringRef>::const_iterator I = Types.begin(), E = Types.end();
|
|
|
|
I != E; ++I)
|
|
|
|
OS << " Match_" << *I << ",\n";
|
|
|
|
OS << " END_OPERAND_DIAGNOSTIC_TYPES\n";
|
|
|
|
}
|
|
|
|
|
2012-04-24 22:40:08 +00:00
|
|
|
/// emitGetSubtargetFeatureName - Emit the helper function to get the
|
|
|
|
/// user-level name for a subtarget feature.
|
|
|
|
static void emitGetSubtargetFeatureName(AsmMatcherInfo &Info, raw_ostream &OS) {
|
|
|
|
OS << "// User-level names for subtarget features that participate in\n"
|
|
|
|
<< "// instruction matching.\n"
|
2014-08-18 11:49:42 +00:00
|
|
|
<< "static const char *getSubtargetFeatureName(uint64_t Val) {\n";
|
2013-07-15 16:53:32 +00:00
|
|
|
if (!Info.SubtargetFeatures.empty()) {
|
|
|
|
OS << " switch(Val) {\n";
|
2014-11-28 03:53:00 +00:00
|
|
|
for (const auto &SF : Info.SubtargetFeatures) {
|
2014-11-28 22:15:06 +00:00
|
|
|
const SubtargetFeatureInfo &SFI = SF.second;
|
2013-07-15 16:53:32 +00:00
|
|
|
// FIXME: Totally just a placeholder name to get the algorithm working.
|
|
|
|
OS << " case " << SFI.getEnumName() << ": return \""
|
|
|
|
<< SFI.TheDef->getValueAsString("PredicateName") << "\";\n";
|
|
|
|
}
|
|
|
|
OS << " default: return \"(unknown)\";\n";
|
|
|
|
OS << " }\n";
|
|
|
|
} else {
|
|
|
|
// Nothing to emit, so skip the switch
|
|
|
|
OS << " return \"(unknown)\";\n";
|
2012-04-24 22:40:08 +00:00
|
|
|
}
|
2013-07-15 16:53:32 +00:00
|
|
|
OS << "}\n\n";
|
2012-04-24 22:40:08 +00:00
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
/// emitComputeAvailableFeatures - Emit the function to compute the list of
|
2010-07-19 05:44:09 +00:00
|
|
|
/// available features given a subtarget.
|
2012-04-19 17:52:32 +00:00
|
|
|
static void emitComputeAvailableFeatures(AsmMatcherInfo &Info,
|
2010-07-19 05:44:09 +00:00
|
|
|
raw_ostream &OS) {
|
|
|
|
std::string ClassName =
|
|
|
|
Info.AsmParser->getValueAsString("AsmParserClassName");
|
|
|
|
|
2014-08-18 11:49:42 +00:00
|
|
|
OS << "uint64_t " << Info.Target.getName() << ClassName << "::\n"
|
2015-02-19 11:38:11 +00:00
|
|
|
<< "ComputeAvailableFeatures(uint64_t FB) const {\n";
|
2014-08-18 11:49:42 +00:00
|
|
|
OS << " uint64_t Features = 0;\n";
|
2014-11-28 03:53:00 +00:00
|
|
|
for (const auto &SF : Info.SubtargetFeatures) {
|
2014-11-28 22:15:06 +00:00
|
|
|
const SubtargetFeatureInfo &SFI = SF.second;
|
2011-07-08 01:53:10 +00:00
|
|
|
|
|
|
|
OS << " if (";
|
2012-04-17 00:01:04 +00:00
|
|
|
std::string CondStorage =
|
|
|
|
SFI.TheDef->getValueAsString("AssemblerCondString");
|
2011-07-08 18:04:22 +00:00
|
|
|
StringRef Conds = CondStorage;
|
2011-07-08 01:53:10 +00:00
|
|
|
std::pair<StringRef,StringRef> Comma = Conds.split(',');
|
|
|
|
bool First = true;
|
|
|
|
do {
|
|
|
|
if (!First)
|
|
|
|
OS << " && ";
|
|
|
|
|
|
|
|
bool Neg = false;
|
|
|
|
StringRef Cond = Comma.first;
|
|
|
|
if (Cond[0] == '!') {
|
|
|
|
Neg = true;
|
|
|
|
Cond = Cond.substr(1);
|
|
|
|
}
|
|
|
|
|
2015-02-19 11:38:11 +00:00
|
|
|
OS << "((FB & " << Info.Target.getName() << "::" << Cond << ")";
|
2011-07-08 01:53:10 +00:00
|
|
|
if (Neg)
|
2015-02-19 11:38:11 +00:00
|
|
|
OS << " == 0";
|
|
|
|
else
|
|
|
|
OS << " != 0";
|
|
|
|
OS << ")";
|
2011-07-08 01:53:10 +00:00
|
|
|
|
|
|
|
if (Comma.second.empty())
|
|
|
|
break;
|
|
|
|
|
|
|
|
First = false;
|
|
|
|
Comma = Comma.second.split(',');
|
|
|
|
} while (true);
|
|
|
|
|
|
|
|
OS << ")\n";
|
2010-10-30 20:07:57 +00:00
|
|
|
OS << " Features |= " << SFI.getEnumName() << ";\n";
|
2010-07-19 05:44:09 +00:00
|
|
|
}
|
|
|
|
OS << " return Features;\n";
|
|
|
|
OS << "}\n\n";
|
|
|
|
}
|
|
|
|
|
2010-10-30 20:15:02 +00:00
|
|
|
static std::string GetAliasRequiredFeatures(Record *R,
|
|
|
|
const AsmMatcherInfo &Info) {
|
2010-10-30 19:23:13 +00:00
|
|
|
std::vector<Record*> ReqFeatures = R->getValueAsListOfDefs("Predicates");
|
|
|
|
std::string Result;
|
|
|
|
unsigned NumFeatures = 0;
|
|
|
|
for (unsigned i = 0, e = ReqFeatures.size(); i != e; ++i) {
|
2014-11-28 22:15:06 +00:00
|
|
|
const SubtargetFeatureInfo *F = Info.getSubtargetFeature(ReqFeatures[i]);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2014-04-15 07:20:03 +00:00
|
|
|
if (!F)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(R->getLoc(), "Predicate '" + ReqFeatures[i]->getName() +
|
2010-11-01 02:09:21 +00:00
|
|
|
"' is not marked as an AssemblerPredicate!");
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 02:09:21 +00:00
|
|
|
if (NumFeatures)
|
|
|
|
Result += '|';
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-11-01 02:09:21 +00:00
|
|
|
Result += F->getEnumName();
|
|
|
|
++NumFeatures;
|
2010-10-30 19:23:13 +00:00
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-10-30 19:23:13 +00:00
|
|
|
if (NumFeatures > 1)
|
|
|
|
Result = '(' + Result + ')';
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2013-04-18 22:35:36 +00:00
|
|
|
static void emitMnemonicAliasVariant(raw_ostream &OS,const AsmMatcherInfo &Info,
|
|
|
|
std::vector<Record*> &Aliases,
|
|
|
|
unsigned Indent = 0,
|
|
|
|
StringRef AsmParserVariantName = StringRef()){
|
2010-10-30 18:56:12 +00:00
|
|
|
// Keep track of all the aliases from a mnemonic. Use an std::map so that the
|
|
|
|
// iteration order of the map is stable.
|
|
|
|
std::map<std::string, std::vector<Record*> > AliasesFromMnemonic;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-10-30 17:36:36 +00:00
|
|
|
for (unsigned i = 0, e = Aliases.size(); i != e; ++i) {
|
|
|
|
Record *R = Aliases[i];
|
2013-04-18 22:35:36 +00:00
|
|
|
// FIXME: Allow AssemblerVariantName to be a comma separated list.
|
|
|
|
std::string AsmVariantName = R->getValueAsString("AsmVariantName");
|
|
|
|
if (AsmVariantName != AsmParserVariantName)
|
|
|
|
continue;
|
2010-10-30 18:56:12 +00:00
|
|
|
AliasesFromMnemonic[R->getValueAsString("FromMnemonic")].push_back(R);
|
|
|
|
}
|
2013-04-18 22:35:36 +00:00
|
|
|
if (AliasesFromMnemonic.empty())
|
|
|
|
return;
|
2013-07-16 09:22:38 +00:00
|
|
|
|
2010-10-30 18:56:12 +00:00
|
|
|
// Process each alias a "from" mnemonic at a time, building the code executed
|
|
|
|
// by the string remapper.
|
|
|
|
std::vector<StringMatcher::StringPair> Cases;
|
|
|
|
for (std::map<std::string, std::vector<Record*> >::iterator
|
|
|
|
I = AliasesFromMnemonic.begin(), E = AliasesFromMnemonic.end();
|
|
|
|
I != E; ++I) {
|
|
|
|
const std::vector<Record*> &ToVec = I->second;
|
2010-10-30 19:23:13 +00:00
|
|
|
|
|
|
|
// Loop through each alias and emit code that handles each case. If there
|
|
|
|
// are two instructions without predicates, emit an error. If there is one,
|
|
|
|
// emit it last.
|
|
|
|
std::string MatchCode;
|
|
|
|
int AliasWithNoPredicate = -1;
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-10-30 19:23:13 +00:00
|
|
|
for (unsigned i = 0, e = ToVec.size(); i != e; ++i) {
|
|
|
|
Record *R = ToVec[i];
|
2010-10-30 20:15:02 +00:00
|
|
|
std::string FeatureMask = GetAliasRequiredFeatures(R, Info);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-10-30 19:23:13 +00:00
|
|
|
// If this unconditionally matches, remember it for later and diagnose
|
|
|
|
// duplicates.
|
|
|
|
if (FeatureMask.empty()) {
|
|
|
|
if (AliasWithNoPredicate != -1) {
|
|
|
|
// We can't have two aliases from the same mnemonic with no predicate.
|
|
|
|
PrintError(ToVec[AliasWithNoPredicate]->getLoc(),
|
|
|
|
"two MnemonicAliases with the same 'from' mnemonic!");
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(R->getLoc(), "this is the other MnemonicAlias.");
|
2010-10-30 19:23:13 +00:00
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-10-30 19:23:13 +00:00
|
|
|
AliasWithNoPredicate = i;
|
|
|
|
continue;
|
|
|
|
}
|
2011-02-17 23:22:19 +00:00
|
|
|
if (R->getValueAsString("ToMnemonic") == I->first)
|
2012-10-25 20:33:17 +00:00
|
|
|
PrintFatalError(R->getLoc(), "MnemonicAlias to the same string");
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-10-30 19:47:49 +00:00
|
|
|
if (!MatchCode.empty())
|
|
|
|
MatchCode += "else ";
|
2010-10-30 19:23:13 +00:00
|
|
|
MatchCode += "if ((Features & " + FeatureMask + ") == "+FeatureMask+")\n";
|
|
|
|
MatchCode += " Mnemonic = \"" +R->getValueAsString("ToMnemonic")+"\";\n";
|
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-10-30 19:23:13 +00:00
|
|
|
if (AliasWithNoPredicate != -1) {
|
|
|
|
Record *R = ToVec[AliasWithNoPredicate];
|
2010-10-30 19:47:49 +00:00
|
|
|
if (!MatchCode.empty())
|
|
|
|
MatchCode += "else\n ";
|
|
|
|
MatchCode += "Mnemonic = \"" + R->getValueAsString("ToMnemonic")+"\";\n";
|
2010-10-30 18:56:12 +00:00
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-10-30 19:23:13 +00:00
|
|
|
MatchCode += "return;";
|
|
|
|
|
|
|
|
Cases.push_back(std::make_pair(I->first, MatchCode));
|
2010-10-30 17:36:36 +00:00
|
|
|
}
|
2013-04-18 22:35:36 +00:00
|
|
|
StringMatcher("Mnemonic", Cases, OS).Emit(Indent);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// emitMnemonicAliases - If the target has any MnemonicAlias<> definitions,
|
|
|
|
/// emit a function for them and return true, otherwise return false.
|
|
|
|
static bool emitMnemonicAliases(raw_ostream &OS, const AsmMatcherInfo &Info,
|
|
|
|
CodeGenTarget &Target) {
|
|
|
|
// Ignore aliases when match-prefix is set.
|
|
|
|
if (!MatchPrefix.empty())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
std::vector<Record*> Aliases =
|
|
|
|
Info.getRecords().getAllDerivedDefinitions("MnemonicAlias");
|
|
|
|
if (Aliases.empty()) return false;
|
|
|
|
|
|
|
|
OS << "static void applyMnemonicAliases(StringRef &Mnemonic, "
|
2014-08-18 11:49:42 +00:00
|
|
|
"uint64_t Features, unsigned VariantID) {\n";
|
2013-04-18 22:35:36 +00:00
|
|
|
OS << " switch (VariantID) {\n";
|
|
|
|
unsigned VariantCount = Target.getAsmParserVariantCount();
|
|
|
|
for (unsigned VC = 0; VC != VariantCount; ++VC) {
|
|
|
|
Record *AsmVariant = Target.getAsmParserVariant(VC);
|
|
|
|
int AsmParserVariantNo = AsmVariant->getValueAsInt("Variant");
|
|
|
|
std::string AsmParserVariantName = AsmVariant->getValueAsString("Name");
|
|
|
|
OS << " case " << AsmParserVariantNo << ":\n";
|
|
|
|
emitMnemonicAliasVariant(OS, Info, Aliases, /*Indent=*/2,
|
|
|
|
AsmParserVariantName);
|
|
|
|
OS << " break;\n";
|
|
|
|
}
|
|
|
|
OS << " }\n";
|
|
|
|
|
|
|
|
// Emit aliases that apply to all variants.
|
|
|
|
emitMnemonicAliasVariant(OS, Info, Aliases);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2011-01-18 01:59:30 +00:00
|
|
|
OS << "}\n\n";
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2010-10-30 18:48:18 +00:00
|
|
|
return true;
|
2010-10-30 17:36:36 +00:00
|
|
|
}
|
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
static void emitCustomOperandParsing(raw_ostream &OS, CodeGenTarget &Target,
|
2012-09-18 07:02:21 +00:00
|
|
|
const AsmMatcherInfo &Info, StringRef ClassName,
|
|
|
|
StringToOffsetTable &StringTable,
|
|
|
|
unsigned MaxMnemonicIndex) {
|
|
|
|
unsigned MaxMask = 0;
|
|
|
|
for (std::vector<OperandMatchEntry>::const_iterator it =
|
|
|
|
Info.OperandMatchInfo.begin(), ie = Info.OperandMatchInfo.end();
|
|
|
|
it != ie; ++it) {
|
|
|
|
MaxMask |= it->OperandMask;
|
|
|
|
}
|
|
|
|
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
// Emit the static custom operand parsing table;
|
|
|
|
OS << "namespace {\n";
|
|
|
|
OS << " struct OperandMatchEntry {\n";
|
2014-05-21 10:11:24 +00:00
|
|
|
OS << " " << getMinimalRequiredFeaturesType(Info)
|
2012-04-02 07:48:39 +00:00
|
|
|
<< " RequiredFeatures;\n";
|
2012-09-18 07:02:21 +00:00
|
|
|
OS << " " << getMinimalTypeForRange(MaxMnemonicIndex)
|
|
|
|
<< " Mnemonic;\n";
|
2014-11-28 20:35:57 +00:00
|
|
|
OS << " " << getMinimalTypeForRange(std::distance(
|
|
|
|
Info.Classes.begin(), Info.Classes.end())) << " Class;\n";
|
2012-09-18 07:02:21 +00:00
|
|
|
OS << " " << getMinimalTypeForRange(MaxMask)
|
|
|
|
<< " OperandMask;\n\n";
|
2012-03-03 20:44:43 +00:00
|
|
|
OS << " StringRef getMnemonic() const {\n";
|
|
|
|
OS << " return StringRef(MnemonicTable + Mnemonic + 1,\n";
|
|
|
|
OS << " MnemonicTable[Mnemonic]);\n";
|
|
|
|
OS << " }\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << " };\n\n";
|
|
|
|
|
|
|
|
OS << " // Predicate for searching for an opcode.\n";
|
|
|
|
OS << " struct LessOpcodeOperand {\n";
|
|
|
|
OS << " bool operator()(const OperandMatchEntry &LHS, StringRef RHS) {\n";
|
2012-03-03 20:44:43 +00:00
|
|
|
OS << " return LHS.getMnemonic() < RHS;\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << " }\n";
|
|
|
|
OS << " bool operator()(StringRef LHS, const OperandMatchEntry &RHS) {\n";
|
2012-03-03 20:44:43 +00:00
|
|
|
OS << " return LHS < RHS.getMnemonic();\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << " }\n";
|
|
|
|
OS << " bool operator()(const OperandMatchEntry &LHS,";
|
|
|
|
OS << " const OperandMatchEntry &RHS) {\n";
|
2012-03-03 20:44:43 +00:00
|
|
|
OS << " return LHS.getMnemonic() < RHS.getMnemonic();\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << " }\n";
|
|
|
|
OS << " };\n";
|
|
|
|
|
|
|
|
OS << "} // end anonymous namespace.\n\n";
|
|
|
|
|
|
|
|
OS << "static const OperandMatchEntry OperandMatchTable["
|
|
|
|
<< Info.OperandMatchInfo.size() << "] = {\n";
|
|
|
|
|
2012-03-03 20:44:43 +00:00
|
|
|
OS << " /* Operand List Mask, Mnemonic, Operand Class, Features */\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
for (std::vector<OperandMatchEntry>::const_iterator it =
|
|
|
|
Info.OperandMatchInfo.begin(), ie = Info.OperandMatchInfo.end();
|
|
|
|
it != ie; ++it) {
|
|
|
|
const OperandMatchEntry &OMI = *it;
|
|
|
|
const MatchableInfo &II = *OMI.MI;
|
|
|
|
|
2012-09-18 07:02:21 +00:00
|
|
|
OS << " { ";
|
|
|
|
|
|
|
|
// Write the required features mask.
|
|
|
|
if (!II.RequiredFeatures.empty()) {
|
|
|
|
for (unsigned i = 0, e = II.RequiredFeatures.size(); i != e; ++i) {
|
|
|
|
if (i) OS << "|";
|
|
|
|
OS << II.RequiredFeatures[i]->getEnumName();
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
OS << "0";
|
|
|
|
|
|
|
|
// Store a pascal-style length byte in the mnemonic.
|
|
|
|
std::string LenMnemonic = char(II.Mnemonic.size()) + II.Mnemonic.str();
|
|
|
|
OS << ", " << StringTable.GetOrAddStringOffset(LenMnemonic, false)
|
|
|
|
<< " /* " << II.Mnemonic << " */, ";
|
|
|
|
|
|
|
|
OS << OMI.CI->Name;
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
2012-09-18 07:02:21 +00:00
|
|
|
OS << ", " << OMI.OperandMask;
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << " /* ";
|
|
|
|
bool printComma = false;
|
|
|
|
for (int i = 0, e = 31; i !=e; ++i)
|
|
|
|
if (OMI.OperandMask & (1 << i)) {
|
|
|
|
if (printComma)
|
|
|
|
OS << ", ";
|
|
|
|
OS << i;
|
|
|
|
printComma = true;
|
|
|
|
}
|
|
|
|
OS << " */";
|
|
|
|
|
|
|
|
OS << " },\n";
|
|
|
|
}
|
|
|
|
OS << "};\n\n";
|
|
|
|
|
|
|
|
// Emit the operand class switch to call the correct custom parser for
|
|
|
|
// the found operand class.
|
2011-02-12 01:34:40 +00:00
|
|
|
OS << Target.getName() << ClassName << "::OperandMatchResultTy "
|
|
|
|
<< Target.getName() << ClassName << "::\n"
|
2014-06-08 16:18:35 +00:00
|
|
|
<< "tryCustomParseOperand(OperandVector"
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
<< " &Operands,\n unsigned MCK) {\n\n"
|
|
|
|
<< " switch(MCK) {\n";
|
|
|
|
|
2014-11-28 03:53:02 +00:00
|
|
|
for (const auto &CI : Info.Classes) {
|
2014-11-28 20:35:57 +00:00
|
|
|
if (CI.ParserMethod.empty())
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
continue;
|
2014-11-28 20:35:57 +00:00
|
|
|
OS << " case " << CI.Name << ":\n"
|
|
|
|
<< " return " << CI.ParserMethod << "(Operands);\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
OS << " default:\n";
|
2011-02-12 01:34:40 +00:00
|
|
|
OS << " return MatchOperand_NoMatch;\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << " }\n";
|
2011-02-12 01:34:40 +00:00
|
|
|
OS << " return MatchOperand_NoMatch;\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << "}\n\n";
|
|
|
|
|
|
|
|
// Emit the static custom operand parser. This code is very similar with
|
|
|
|
// the other matcher. Also use MatchResultTy here just in case we go for
|
|
|
|
// a better error handling.
|
2011-02-12 01:34:40 +00:00
|
|
|
OS << Target.getName() << ClassName << "::OperandMatchResultTy "
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
<< Target.getName() << ClassName << "::\n"
|
2014-06-08 16:18:35 +00:00
|
|
|
<< "MatchOperandParserImpl(OperandVector"
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
<< " &Operands,\n StringRef Mnemonic) {\n";
|
|
|
|
|
|
|
|
// Emit code to get the available features.
|
|
|
|
OS << " // Get the current feature set.\n";
|
2014-08-18 11:49:42 +00:00
|
|
|
OS << " uint64_t AvailableFeatures = getAvailableFeatures();\n\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
|
|
|
OS << " // Get the next operand index.\n";
|
|
|
|
OS << " unsigned NextOpNum = Operands.size()-1;\n";
|
|
|
|
|
|
|
|
// Emit code to search the table.
|
|
|
|
OS << " // Search the table.\n";
|
|
|
|
OS << " std::pair<const OperandMatchEntry*, const OperandMatchEntry*>";
|
|
|
|
OS << " MnemonicRange =\n";
|
|
|
|
OS << " std::equal_range(OperandMatchTable, OperandMatchTable+"
|
|
|
|
<< Info.OperandMatchInfo.size() << ", Mnemonic,\n"
|
|
|
|
<< " LessOpcodeOperand());\n\n";
|
|
|
|
|
|
|
|
OS << " if (MnemonicRange.first == MnemonicRange.second)\n";
|
2011-02-12 01:34:40 +00:00
|
|
|
OS << " return MatchOperand_NoMatch;\n\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
|
|
|
OS << " for (const OperandMatchEntry *it = MnemonicRange.first,\n"
|
|
|
|
<< " *ie = MnemonicRange.second; it != ie; ++it) {\n";
|
|
|
|
|
|
|
|
OS << " // equal_range guarantees that instruction mnemonic matches.\n";
|
2012-03-03 20:44:43 +00:00
|
|
|
OS << " assert(Mnemonic == it->getMnemonic());\n\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
|
|
|
// Emit check that the required features are available.
|
|
|
|
OS << " // check if the available features match\n";
|
|
|
|
OS << " if ((AvailableFeatures & it->RequiredFeatures) "
|
|
|
|
<< "!= it->RequiredFeatures) {\n";
|
|
|
|
OS << " continue;\n";
|
|
|
|
OS << " }\n\n";
|
|
|
|
|
|
|
|
// Emit check to ensure the operand number matches.
|
|
|
|
OS << " // check if the operand in question has a custom parser.\n";
|
|
|
|
OS << " if (!(it->OperandMask & (1 << NextOpNum)))\n";
|
|
|
|
OS << " continue;\n\n";
|
|
|
|
|
|
|
|
// Emit call to the custom parser method
|
|
|
|
OS << " // call custom parse method to handle the operand\n";
|
2011-02-12 01:34:40 +00:00
|
|
|
OS << " OperandMatchResultTy Result = ";
|
2011-12-06 22:07:02 +00:00
|
|
|
OS << "tryCustomParseOperand(Operands, it->Class);\n";
|
2011-02-12 01:34:40 +00:00
|
|
|
OS << " if (Result != MatchOperand_NoMatch)\n";
|
|
|
|
OS << " return Result;\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << " }\n\n";
|
|
|
|
|
2011-02-12 01:34:40 +00:00
|
|
|
OS << " // Okay, we had no match.\n";
|
|
|
|
OS << " return MatchOperand_NoMatch;\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << "}\n\n";
|
|
|
|
}
|
|
|
|
|
2009-08-07 21:01:44 +00:00
|
|
|
void AsmMatcherEmitter::run(raw_ostream &OS) {
|
2010-12-13 00:23:57 +00:00
|
|
|
CodeGenTarget Target(Records);
|
2009-08-07 21:01:44 +00:00
|
|
|
Record *AsmParser = Target.getAsmParser();
|
|
|
|
std::string ClassName = AsmParser->getValueAsString("AsmParserClassName");
|
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
// Compute the information on the instructions to match.
|
2010-12-13 00:23:57 +00:00
|
|
|
AsmMatcherInfo Info(AsmParser, Target, Records);
|
2012-04-19 17:52:32 +00:00
|
|
|
Info.buildInfo();
|
2009-08-07 08:26:05 +00:00
|
|
|
|
2010-02-02 23:46:36 +00:00
|
|
|
// Sort the instruction table using the partial order on classes. We use
|
|
|
|
// stable_sort to ensure that ambiguous instructions are still
|
|
|
|
// deterministically ordered.
|
2014-11-28 23:00:22 +00:00
|
|
|
std::stable_sort(Info.Matchables.begin(), Info.Matchables.end(),
|
|
|
|
[](const std::unique_ptr<MatchableInfo> &a,
|
|
|
|
const std::unique_ptr<MatchableInfo> &b){
|
|
|
|
return *a < *b;});
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2009-08-08 05:24:34 +00:00
|
|
|
DEBUG_WITH_TYPE("instruction_info", {
|
2014-11-28 03:53:02 +00:00
|
|
|
for (const auto &MI : Info.Matchables)
|
2014-11-28 23:00:22 +00:00
|
|
|
MI->dump();
|
2009-08-07 08:26:05 +00:00
|
|
|
});
|
|
|
|
|
2010-11-01 05:06:45 +00:00
|
|
|
// Check for ambiguous matchables.
|
2010-09-06 21:28:52 +00:00
|
|
|
DEBUG_WITH_TYPE("ambiguous_instrs", {
|
|
|
|
unsigned NumAmbiguous = 0;
|
2014-12-22 21:26:38 +00:00
|
|
|
for (auto I = Info.Matchables.begin(), E = Info.Matchables.end(); I != E;
|
|
|
|
++I) {
|
|
|
|
for (auto J = std::next(I); J != E; ++J) {
|
|
|
|
const MatchableInfo &A = **I;
|
|
|
|
const MatchableInfo &B = **J;
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2012-04-19 17:52:32 +00:00
|
|
|
if (A.couldMatchAmbiguouslyWith(B)) {
|
2010-11-01 05:06:45 +00:00
|
|
|
errs() << "warning: ambiguous matchables:\n";
|
2010-09-06 21:28:52 +00:00
|
|
|
A.dump();
|
|
|
|
errs() << "\nis incomparable with:\n";
|
|
|
|
B.dump();
|
|
|
|
errs() << "\n\n";
|
2010-09-06 20:21:47 +00:00
|
|
|
++NumAmbiguous;
|
|
|
|
}
|
2009-08-09 06:05:33 +00:00
|
|
|
}
|
2009-08-09 04:00:06 +00:00
|
|
|
}
|
2010-09-06 20:21:47 +00:00
|
|
|
if (NumAmbiguous)
|
2010-10-29 22:13:48 +00:00
|
|
|
errs() << "warning: " << NumAmbiguous
|
2010-11-01 05:06:45 +00:00
|
|
|
<< " ambiguous matchables!\n";
|
2010-09-06 21:28:52 +00:00
|
|
|
});
|
2009-08-09 04:00:06 +00:00
|
|
|
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
// Compute the information on the custom operand parsing.
|
2012-04-19 17:52:32 +00:00
|
|
|
Info.buildOperandMatchInfo();
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
2009-08-11 23:23:44 +00:00
|
|
|
// Write the output.
|
|
|
|
|
2010-09-06 19:11:01 +00:00
|
|
|
// Information for the class declaration.
|
|
|
|
OS << "\n#ifdef GET_ASSEMBLER_HEADER\n";
|
|
|
|
OS << "#undef GET_ASSEMBLER_HEADER\n";
|
2011-02-11 21:31:55 +00:00
|
|
|
OS << " // This should be included into the middle of the declaration of\n";
|
2011-07-26 00:24:13 +00:00
|
|
|
OS << " // your subclasses implementation of MCTargetAsmParser.\n";
|
2015-02-19 11:38:11 +00:00
|
|
|
OS << " uint64_t ComputeAvailableFeatures(uint64_t FeatureBits) const;\n";
|
2012-09-05 01:02:38 +00:00
|
|
|
OS << " void convertToMCInst(unsigned Kind, MCInst &Inst, "
|
2011-02-04 23:17:40 +00:00
|
|
|
<< "unsigned Opcode,\n"
|
2014-06-08 16:18:35 +00:00
|
|
|
<< " const OperandVector "
|
2011-02-04 23:17:40 +00:00
|
|
|
<< "&Operands);\n";
|
2012-10-02 00:25:57 +00:00
|
|
|
OS << " void convertToMapAndConstraints(unsigned Kind,\n ";
|
2014-06-08 16:18:35 +00:00
|
|
|
OS << " const OperandVector &Operands) override;\n";
|
2014-03-09 18:03:14 +00:00
|
|
|
OS << " bool mnemonicIsValid(StringRef Mnemonic, unsigned VariantID) override;\n";
|
2015-01-03 08:16:29 +00:00
|
|
|
OS << " unsigned MatchInstructionImpl(const OperandVector &Operands,\n"
|
2012-10-12 22:53:36 +00:00
|
|
|
<< " MCInst &Inst,\n"
|
2014-08-18 11:49:42 +00:00
|
|
|
<< " uint64_t &ErrorInfo,"
|
2012-10-02 00:25:57 +00:00
|
|
|
<< " bool matchingInlineAsm,\n"
|
|
|
|
<< " unsigned VariantID = 0);\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
2015-01-15 11:41:30 +00:00
|
|
|
if (!Info.OperandMatchInfo.empty()) {
|
2011-02-12 01:34:40 +00:00
|
|
|
OS << "\n enum OperandMatchResultTy {\n";
|
|
|
|
OS << " MatchOperand_Success, // operand matched successfully\n";
|
|
|
|
OS << " MatchOperand_NoMatch, // operand did not match\n";
|
|
|
|
OS << " MatchOperand_ParseFail // operand matched but had errors\n";
|
|
|
|
OS << " };\n";
|
|
|
|
OS << " OperandMatchResultTy MatchOperandParserImpl(\n";
|
2014-06-08 16:18:35 +00:00
|
|
|
OS << " OperandVector &Operands,\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << " StringRef Mnemonic);\n";
|
|
|
|
|
2011-12-06 22:07:02 +00:00
|
|
|
OS << " OperandMatchResultTy tryCustomParseOperand(\n";
|
2014-06-08 16:18:35 +00:00
|
|
|
OS << " OperandVector &Operands,\n";
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << " unsigned MCK);\n\n";
|
|
|
|
}
|
|
|
|
|
2010-09-06 19:11:01 +00:00
|
|
|
OS << "#endif // GET_ASSEMBLER_HEADER_INFO\n\n";
|
|
|
|
|
2012-06-22 23:56:44 +00:00
|
|
|
// Emit the operand match diagnostic enum names.
|
|
|
|
OS << "\n#ifdef GET_OPERAND_DIAGNOSTIC_TYPES\n";
|
|
|
|
OS << "#undef GET_OPERAND_DIAGNOSTIC_TYPES\n\n";
|
|
|
|
emitOperandDiagnosticTypes(Info, OS);
|
|
|
|
OS << "#endif // GET_OPERAND_DIAGNOSTIC_TYPES\n\n";
|
|
|
|
|
|
|
|
|
2010-09-06 19:11:01 +00:00
|
|
|
OS << "\n#ifdef GET_REGISTER_MATCHER\n";
|
|
|
|
OS << "#undef GET_REGISTER_MATCHER\n\n";
|
|
|
|
|
2010-07-19 05:44:09 +00:00
|
|
|
// Emit the subtarget feature enumeration.
|
2012-04-19 17:52:32 +00:00
|
|
|
emitSubtargetFeatureFlagEnumeration(Info, OS);
|
2010-07-19 05:44:09 +00:00
|
|
|
|
2009-08-11 23:23:44 +00:00
|
|
|
// Emit the function to match a register name to number.
|
2012-08-17 20:16:42 +00:00
|
|
|
// This should be omitted for Mips target
|
|
|
|
if (AsmParser->getValueAsBit("ShouldEmitMatchRegisterName"))
|
|
|
|
emitMatchRegisterName(Target, AsmParser, OS);
|
2010-09-06 19:11:01 +00:00
|
|
|
|
|
|
|
OS << "#endif // GET_REGISTER_MATCHER\n\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2012-04-25 06:56:34 +00:00
|
|
|
OS << "\n#ifdef GET_SUBTARGET_FEATURE_NAME\n";
|
|
|
|
OS << "#undef GET_SUBTARGET_FEATURE_NAME\n\n";
|
2009-08-11 23:23:44 +00:00
|
|
|
|
2012-04-24 22:40:08 +00:00
|
|
|
// Generate the helper function to get the names for subtarget features.
|
|
|
|
emitGetSubtargetFeatureName(Info, OS);
|
|
|
|
|
2012-04-25 06:56:34 +00:00
|
|
|
OS << "#endif // GET_SUBTARGET_FEATURE_NAME\n\n";
|
|
|
|
|
|
|
|
OS << "\n#ifdef GET_MATCHER_IMPLEMENTATION\n";
|
|
|
|
OS << "#undef GET_MATCHER_IMPLEMENTATION\n\n";
|
|
|
|
|
2010-10-30 18:48:18 +00:00
|
|
|
// Generate the function that remaps for mnemonic aliases.
|
2013-04-18 22:35:36 +00:00
|
|
|
bool HasMnemonicAliases = emitMnemonicAliases(OS, Info, Target);
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2012-10-01 23:45:51 +00:00
|
|
|
// Generate the convertToMCInst function to convert operands into an MCInst.
|
|
|
|
// Also, generate the convertToMapAndConstraints function for MS-style inline
|
|
|
|
// assembly. The latter doesn't actually generate a MCInst.
|
|
|
|
emitConvertFuncs(Target, ClassName, Info.Matchables, OS);
|
2009-08-08 07:50:56 +00:00
|
|
|
|
|
|
|
// Emit the enumeration for classes which participate in matching.
|
2012-04-19 17:52:32 +00:00
|
|
|
emitMatchClassEnumeration(Target, Info.Classes, OS);
|
2009-08-07 08:26:05 +00:00
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
// Emit the routine to match token strings to their match class.
|
2012-04-19 17:52:32 +00:00
|
|
|
emitMatchTokenString(Target, Info.Classes, OS);
|
2009-08-07 08:26:05 +00:00
|
|
|
|
2009-08-10 16:05:47 +00:00
|
|
|
// Emit the subclass predicate routine.
|
2012-04-19 17:52:32 +00:00
|
|
|
emitIsSubclass(Target, Info.Classes, OS);
|
2009-08-10 16:05:47 +00:00
|
|
|
|
2011-02-10 00:08:28 +00:00
|
|
|
// Emit the routine to validate an operand against a match class.
|
2012-04-19 17:52:32 +00:00
|
|
|
emitValidateOperandClass(Info, OS);
|
2011-02-10 00:08:28 +00:00
|
|
|
|
2010-07-19 05:44:09 +00:00
|
|
|
// Emit the available features compute function.
|
2012-04-19 17:52:32 +00:00
|
|
|
emitComputeAvailableFeatures(Info, OS);
|
2010-07-19 05:44:09 +00:00
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
|
2012-09-18 06:10:45 +00:00
|
|
|
StringToOffsetTable StringTable;
|
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
size_t MaxNumOperands = 0;
|
2012-09-18 06:10:45 +00:00
|
|
|
unsigned MaxMnemonicIndex = 0;
|
2013-09-12 10:28:05 +00:00
|
|
|
bool HasDeprecation = false;
|
2014-11-28 03:53:02 +00:00
|
|
|
for (const auto &MI : Info.Matchables) {
|
2014-11-28 23:00:22 +00:00
|
|
|
MaxNumOperands = std::max(MaxNumOperands, MI->AsmOperands.size());
|
|
|
|
HasDeprecation |= MI->HasDeprecation;
|
2012-09-18 06:10:45 +00:00
|
|
|
|
|
|
|
// Store a pascal-style length byte in the mnemonic.
|
2014-11-28 23:00:22 +00:00
|
|
|
std::string LenMnemonic = char(MI->Mnemonic.size()) + MI->Mnemonic.str();
|
2012-09-18 06:10:45 +00:00
|
|
|
MaxMnemonicIndex = std::max(MaxMnemonicIndex,
|
|
|
|
StringTable.GetOrAddStringOffset(LenMnemonic, false));
|
|
|
|
}
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2012-09-18 07:02:21 +00:00
|
|
|
OS << "static const char *const MnemonicTable =\n";
|
|
|
|
StringTable.EmitString(OS);
|
|
|
|
OS << ";\n\n";
|
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
// Emit the static match table; unused classes get initalized to 0 which is
|
|
|
|
// guaranteed to be InvalidMatchClass.
|
|
|
|
//
|
|
|
|
// FIXME: We can reduce the size of this table very easily. First, we change
|
|
|
|
// it so that store the kinds in separate bit-fields for each index, which
|
|
|
|
// only needs to be the max width used for classes at that index (we also need
|
|
|
|
// to reject based on this during classification). If we then make sure to
|
|
|
|
// order the match kinds appropriately (putting mnemonics last), then we
|
|
|
|
// should only end up using a few bits for each class, especially the ones
|
|
|
|
// following the mnemonic.
|
2010-09-06 21:08:38 +00:00
|
|
|
OS << "namespace {\n";
|
|
|
|
OS << " struct MatchEntry {\n";
|
2012-09-18 06:10:45 +00:00
|
|
|
OS << " " << getMinimalTypeForRange(MaxMnemonicIndex)
|
|
|
|
<< " Mnemonic;\n";
|
2012-03-03 19:13:26 +00:00
|
|
|
OS << " uint16_t Opcode;\n";
|
2014-11-28 23:00:22 +00:00
|
|
|
OS << " " << getMinimalTypeForRange(Info.Matchables.size())
|
|
|
|
<< " ConvertFn;\n";
|
2014-05-21 10:11:24 +00:00
|
|
|
OS << " " << getMinimalRequiredFeaturesType(Info)
|
2011-10-17 16:18:09 +00:00
|
|
|
<< " RequiredFeatures;\n";
|
2014-11-28 20:35:57 +00:00
|
|
|
OS << " " << getMinimalTypeForRange(
|
|
|
|
std::distance(Info.Classes.begin(), Info.Classes.end()))
|
|
|
|
<< " Classes[" << MaxNumOperands << "];\n";
|
2012-03-03 19:13:26 +00:00
|
|
|
OS << " StringRef getMnemonic() const {\n";
|
|
|
|
OS << " return StringRef(MnemonicTable + Mnemonic + 1,\n";
|
|
|
|
OS << " MnemonicTable[Mnemonic]);\n";
|
|
|
|
OS << " }\n";
|
2010-09-06 21:22:45 +00:00
|
|
|
OS << " };\n\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
OS << " // Predicate for searching for an opcode.\n";
|
2010-09-06 21:22:45 +00:00
|
|
|
OS << " struct LessOpcode {\n";
|
|
|
|
OS << " bool operator()(const MatchEntry &LHS, StringRef RHS) {\n";
|
2012-03-03 19:13:26 +00:00
|
|
|
OS << " return LHS.getMnemonic() < RHS;\n";
|
2010-09-06 21:22:45 +00:00
|
|
|
OS << " }\n";
|
|
|
|
OS << " bool operator()(StringRef LHS, const MatchEntry &RHS) {\n";
|
2012-03-03 19:13:26 +00:00
|
|
|
OS << " return LHS < RHS.getMnemonic();\n";
|
2010-09-06 21:22:45 +00:00
|
|
|
OS << " }\n";
|
2010-09-07 06:10:48 +00:00
|
|
|
OS << " bool operator()(const MatchEntry &LHS, const MatchEntry &RHS) {\n";
|
2012-03-03 19:13:26 +00:00
|
|
|
OS << " return LHS.getMnemonic() < RHS.getMnemonic();\n";
|
2010-09-07 06:10:48 +00:00
|
|
|
OS << " }\n";
|
2010-09-06 21:08:38 +00:00
|
|
|
OS << " };\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2010-09-06 21:08:38 +00:00
|
|
|
OS << "} // end anonymous namespace.\n\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2013-07-24 07:33:14 +00:00
|
|
|
unsigned VariantCount = Target.getAsmParserVariantCount();
|
|
|
|
for (unsigned VC = 0; VC != VariantCount; ++VC) {
|
|
|
|
Record *AsmVariant = Target.getAsmParserVariant(VC);
|
|
|
|
int AsmVariantNo = AsmVariant->getValueAsInt("Variant");
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2013-07-24 07:33:14 +00:00
|
|
|
OS << "static const MatchEntry MatchTable" << VC << "[] = {\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2014-11-28 03:53:02 +00:00
|
|
|
for (const auto &MI : Info.Matchables) {
|
2014-11-28 23:00:22 +00:00
|
|
|
if (MI->AsmVariantID != AsmVariantNo)
|
2013-07-24 07:33:14 +00:00
|
|
|
continue;
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2013-07-24 07:33:14 +00:00
|
|
|
// Store a pascal-style length byte in the mnemonic.
|
2014-11-28 23:00:22 +00:00
|
|
|
std::string LenMnemonic = char(MI->Mnemonic.size()) + MI->Mnemonic.str();
|
2013-07-24 07:33:14 +00:00
|
|
|
OS << " { " << StringTable.GetOrAddStringOffset(LenMnemonic, false)
|
2014-11-28 23:00:22 +00:00
|
|
|
<< " /* " << MI->Mnemonic << " */, "
|
|
|
|
<< Target.getName() << "::"
|
|
|
|
<< MI->getResultInst()->TheDef->getName() << ", "
|
|
|
|
<< MI->ConversionFnKind << ", ";
|
2013-07-24 07:33:14 +00:00
|
|
|
|
|
|
|
// Write the required features mask.
|
2014-11-28 23:00:22 +00:00
|
|
|
if (!MI->RequiredFeatures.empty()) {
|
|
|
|
for (unsigned i = 0, e = MI->RequiredFeatures.size(); i != e; ++i) {
|
2013-07-24 07:33:14 +00:00
|
|
|
if (i) OS << "|";
|
2014-11-28 23:00:22 +00:00
|
|
|
OS << MI->RequiredFeatures[i]->getEnumName();
|
2013-07-24 07:33:14 +00:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
OS << "0";
|
2012-04-02 07:48:39 +00:00
|
|
|
|
2013-07-24 07:33:14 +00:00
|
|
|
OS << ", { ";
|
2014-11-28 23:00:22 +00:00
|
|
|
for (unsigned i = 0, e = MI->AsmOperands.size(); i != e; ++i) {
|
|
|
|
const MatchableInfo::AsmOperand &Op = MI->AsmOperands[i];
|
2012-04-02 07:48:39 +00:00
|
|
|
|
2013-07-24 07:33:14 +00:00
|
|
|
if (i) OS << ", ";
|
|
|
|
OS << Op.Class->Name;
|
|
|
|
}
|
|
|
|
OS << " }, },\n";
|
2012-04-02 07:48:39 +00:00
|
|
|
}
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2013-07-24 07:33:14 +00:00
|
|
|
OS << "};\n\n";
|
|
|
|
}
|
2009-08-08 07:50:56 +00:00
|
|
|
|
2011-01-26 21:43:46 +00:00
|
|
|
// A method to determine if a mnemonic is in the list.
|
|
|
|
OS << "bool " << Target.getName() << ClassName << "::\n"
|
2013-07-24 07:33:14 +00:00
|
|
|
<< "mnemonicIsValid(StringRef Mnemonic, unsigned VariantID) {\n";
|
|
|
|
OS << " // Find the appropriate table for this asm variant.\n";
|
|
|
|
OS << " const MatchEntry *Start, *End;\n";
|
|
|
|
OS << " switch (VariantID) {\n";
|
2015-01-03 08:16:14 +00:00
|
|
|
OS << " default: llvm_unreachable(\"invalid variant!\");\n";
|
2013-07-24 07:33:14 +00:00
|
|
|
for (unsigned VC = 0; VC != VariantCount; ++VC) {
|
|
|
|
Record *AsmVariant = Target.getAsmParserVariant(VC);
|
|
|
|
int AsmVariantNo = AsmVariant->getValueAsInt("Variant");
|
2014-04-12 16:15:53 +00:00
|
|
|
OS << " case " << AsmVariantNo << ": Start = std::begin(MatchTable" << VC
|
|
|
|
<< "); End = std::end(MatchTable" << VC << "); break;\n";
|
2013-07-24 07:33:14 +00:00
|
|
|
}
|
|
|
|
OS << " }\n";
|
2011-01-26 21:43:46 +00:00
|
|
|
OS << " // Search the table.\n";
|
|
|
|
OS << " std::pair<const MatchEntry*, const MatchEntry*> MnemonicRange =\n";
|
2013-07-24 07:33:14 +00:00
|
|
|
OS << " std::equal_range(Start, End, Mnemonic, LessOpcode());\n";
|
2011-01-26 21:43:46 +00:00
|
|
|
OS << " return MnemonicRange.first != MnemonicRange.second;\n";
|
|
|
|
OS << "}\n\n";
|
|
|
|
|
2010-09-06 21:08:38 +00:00
|
|
|
// Finally, build the match function.
|
2014-06-08 16:18:35 +00:00
|
|
|
OS << "unsigned " << Target.getName() << ClassName << "::\n"
|
2015-01-03 08:16:29 +00:00
|
|
|
<< "MatchInstructionImpl(const OperandVector &Operands,\n";
|
|
|
|
OS << " MCInst &Inst, uint64_t &ErrorInfo,\n"
|
|
|
|
<< " bool matchingInlineAsm, unsigned VariantID) {\n";
|
2010-07-19 05:44:09 +00:00
|
|
|
|
2012-08-30 21:43:05 +00:00
|
|
|
OS << " // Eliminate obvious mismatches.\n";
|
|
|
|
OS << " if (Operands.size() > " << (MaxNumOperands+1) << ") {\n";
|
|
|
|
OS << " ErrorInfo = " << (MaxNumOperands+1) << ";\n";
|
|
|
|
OS << " return Match_InvalidOperand;\n";
|
|
|
|
OS << " }\n\n";
|
|
|
|
|
2010-07-19 05:44:09 +00:00
|
|
|
// Emit code to get the available features.
|
|
|
|
OS << " // Get the current feature set.\n";
|
2014-08-18 11:49:42 +00:00
|
|
|
OS << " uint64_t AvailableFeatures = getAvailableFeatures();\n\n";
|
2010-07-19 05:44:09 +00:00
|
|
|
|
2010-10-30 17:36:36 +00:00
|
|
|
OS << " // Get the instruction mnemonic, which is the first token.\n";
|
|
|
|
OS << " StringRef Mnemonic = ((" << Target.getName()
|
2014-06-08 16:18:35 +00:00
|
|
|
<< "Operand&)*Operands[0]).getToken();\n\n";
|
2010-10-30 17:36:36 +00:00
|
|
|
|
2010-10-30 18:48:18 +00:00
|
|
|
if (HasMnemonicAliases) {
|
|
|
|
OS << " // Process all MnemonicAliases to remap the mnemonic.\n";
|
2013-04-18 22:35:36 +00:00
|
|
|
OS << " applyMnemonicAliases(Mnemonic, AvailableFeatures, VariantID);\n\n";
|
2010-10-30 18:48:18 +00:00
|
|
|
}
|
2011-01-26 21:26:19 +00:00
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
// Emit code to compute the class list for this operand vector.
|
2010-09-06 23:37:39 +00:00
|
|
|
OS << " // Some state to try to produce better error messages.\n";
|
2011-08-15 23:03:29 +00:00
|
|
|
OS << " bool HadMatchOtherThanFeatures = false;\n";
|
2011-08-16 20:12:35 +00:00
|
|
|
OS << " bool HadMatchOtherThanPredicate = false;\n";
|
2011-08-15 23:03:29 +00:00
|
|
|
OS << " unsigned RetCode = Match_InvalidOperand;\n";
|
2014-08-18 11:49:42 +00:00
|
|
|
OS << " uint64_t MissingFeatures = ~0ULL;\n";
|
2011-02-11 21:31:55 +00:00
|
|
|
OS << " // Set ErrorInfo to the operand that mismatches if it is\n";
|
2010-09-06 23:37:39 +00:00
|
|
|
OS << " // wrong for all instances of the instruction.\n";
|
|
|
|
OS << " ErrorInfo = ~0U;\n";
|
2010-09-06 21:22:45 +00:00
|
|
|
|
2009-08-08 07:50:56 +00:00
|
|
|
// Emit code to search the table.
|
2013-07-24 07:33:14 +00:00
|
|
|
OS << " // Find the appropriate table for this asm variant.\n";
|
|
|
|
OS << " const MatchEntry *Start, *End;\n";
|
|
|
|
OS << " switch (VariantID) {\n";
|
2015-01-03 08:16:14 +00:00
|
|
|
OS << " default: llvm_unreachable(\"invalid variant!\");\n";
|
2013-07-24 07:33:14 +00:00
|
|
|
for (unsigned VC = 0; VC != VariantCount; ++VC) {
|
|
|
|
Record *AsmVariant = Target.getAsmParserVariant(VC);
|
|
|
|
int AsmVariantNo = AsmVariant->getValueAsInt("Variant");
|
2014-04-12 16:15:53 +00:00
|
|
|
OS << " case " << AsmVariantNo << ": Start = std::begin(MatchTable" << VC
|
|
|
|
<< "); End = std::end(MatchTable" << VC << "); break;\n";
|
2013-07-24 07:33:14 +00:00
|
|
|
}
|
|
|
|
OS << " }\n";
|
2009-08-08 07:50:56 +00:00
|
|
|
OS << " // Search the table.\n";
|
2010-09-06 21:22:45 +00:00
|
|
|
OS << " std::pair<const MatchEntry*, const MatchEntry*> MnemonicRange =\n";
|
2013-07-24 07:33:14 +00:00
|
|
|
OS << " std::equal_range(Start, End, Mnemonic, LessOpcode());\n\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2010-09-06 21:54:15 +00:00
|
|
|
OS << " // Return a more specific error code if no mnemonics match.\n";
|
|
|
|
OS << " if (MnemonicRange.first == MnemonicRange.second)\n";
|
|
|
|
OS << " return Match_MnemonicFail;\n\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2010-09-06 21:22:45 +00:00
|
|
|
OS << " for (const MatchEntry *it = MnemonicRange.first, "
|
2010-09-06 21:23:43 +00:00
|
|
|
<< "*ie = MnemonicRange.second;\n";
|
2010-09-06 21:22:45 +00:00
|
|
|
OS << " it != ie; ++it) {\n";
|
2010-07-19 05:44:09 +00:00
|
|
|
|
2010-09-07 06:06:06 +00:00
|
|
|
OS << " // equal_range guarantees that instruction mnemonic matches.\n";
|
2012-03-03 19:13:26 +00:00
|
|
|
OS << " assert(Mnemonic == it->getMnemonic());\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2010-07-19 05:44:09 +00:00
|
|
|
// Emit check that the subclasses match.
|
2010-09-06 22:11:18 +00:00
|
|
|
OS << " bool OperandsValid = true;\n";
|
|
|
|
OS << " for (unsigned i = 0; i != " << MaxNumOperands << "; ++i) {\n";
|
2011-02-10 00:08:28 +00:00
|
|
|
OS << " if (i + 1 >= Operands.size()) {\n";
|
|
|
|
OS << " OperandsValid = (it->Classes[i] == " <<"InvalidMatchClass);\n";
|
2012-08-04 10:31:40 +00:00
|
|
|
OS << " if (!OperandsValid) ErrorInfo = i + 1;\n";
|
2011-05-03 19:09:56 +00:00
|
|
|
OS << " break;\n";
|
2011-02-10 00:08:28 +00:00
|
|
|
OS << " }\n";
|
2014-06-08 16:18:35 +00:00
|
|
|
OS << " unsigned Diag = validateOperandClass(*Operands[i+1],\n";
|
2012-06-22 23:56:44 +00:00
|
|
|
OS.indent(43);
|
|
|
|
OS << "(MatchClassKind)it->Classes[i]);\n";
|
|
|
|
OS << " if (Diag == Match_Success)\n";
|
2010-09-06 22:11:18 +00:00
|
|
|
OS << " continue;\n";
|
2013-02-06 06:00:06 +00:00
|
|
|
OS << " // If the generic handler indicates an invalid operand\n";
|
|
|
|
OS << " // failure, check for a special case.\n";
|
|
|
|
OS << " if (Diag == Match_InvalidOperand) {\n";
|
2014-06-08 16:18:35 +00:00
|
|
|
OS << " Diag = validateTargetOperandClass(*Operands[i+1],\n";
|
2013-02-06 06:00:06 +00:00
|
|
|
OS.indent(43);
|
|
|
|
OS << "(MatchClassKind)it->Classes[i]);\n";
|
|
|
|
OS << " if (Diag == Match_Success)\n";
|
|
|
|
OS << " continue;\n";
|
|
|
|
OS << " }\n";
|
2010-09-06 23:37:39 +00:00
|
|
|
OS << " // If this operand is broken for all of the instances of this\n";
|
|
|
|
OS << " // mnemonic, keep track of it so we can report loc info.\n";
|
2012-06-22 23:56:44 +00:00
|
|
|
OS << " // If we already had a match that only failed due to a\n";
|
|
|
|
OS << " // target predicate, that diagnostic is preferred.\n";
|
|
|
|
OS << " if (!HadMatchOtherThanPredicate &&\n";
|
|
|
|
OS << " (it == MnemonicRange.first || ErrorInfo <= i+1)) {\n";
|
2010-09-06 22:11:18 +00:00
|
|
|
OS << " ErrorInfo = i+1;\n";
|
2012-06-26 22:58:01 +00:00
|
|
|
OS << " // InvalidOperand is the default. Prefer specificity.\n";
|
|
|
|
OS << " if (Diag != Match_InvalidOperand)\n";
|
|
|
|
OS << " RetCode = Diag;\n";
|
2012-06-22 23:56:44 +00:00
|
|
|
OS << " }\n";
|
2010-09-06 22:11:18 +00:00
|
|
|
OS << " // Otherwise, just reject this instance of the mnemonic.\n";
|
|
|
|
OS << " OperandsValid = false;\n";
|
|
|
|
OS << " break;\n";
|
|
|
|
OS << " }\n\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2010-09-06 22:11:18 +00:00
|
|
|
OS << " if (!OperandsValid) continue;\n";
|
2010-09-06 20:08:02 +00:00
|
|
|
|
|
|
|
// Emit check that the required features are available.
|
|
|
|
OS << " if ((AvailableFeatures & it->RequiredFeatures) "
|
|
|
|
<< "!= it->RequiredFeatures) {\n";
|
|
|
|
OS << " HadMatchOtherThanFeatures = true;\n";
|
2014-08-18 11:49:42 +00:00
|
|
|
OS << " uint64_t NewMissingFeatures = it->RequiredFeatures & "
|
2012-06-18 19:45:46 +00:00
|
|
|
"~AvailableFeatures;\n";
|
2015-02-12 15:35:40 +00:00
|
|
|
OS << " if (countPopulation(NewMissingFeatures) <=\n"
|
|
|
|
" countPopulation(MissingFeatures))\n";
|
2012-06-18 19:45:46 +00:00
|
|
|
OS << " MissingFeatures = NewMissingFeatures;\n";
|
2010-09-06 20:08:02 +00:00
|
|
|
OS << " continue;\n";
|
|
|
|
OS << " }\n";
|
2009-08-08 07:50:56 +00:00
|
|
|
OS << "\n";
|
2014-12-16 18:05:28 +00:00
|
|
|
OS << " Inst.clear();\n\n";
|
2012-10-01 23:45:51 +00:00
|
|
|
OS << " if (matchingInlineAsm) {\n";
|
|
|
|
OS << " Inst.setOpcode(it->Opcode);\n";
|
2012-10-12 22:53:36 +00:00
|
|
|
OS << " convertToMapAndConstraints(it->ConvertFn, Operands);\n";
|
2012-10-01 23:45:51 +00:00
|
|
|
OS << " return Match_Success;\n";
|
|
|
|
OS << " }\n\n";
|
2011-02-04 17:12:23 +00:00
|
|
|
OS << " // We have selected a definite instruction, convert the parsed\n"
|
|
|
|
<< " // operands into the appropriate MCInst.\n";
|
2012-09-05 01:02:38 +00:00
|
|
|
OS << " convertToMCInst(it->ConvertFn, Inst, it->Opcode, Operands);\n";
|
2011-02-04 17:12:23 +00:00
|
|
|
OS << "\n";
|
2010-03-18 20:05:56 +00:00
|
|
|
|
2011-08-15 23:03:29 +00:00
|
|
|
// Verify the instruction with the target-specific match predicate function.
|
|
|
|
OS << " // We have a potential match. Check the target predicate to\n"
|
|
|
|
<< " // handle any context sensitive constraints.\n"
|
|
|
|
<< " unsigned MatchResult;\n"
|
|
|
|
<< " if ((MatchResult = checkTargetMatchPredicate(Inst)) !="
|
|
|
|
<< " Match_Success) {\n"
|
|
|
|
<< " Inst.clear();\n"
|
|
|
|
<< " RetCode = MatchResult;\n"
|
2011-08-16 20:12:35 +00:00
|
|
|
<< " HadMatchOtherThanPredicate = true;\n"
|
2011-08-15 23:03:29 +00:00
|
|
|
<< " continue;\n"
|
|
|
|
<< " }\n\n";
|
|
|
|
|
2010-03-18 20:05:56 +00:00
|
|
|
// Call the post-processing function, if used.
|
|
|
|
std::string InsnCleanupFn =
|
|
|
|
AsmParser->getValueAsString("AsmParserInstCleanup");
|
|
|
|
if (!InsnCleanupFn.empty())
|
|
|
|
OS << " " << InsnCleanupFn << "(Inst);\n";
|
|
|
|
|
2013-09-12 10:28:05 +00:00
|
|
|
if (HasDeprecation) {
|
|
|
|
OS << " std::string Info;\n";
|
|
|
|
OS << " if (MII.get(Inst.getOpcode()).getDeprecatedInfo(Inst, STI, Info)) {\n";
|
2014-06-08 16:18:35 +00:00
|
|
|
OS << " SMLoc Loc = ((" << Target.getName()
|
|
|
|
<< "Operand&)*Operands[0]).getStartLoc();\n";
|
2014-11-11 05:18:41 +00:00
|
|
|
OS << " getParser().Warning(Loc, Info, None);\n";
|
2013-09-12 10:28:05 +00:00
|
|
|
OS << " }\n";
|
|
|
|
}
|
|
|
|
|
2010-09-06 19:22:17 +00:00
|
|
|
OS << " return Match_Success;\n";
|
2009-08-08 07:50:56 +00:00
|
|
|
OS << " }\n\n";
|
2009-07-31 02:32:59 +00:00
|
|
|
|
2010-09-06 20:08:02 +00:00
|
|
|
OS << " // Okay, we had no match. Try to return a useful error code.\n";
|
2012-08-21 17:22:47 +00:00
|
|
|
OS << " if (HadMatchOtherThanPredicate || !HadMatchOtherThanFeatures)\n";
|
|
|
|
OS << " return RetCode;\n\n";
|
2012-06-18 19:45:46 +00:00
|
|
|
OS << " // Missing feature matches return which features were missing\n";
|
|
|
|
OS << " ErrorInfo = MissingFeatures;\n";
|
2011-08-16 20:12:35 +00:00
|
|
|
OS << " return Match_MissingFeature;\n";
|
2009-07-31 02:32:59 +00:00
|
|
|
OS << "}\n\n";
|
2010-10-29 22:13:48 +00:00
|
|
|
|
2015-01-15 11:41:30 +00:00
|
|
|
if (!Info.OperandMatchInfo.empty())
|
2012-09-18 07:02:21 +00:00
|
|
|
emitCustomOperandParsing(OS, Target, Info, ClassName, StringTable,
|
|
|
|
MaxMnemonicIndex);
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
2010-09-06 19:11:01 +00:00
|
|
|
OS << "#endif // GET_MATCHER_IMPLEMENTATION\n\n";
|
2009-07-11 19:39:44 +00:00
|
|
|
}
|
2012-06-11 15:37:55 +00:00
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
|
|
|
void EmitAsmMatcher(RecordKeeper &RK, raw_ostream &OS) {
|
|
|
|
emitSourceFileHeader("Assembly Matcher Source Fragment", OS);
|
|
|
|
AsmMatcherEmitter(RK).run(OS);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // End llvm namespace
|