blob: b8ff2cd400caf41711246f253624c8d1761be78a [file] [log] [blame]
Daniel Dunbar3085b572009-07-11 19:39:44 +00001//===- AsmMatcherEmitter.cpp - Generate an assembly matcher ---------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This tablegen backend emits a target specifier matcher for converting parsed
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +000011// assembly operands in the MCInst structures. It also emits a matcher for
12// custom operand parsing.
13//
14// Converting assembly operands into MCInst structures
15// ---------------------------------------------------
Daniel Dunbar3085b572009-07-11 19:39:44 +000016//
Daniel Dunbare10787e2009-08-07 08:26:05 +000017// The input to the target specific matcher is a list of literal tokens and
18// operands. The target specific parser should generally eliminate any syntax
19// which is not relevant for matching; for example, comma tokens should have
20// already been consumed and eliminated by the parser. Most instructions will
21// end up with a single literal token (the instruction name) and some number of
22// operands.
23//
24// Some example inputs, for X86:
25// 'addl' (immediate ...) (register ...)
26// 'add' (immediate ...) (memory ...)
Jim Grosbach0eccfc22010-10-29 22:13:48 +000027// 'call' '*' %epc
Daniel Dunbare10787e2009-08-07 08:26:05 +000028//
29// The assembly matcher is responsible for converting this input into a precise
30// machine instruction (i.e., an instruction with a well defined encoding). This
31// mapping has several properties which complicate matching:
32//
33// - It may be ambiguous; many architectures can legally encode particular
34// variants of an instruction in different ways (for example, using a smaller
35// encoding for small immediates). Such ambiguities should never be
36// arbitrarily resolved by the assembler, the assembler is always responsible
37// for choosing the "best" available instruction.
38//
39// - It may depend on the subtarget or the assembler context. Instructions
40// which are invalid for the current mode, but otherwise unambiguous (e.g.,
41// an SSE instruction in a file being assembled for i486) should be accepted
42// and rejected by the assembler front end. However, if the proper encoding
43// for an instruction is dependent on the assembler context then the matcher
44// is responsible for selecting the correct machine instruction for the
45// current mode.
46//
47// The core matching algorithm attempts to exploit the regularity in most
48// instruction sets to quickly determine the set of possibly matching
49// instructions, and the simplify the generated code. Additionally, this helps
50// to ensure that the ambiguities are intentionally resolved by the user.
51//
52// The matching is divided into two distinct phases:
53//
54// 1. Classification: Each operand is mapped to the unique set which (a)
55// contains it, and (b) is the largest such subset for which a single
56// instruction could match all members.
57//
58// For register classes, we can generate these subgroups automatically. For
59// arbitrary operands, we expect the user to define the classes and their
60// relations to one another (for example, 8-bit signed immediates as a
61// subset of 32-bit immediates).
62//
63// By partitioning the operands in this way, we guarantee that for any
64// tuple of classes, any single instruction must match either all or none
65// of the sets of operands which could classify to that tuple.
66//
67// In addition, the subset relation amongst classes induces a partial order
68// on such tuples, which we use to resolve ambiguities.
69//
Daniel Dunbare10787e2009-08-07 08:26:05 +000070// 2. The input can now be treated as a tuple of classes (static tokens are
71// simple singleton sets). Each such tuple should generally map to a single
72// instruction (we currently ignore cases where this isn't true, whee!!!),
73// which we can emit a simple matcher for.
74//
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +000075// Custom Operand Parsing
76// ----------------------
77//
78// Some targets need a custom way to parse operands, some specific instructions
79// can contain arguments that can represent processor flags and other kinds of
Craig Topperaae8fb82012-09-18 01:13:36 +000080// identifiers that need to be mapped to specific values in the final encoded
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +000081// instructions. The target specific custom operand parsing works in the
82// following way:
83//
84// 1. A operand match table is built, each entry contains a mnemonic, an
85// operand class, a mask for all operand positions for that same
86// class/mnemonic and target features to be checked while trying to match.
87//
88// 2. The operand matcher will try every possible entry with the same
89// mnemonic and will check if the target feature for this mnemonic also
90// matches. After that, if the operand to be matched has its index
Chris Lattner0ab5e2c2011-04-15 05:18:47 +000091// present in the mask, a successful match occurs. Otherwise, fallback
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +000092// to the regular operand parsing.
93//
94// 3. For a match success, each operand class that has a 'ParserMethod'
95// becomes part of a switch from where the custom method is called.
96//
Daniel Dunbar3085b572009-07-11 19:39:44 +000097//===----------------------------------------------------------------------===//
98
Daniel Dunbar3085b572009-07-11 19:39:44 +000099#include "CodeGenTarget.h"
Chris Lattner4efe13d2010-11-04 02:11:18 +0000100#include "llvm/ADT/PointerUnion.h"
Chandler Carruth91d19d82012-12-04 10:37:14 +0000101#include "llvm/ADT/STLExtras.h"
Chris Lattnerf7a01e92010-11-01 01:47:07 +0000102#include "llvm/ADT/SmallPtrSet.h"
Daniel Dunbarb6d6aa22009-07-31 02:32:59 +0000103#include "llvm/ADT/SmallVector.h"
Daniel Dunbare10787e2009-08-07 08:26:05 +0000104#include "llvm/ADT/StringExtras.h"
105#include "llvm/Support/CommandLine.h"
Daniel Dunbarb6d6aa22009-07-31 02:32:59 +0000106#include "llvm/Support/Debug.h"
Craig Topperc4965bc2012-02-05 07:21:30 +0000107#include "llvm/Support/ErrorHandling.h"
Peter Collingbourne84c287e2011-10-01 16:41:13 +0000108#include "llvm/TableGen/Error.h"
109#include "llvm/TableGen/Record.h"
Douglas Gregor12c1cd32012-05-02 17:32:48 +0000110#include "llvm/TableGen/StringMatcher.h"
Craig Topper3e1d5da2013-08-29 05:09:55 +0000111#include "llvm/TableGen/StringToOffsetTable.h"
Jakob Stoklund Olesene6aed132012-06-11 15:37:55 +0000112#include "llvm/TableGen/TableGenBackend.h"
113#include <cassert>
Will Dietz981af002013-10-12 00:55:57 +0000114#include <cctype>
Daniel Dunbar71330282009-08-08 05:24:34 +0000115#include <map>
116#include <set>
Aaron Ballmane59e3582013-07-15 16:53:32 +0000117#include <sstream>
David Blaikied749e342014-11-28 20:35:57 +0000118#include <forward_list>
Daniel Dunbar3085b572009-07-11 19:39:44 +0000119using namespace llvm;
120
Chandler Carruthe96dd892014-04-21 22:55:11 +0000121#define DEBUG_TYPE "asm-matcher-emitter"
122
Daniel Dunbar15b80372009-08-07 20:33:39 +0000123static cl::opt<std::string>
Daniel Dunbar3239f022009-08-09 04:00:06 +0000124MatchPrefix("match-prefix", cl::init(""),
125 cl::desc("Only match instructions with the given prefix"));
Daniel Dunbare10787e2009-08-07 08:26:05 +0000126
Daniel Dunbare10787e2009-08-07 08:26:05 +0000127namespace {
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000128class AsmMatcherInfo;
Daniel Dunbareefe8612010-07-19 05:44:09 +0000129struct SubtargetFeatureInfo;
130
Tim Northoverc74e6912013-09-16 16:43:19 +0000131// Register sets are used as keys in some second-order sets TableGen creates
132// when generating its data structures. This means that the order of two
133// RegisterSets can be seen in the outputted AsmMatcher tables occasionally, and
134// can even affect compiler output (at least seen in diagnostics produced when
135// all matches fail). So we use a type that sorts them consistently.
136typedef std::set<Record*, LessRecordByID> RegisterSet;
137
Jakob Stoklund Olesene6aed132012-06-11 15:37:55 +0000138class AsmMatcherEmitter {
139 RecordKeeper &Records;
140public:
141 AsmMatcherEmitter(RecordKeeper &R) : Records(R) {}
142
143 void run(raw_ostream &o);
144};
145
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000146/// ClassInfo - Helper class for storing the information about a particular
147/// class of operands which can be matched.
148struct ClassInfo {
Daniel Dunbar3239f022009-08-09 04:00:06 +0000149 enum ClassInfoKind {
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000150 /// Invalid kind, for use as a sentinel value.
151 Invalid = 0,
152
153 /// The class for a particular token.
154 Token,
155
156 /// The (first) register class, subsequent register classes are
157 /// RegisterClass0+1, and so on.
158 RegisterClass0,
159
160 /// The (first) user defined class, subsequent user defined classes are
161 /// UserClass0+1, and so on.
162 UserClass0 = 1<<16
Daniel Dunbar3239f022009-08-09 04:00:06 +0000163 };
164
165 /// Kind - The class kind, which is either a predefined kind, or (UserClass0 +
166 /// N) for the Nth user defined class.
167 unsigned Kind;
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000168
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000169 /// SuperClasses - The super classes of this class. Note that for simplicities
170 /// sake user operands only record their immediate super class, while register
171 /// operands include all superclasses.
172 std::vector<ClassInfo*> SuperClasses;
Daniel Dunbar8e33cb22009-08-09 07:20:21 +0000173
Daniel Dunbarc32aa062009-08-09 05:18:30 +0000174 /// Name - The full class name, suitable for use in an enum.
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000175 std::string Name;
176
Daniel Dunbarc32aa062009-08-09 05:18:30 +0000177 /// ClassName - The unadorned generic name for this class (e.g., Token).
178 std::string ClassName;
179
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000180 /// ValueName - The name of the value this class represents; for a token this
181 /// is the literal token string, for an operand it is the TableGen class (or
182 /// empty if this is a derived class).
183 std::string ValueName;
184
185 /// PredicateMethod - The name of the operand method to test whether the
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000186 /// operand matches this class; this is not valid for Token or register kinds.
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000187 std::string PredicateMethod;
188
189 /// RenderMethod - The name of the operand method to add this operand to an
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000190 /// MCInst; this is not valid for Token or register kinds.
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000191 std::string RenderMethod;
Daniel Dunbar3239f022009-08-09 04:00:06 +0000192
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +0000193 /// ParserMethod - The name of the operand method to do a target specific
194 /// parsing on the operand.
195 std::string ParserMethod;
196
Eric Christopher650c8f22014-05-20 17:11:11 +0000197 /// For register classes: the records for all the registers in this class.
Tim Northoverc74e6912013-09-16 16:43:19 +0000198 RegisterSet Registers;
Daniel Dunbar34c87912009-08-11 20:10:07 +0000199
Eric Christopher650c8f22014-05-20 17:11:11 +0000200 /// For custom match classes: the diagnostic kind for when the predicate fails.
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +0000201 std::string DiagnosticType;
Daniel Dunbar34c87912009-08-11 20:10:07 +0000202public:
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000203 /// isRegisterClass() - Check if this is a register class.
204 bool isRegisterClass() const {
205 return Kind >= RegisterClass0 && Kind < UserClass0;
206 }
207
Daniel Dunbar8e33cb22009-08-09 07:20:21 +0000208 /// isUserClass() - Check if this is a user defined class.
209 bool isUserClass() const {
210 return Kind >= UserClass0;
211 }
212
Dmitri Gribenko8d302402012-09-15 20:22:05 +0000213 /// isRelatedTo - Check whether this class is "related" to \p RHS. Classes
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000214 /// are related if they are in the same class hierarchy.
215 bool isRelatedTo(const ClassInfo &RHS) const {
216 // Tokens are only related to tokens.
217 if (Kind == Token || RHS.Kind == Token)
218 return Kind == Token && RHS.Kind == Token;
219
Daniel Dunbar34c87912009-08-11 20:10:07 +0000220 // Registers classes are only related to registers classes, and only if
221 // their intersection is non-empty.
222 if (isRegisterClass() || RHS.isRegisterClass()) {
223 if (!isRegisterClass() || !RHS.isRegisterClass())
224 return false;
225
Tim Northoverc74e6912013-09-16 16:43:19 +0000226 RegisterSet Tmp;
227 std::insert_iterator<RegisterSet> II(Tmp, Tmp.begin());
Jim Grosbach0eccfc22010-10-29 22:13:48 +0000228 std::set_intersection(Registers.begin(), Registers.end(),
Daniel Dunbar34c87912009-08-11 20:10:07 +0000229 RHS.Registers.begin(), RHS.Registers.end(),
Tim Northoverc74e6912013-09-16 16:43:19 +0000230 II, LessRecordByID());
Daniel Dunbar34c87912009-08-11 20:10:07 +0000231
232 return !Tmp.empty();
233 }
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000234
235 // Otherwise we have two users operands; they are related if they are in the
236 // same class hierarchy.
Daniel Dunbar34c87912009-08-11 20:10:07 +0000237 //
238 // FIXME: This is an oversimplification, they should only be related if they
239 // intersect, however we don't have that information.
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000240 assert(isUserClass() && RHS.isUserClass() && "Unexpected class!");
241 const ClassInfo *Root = this;
242 while (!Root->SuperClasses.empty())
243 Root = Root->SuperClasses.front();
244
Daniel Dunbar34c87912009-08-11 20:10:07 +0000245 const ClassInfo *RHSRoot = &RHS;
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000246 while (!RHSRoot->SuperClasses.empty())
247 RHSRoot = RHSRoot->SuperClasses.front();
Jim Grosbach0eccfc22010-10-29 22:13:48 +0000248
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000249 return Root == RHSRoot;
250 }
251
Dmitri Gribenko8d302402012-09-15 20:22:05 +0000252 /// isSubsetOf - Test whether this class is a subset of \p RHS.
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000253 bool isSubsetOf(const ClassInfo &RHS) const {
254 // This is a subset of RHS if it is the same class...
255 if (this == &RHS)
256 return true;
257
258 // ... or if any of its super classes are a subset of RHS.
Craig Topper03ec8012014-11-25 20:11:31 +0000259 for (const ClassInfo *CI : SuperClasses)
260 if (CI->isSubsetOf(RHS))
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000261 return true;
262
263 return false;
Daniel Dunbar8e33cb22009-08-09 07:20:21 +0000264 }
265
Daniel Dunbar3239f022009-08-09 04:00:06 +0000266 /// operator< - Compare two classes.
267 bool operator<(const ClassInfo &RHS) const {
Daniel Dunbar97ac3af2010-05-27 05:31:32 +0000268 if (this == &RHS)
269 return false;
270
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000271 // Unrelated classes can be ordered by kind.
272 if (!isRelatedTo(RHS))
Daniel Dunbar3239f022009-08-09 04:00:06 +0000273 return Kind < RHS.Kind;
274
275 switch (Kind) {
Daniel Dunbarc32aa062009-08-09 05:18:30 +0000276 case Invalid:
Craig Topperc4965bc2012-02-05 07:21:30 +0000277 llvm_unreachable("Invalid kind!");
Daniel Dunbar3239f022009-08-09 04:00:06 +0000278
Daniel Dunbar3239f022009-08-09 04:00:06 +0000279 default:
Chris Lattner0ab5e2c2011-04-15 05:18:47 +0000280 // This class precedes the RHS if it is a proper subset of the RHS.
Daniel Dunbar97ac3af2010-05-27 05:31:32 +0000281 if (isSubsetOf(RHS))
Duncan Sands41b4a6b2010-07-12 08:16:59 +0000282 return true;
Daniel Dunbar97ac3af2010-05-27 05:31:32 +0000283 if (RHS.isSubsetOf(*this))
Duncan Sands41b4a6b2010-07-12 08:16:59 +0000284 return false;
Daniel Dunbar97ac3af2010-05-27 05:31:32 +0000285
286 // Otherwise, order by name to ensure we have a total ordering.
287 return ValueName < RHS.ValueName;
Daniel Dunbar3239f022009-08-09 04:00:06 +0000288 }
289 }
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000290};
291
Chris Lattnerad776812010-11-01 05:06:45 +0000292/// MatchableInfo - Helper class for storing the necessary information for an
293/// instruction or alias which is capable of being matched.
294struct MatchableInfo {
Chris Lattner896cf042010-11-03 19:47:34 +0000295 struct AsmOperand {
Chris Lattner28ea9b12010-11-02 17:30:52 +0000296 /// Token - This is the token that the operand came from.
297 StringRef Token;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000298
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000299 /// The unique class instance this operand should match.
300 ClassInfo *Class;
Daniel Dunbare10787e2009-08-07 08:26:05 +0000301
Chris Lattner7108dad2010-11-04 01:42:59 +0000302 /// The operand name this is, if anything.
303 StringRef SrcOpName;
Bob Wilsonb9b24222011-01-26 19:44:55 +0000304
305 /// The suboperand index within SrcOpName, or -1 for the entire operand.
306 int SubOpIdx;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000307
Devang Patel6d676e42012-01-07 01:33:34 +0000308 /// Register record if this token is singleton register.
309 Record *SingletonReg;
310
Craig Topper24064772014-04-15 07:20:03 +0000311 explicit AsmOperand(StringRef T) : Token(T), Class(nullptr), SubOpIdx(-1),
312 SingletonReg(nullptr) {}
Daniel Dunbare10787e2009-08-07 08:26:05 +0000313 };
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000314
Chris Lattner743081d2010-11-04 00:43:46 +0000315 /// ResOperand - This represents a single operand in the result instruction
316 /// generated by the match. In cases (like addressing modes) where a single
317 /// assembler operand expands to multiple MCOperands, this represents the
318 /// single assembler operand, not the MCOperand.
319 struct ResOperand {
320 enum {
321 /// RenderAsmOperand - This represents an operand result that is
322 /// generated by calling the render method on the assembly operand. The
323 /// corresponding AsmOperand is specified by AsmOperandNum.
324 RenderAsmOperand,
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000325
Chris Lattner743081d2010-11-04 00:43:46 +0000326 /// TiedOperand - This represents a result operand that is a duplicate of
327 /// a previous result operand.
Chris Lattnerb6f8e822010-11-06 19:25:43 +0000328 TiedOperand,
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000329
Chris Lattnerb6f8e822010-11-06 19:25:43 +0000330 /// ImmOperand - This represents an immediate value that is dumped into
331 /// the operand.
Chris Lattner4869d342010-11-06 19:57:21 +0000332 ImmOperand,
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000333
Chris Lattner4869d342010-11-06 19:57:21 +0000334 /// RegOperand - This represents a fixed register that is dumped in.
335 RegOperand
Chris Lattner743081d2010-11-04 00:43:46 +0000336 } Kind;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000337
Chris Lattner743081d2010-11-04 00:43:46 +0000338 union {
339 /// This is the operand # in the AsmOperands list that this should be
340 /// copied from.
341 unsigned AsmOperandNum;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000342
Chris Lattner743081d2010-11-04 00:43:46 +0000343 /// TiedOperandNum - This is the (earlier) result operand that should be
344 /// copied from.
345 unsigned TiedOperandNum;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000346
Chris Lattnerb6f8e822010-11-06 19:25:43 +0000347 /// ImmVal - This is the immediate value added to the instruction.
348 int64_t ImmVal;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000349
Chris Lattner4869d342010-11-06 19:57:21 +0000350 /// Register - This is the register record.
351 Record *Register;
Chris Lattner743081d2010-11-04 00:43:46 +0000352 };
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000353
Bob Wilsonb9b24222011-01-26 19:44:55 +0000354 /// MINumOperands - The number of MCInst operands populated by this
355 /// operand.
356 unsigned MINumOperands;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000357
Bob Wilsonb9b24222011-01-26 19:44:55 +0000358 static ResOperand getRenderedOp(unsigned AsmOpNum, unsigned NumOperands) {
Chris Lattner743081d2010-11-04 00:43:46 +0000359 ResOperand X;
360 X.Kind = RenderAsmOperand;
361 X.AsmOperandNum = AsmOpNum;
Bob Wilsonb9b24222011-01-26 19:44:55 +0000362 X.MINumOperands = NumOperands;
Chris Lattner743081d2010-11-04 00:43:46 +0000363 return X;
364 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000365
Bob Wilsonb9b24222011-01-26 19:44:55 +0000366 static ResOperand getTiedOp(unsigned TiedOperandNum) {
Chris Lattner743081d2010-11-04 00:43:46 +0000367 ResOperand X;
368 X.Kind = TiedOperand;
369 X.TiedOperandNum = TiedOperandNum;
Bob Wilsonb9b24222011-01-26 19:44:55 +0000370 X.MINumOperands = 1;
Chris Lattner743081d2010-11-04 00:43:46 +0000371 return X;
372 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000373
Bob Wilsonb9b24222011-01-26 19:44:55 +0000374 static ResOperand getImmOp(int64_t Val) {
Chris Lattnerb6f8e822010-11-06 19:25:43 +0000375 ResOperand X;
376 X.Kind = ImmOperand;
377 X.ImmVal = Val;
Bob Wilsonb9b24222011-01-26 19:44:55 +0000378 X.MINumOperands = 1;
Chris Lattnerb6f8e822010-11-06 19:25:43 +0000379 return X;
380 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000381
Bob Wilsonb9b24222011-01-26 19:44:55 +0000382 static ResOperand getRegOp(Record *Reg) {
Chris Lattner4869d342010-11-06 19:57:21 +0000383 ResOperand X;
384 X.Kind = RegOperand;
385 X.Register = Reg;
Bob Wilsonb9b24222011-01-26 19:44:55 +0000386 X.MINumOperands = 1;
Chris Lattner4869d342010-11-06 19:57:21 +0000387 return X;
388 }
Chris Lattner743081d2010-11-04 00:43:46 +0000389 };
Daniel Dunbare10787e2009-08-07 08:26:05 +0000390
Devang Patel9bdc5052012-01-10 17:50:43 +0000391 /// AsmVariantID - Target's assembly syntax variant no.
392 int AsmVariantID;
393
Chris Lattnera7a903e2010-11-02 17:34:28 +0000394 /// TheDef - This is the definition of the instruction or InstAlias that this
395 /// matchable came from.
Chris Lattner39bc53b2010-11-01 04:34:44 +0000396 Record *const TheDef;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000397
David Blaikie4e3c6ca2014-11-28 21:59:58 +0000398 /// AsmString - The assembly string for this instruction (with variants
399 /// removed), e.g. "movsx $src, $dst".
400 std::string AsmString;
401
Chris Lattner4efe13d2010-11-04 02:11:18 +0000402 /// DefRec - This is the definition that it came from.
403 PointerUnion<const CodeGenInstruction*, const CodeGenInstAlias*> DefRec;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000404
Chris Lattnerfecdad62010-11-06 07:14:44 +0000405 const CodeGenInstruction *getResultInst() const {
406 if (DefRec.is<const CodeGenInstruction*>())
407 return DefRec.get<const CodeGenInstruction*>();
408 return DefRec.get<const CodeGenInstAlias*>()->ResultInst;
409 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000410
Chris Lattner743081d2010-11-04 00:43:46 +0000411 /// ResOperands - This is the operand list that should be built for the result
412 /// MCInst.
Jim Grosbacha37e2292012-04-19 17:52:34 +0000413 SmallVector<ResOperand, 8> ResOperands;
Daniel Dunbare10787e2009-08-07 08:26:05 +0000414
Chris Lattner28ea9b12010-11-02 17:30:52 +0000415 /// Mnemonic - This is the first token of the matched instruction, its
416 /// mnemonic.
417 StringRef Mnemonic;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000418
Chris Lattnerd64b7c02010-11-02 01:03:43 +0000419 /// AsmOperands - The textual operands that this instruction matches,
Chris Lattnera7a903e2010-11-02 17:34:28 +0000420 /// annotated with a class and where in the OperandList they were defined.
421 /// This directly corresponds to the tokenized AsmString after the mnemonic is
422 /// removed.
Jim Grosbacha37e2292012-04-19 17:52:34 +0000423 SmallVector<AsmOperand, 8> AsmOperands;
Daniel Dunbare10787e2009-08-07 08:26:05 +0000424
Daniel Dunbareefe8612010-07-19 05:44:09 +0000425 /// Predicates - The required subtarget features to match this instruction.
David Blaikief6d4b1c2014-11-28 22:01:06 +0000426 SmallVector<SubtargetFeatureInfo*, 4> RequiredFeatures;
Daniel Dunbareefe8612010-07-19 05:44:09 +0000427
Daniel Dunbar71330282009-08-08 05:24:34 +0000428 /// ConversionFnKind - The enum value which is passed to the generated
Chad Rosierba284b92012-09-05 01:02:38 +0000429 /// convertToMCInst to convert parsed operands into an MCInst for this
Daniel Dunbar71330282009-08-08 05:24:34 +0000430 /// function.
431 std::string ConversionFnKind;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000432
Joey Gouly0e76fa72013-09-12 10:28:05 +0000433 /// If this instruction is deprecated in some form.
434 bool HasDeprecation;
435
Chris Lattnerad776812010-11-01 05:06:45 +0000436 MatchableInfo(const CodeGenInstruction &CGI)
David Blaikie4e3c6ca2014-11-28 21:59:58 +0000437 : AsmVariantID(0), TheDef(CGI.TheDef), AsmString(CGI.AsmString),
438 DefRec(&CGI) {}
Chris Lattner39bc53b2010-11-01 04:34:44 +0000439
David Blaikie4e3c6ca2014-11-28 21:59:58 +0000440 MatchableInfo(std::unique_ptr<CodeGenInstAlias> Alias)
441 : AsmVariantID(0), TheDef(Alias->TheDef), AsmString(Alias->AsmString),
442 DefRec(Alias.release()) {}
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000443
David Blaikie4e3c6ca2014-11-28 21:59:58 +0000444 ~MatchableInfo() { delete DefRec.dyn_cast<const CodeGenInstAlias *>(); }
Craig Topperce274892014-11-28 05:01:21 +0000445
Jim Grosbach31c2d3f2012-04-19 23:59:23 +0000446 // Two-operand aliases clone from the main matchable, but mark the second
447 // operand as a tied operand of the first for purposes of the assembler.
448 void formTwoOperandAlias(StringRef Constraint);
449
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000450 void initialize(const AsmMatcherInfo &Info,
Craig Topper71b7b682014-08-21 05:55:13 +0000451 SmallPtrSetImpl<Record*> &SingletonRegisters,
Jim Grosbach3263a072012-04-11 21:02:33 +0000452 int AsmVariantNo, std::string &RegisterPrefix);
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000453
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000454 /// validate - Return true if this matchable is a valid thing to match against
Chris Lattnerad776812010-11-01 05:06:45 +0000455 /// and perform a bunch of validity checking.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000456 bool validate(StringRef CommentDelimiter, bool Hack) const;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000457
Jim Grosbach0bba00d2012-01-24 21:06:59 +0000458 /// extractSingletonRegisterForAsmOperand - Extract singleton register,
Devang Patel6d676e42012-01-07 01:33:34 +0000459 /// if present, from specified token.
460 void
461 extractSingletonRegisterForAsmOperand(unsigned i, const AsmMatcherInfo &Info,
462 std::string &RegisterPrefix);
Daniel Dunbare10787e2009-08-07 08:26:05 +0000463
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000464 /// findAsmOperand - Find the AsmOperand with the specified name and
Bob Wilsonb9b24222011-01-26 19:44:55 +0000465 /// suboperand index.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000466 int findAsmOperand(StringRef N, int SubOpIdx) const {
Bob Wilsonb9b24222011-01-26 19:44:55 +0000467 for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i)
468 if (N == AsmOperands[i].SrcOpName &&
469 SubOpIdx == AsmOperands[i].SubOpIdx)
470 return i;
471 return -1;
472 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000473
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000474 /// findAsmOperandNamed - Find the first AsmOperand with the specified name.
Bob Wilsonb9b24222011-01-26 19:44:55 +0000475 /// This does not check the suboperand index.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000476 int findAsmOperandNamed(StringRef N) const {
Chris Lattner897a1402010-11-04 01:55:23 +0000477 for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i)
478 if (N == AsmOperands[i].SrcOpName)
479 return i;
480 return -1;
481 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000482
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000483 void buildInstructionResultOperands();
484 void buildAliasResultOperands();
Chris Lattner743081d2010-11-04 00:43:46 +0000485
Chris Lattnerad776812010-11-01 05:06:45 +0000486 /// operator< - Compare two matchables.
487 bool operator<(const MatchableInfo &RHS) const {
Chris Lattner82d88ce2010-09-06 21:01:37 +0000488 // The primary comparator is the instruction mnemonic.
Chris Lattner28ea9b12010-11-02 17:30:52 +0000489 if (Mnemonic != RHS.Mnemonic)
490 return Mnemonic < RHS.Mnemonic;
Jim Grosbach0eccfc22010-10-29 22:13:48 +0000491
Chris Lattnerd64b7c02010-11-02 01:03:43 +0000492 if (AsmOperands.size() != RHS.AsmOperands.size())
493 return AsmOperands.size() < RHS.AsmOperands.size();
Daniel Dunbar3239f022009-08-09 04:00:06 +0000494
Daniel Dunbard9631912009-08-09 08:23:23 +0000495 // Compare lexicographically by operand. The matcher validates that other
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000496 // orderings wouldn't be ambiguous using \see couldMatchAmbiguouslyWith().
Chris Lattnerd64b7c02010-11-02 01:03:43 +0000497 for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
498 if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class)
Daniel Dunbar3239f022009-08-09 04:00:06 +0000499 return true;
Chris Lattnerd64b7c02010-11-02 01:03:43 +0000500 if (*RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
Daniel Dunbard9631912009-08-09 08:23:23 +0000501 return false;
502 }
503
Andrew Trick818f5ac2012-08-29 03:52:57 +0000504 // Give matches that require more features higher precedence. This is useful
505 // because we cannot define AssemblerPredicates with the negation of
506 // processor features. For example, ARM v6 "nop" may be either a HINT or
507 // MOV. With v6, we want to match HINT. The assembler has no way to
508 // predicate MOV under "NoV6", but HINT will always match first because it
509 // requires V6 while MOV does not.
510 if (RequiredFeatures.size() != RHS.RequiredFeatures.size())
511 return RequiredFeatures.size() > RHS.RequiredFeatures.size();
512
Daniel Dunbar3239f022009-08-09 04:00:06 +0000513 return false;
514 }
515
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000516 /// couldMatchAmbiguouslyWith - Check whether this matchable could
Dmitri Gribenko8d302402012-09-15 20:22:05 +0000517 /// ambiguously match the same set of operands as \p RHS (without being a
Daniel Dunbarf573b562009-08-09 06:05:33 +0000518 /// strictly superior match).
Craig Topper42bd8192014-11-28 03:53:00 +0000519 bool couldMatchAmbiguouslyWith(const MatchableInfo &RHS) const {
Chris Lattnere3c48de2010-11-01 23:57:23 +0000520 // The primary comparator is the instruction mnemonic.
Chris Lattner28ea9b12010-11-02 17:30:52 +0000521 if (Mnemonic != RHS.Mnemonic)
Chris Lattnere3c48de2010-11-01 23:57:23 +0000522 return false;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000523
Daniel Dunbarf573b562009-08-09 06:05:33 +0000524 // The number of operands is unambiguous.
Chris Lattnerd64b7c02010-11-02 01:03:43 +0000525 if (AsmOperands.size() != RHS.AsmOperands.size())
Daniel Dunbarf573b562009-08-09 06:05:33 +0000526 return false;
527
Daniel Dunbare1974092010-01-23 00:26:16 +0000528 // Otherwise, make sure the ordering of the two instructions is unambiguous
529 // by checking that either (a) a token or operand kind discriminates them,
530 // or (b) the ordering among equivalent kinds is consistent.
531
Daniel Dunbarf573b562009-08-09 06:05:33 +0000532 // Tokens and operand kinds are unambiguous (assuming a correct target
533 // specific parser).
Chris Lattnerd64b7c02010-11-02 01:03:43 +0000534 for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i)
535 if (AsmOperands[i].Class->Kind != RHS.AsmOperands[i].Class->Kind ||
536 AsmOperands[i].Class->Kind == ClassInfo::Token)
537 if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class ||
538 *RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
Daniel Dunbarf573b562009-08-09 06:05:33 +0000539 return false;
Jim Grosbach0eccfc22010-10-29 22:13:48 +0000540
Daniel Dunbarf573b562009-08-09 06:05:33 +0000541 // Otherwise, this operand could commute if all operands are equivalent, or
542 // there is a pair of operands that compare less than and a pair that
543 // compare greater than.
544 bool HasLT = false, HasGT = false;
Chris Lattnerd64b7c02010-11-02 01:03:43 +0000545 for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
546 if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class)
Daniel Dunbarf573b562009-08-09 06:05:33 +0000547 HasLT = true;
Chris Lattnerd64b7c02010-11-02 01:03:43 +0000548 if (*RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
Daniel Dunbarf573b562009-08-09 06:05:33 +0000549 HasGT = true;
550 }
551
552 return !(HasLT ^ HasGT);
553 }
554
Craig Topper42bd8192014-11-28 03:53:00 +0000555 void dump() const;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000556
Chris Lattner28ea9b12010-11-02 17:30:52 +0000557private:
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000558 void tokenizeAsmString(const AsmMatcherInfo &Info);
Daniel Dunbare10787e2009-08-07 08:26:05 +0000559};
560
Daniel Dunbareefe8612010-07-19 05:44:09 +0000561/// SubtargetFeatureInfo - Helper class for storing information on a subtarget
562/// feature which participates in instruction matching.
563struct SubtargetFeatureInfo {
564 /// \brief The predicate record for this feature.
565 Record *TheDef;
566
567 /// \brief An unique index assigned to represent this feature.
Tim Northover26bb14e2014-08-18 11:49:42 +0000568 uint64_t Index;
Daniel Dunbareefe8612010-07-19 05:44:09 +0000569
Tim Northover26bb14e2014-08-18 11:49:42 +0000570 SubtargetFeatureInfo(Record *D, uint64_t Idx) : TheDef(D), Index(Idx) {}
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000571
Daniel Dunbareefe8612010-07-19 05:44:09 +0000572 /// \brief The name of the enumerated constant identifying this feature.
Chris Lattnera0e87192010-10-30 20:07:57 +0000573 std::string getEnumName() const {
574 return "Feature_" + TheDef->getName();
575 }
Daniel Sanders3ea92742014-05-21 10:11:24 +0000576
Craig Topper42bd8192014-11-28 03:53:00 +0000577 void dump() const {
Daniel Sanders3ea92742014-05-21 10:11:24 +0000578 errs() << getEnumName() << " " << Index << "\n";
579 TheDef->dump();
580 }
Daniel Dunbareefe8612010-07-19 05:44:09 +0000581};
582
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +0000583struct OperandMatchEntry {
584 unsigned OperandMask;
Craig Topper42bd8192014-11-28 03:53:00 +0000585 const MatchableInfo* MI;
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +0000586 ClassInfo *CI;
587
Craig Topper42bd8192014-11-28 03:53:00 +0000588 static OperandMatchEntry create(const MatchableInfo *mi, ClassInfo *ci,
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +0000589 unsigned opMask) {
590 OperandMatchEntry X;
591 X.OperandMask = opMask;
592 X.CI = ci;
593 X.MI = mi;
594 return X;
595 }
596};
597
598
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000599class AsmMatcherInfo {
600public:
Chris Lattner77d369c2010-12-13 00:23:57 +0000601 /// Tracked Records
Chris Lattner89dcb682010-12-15 04:48:22 +0000602 RecordKeeper &Records;
Chris Lattner77d369c2010-12-13 00:23:57 +0000603
Daniel Dunbare4318712009-08-11 20:59:47 +0000604 /// The tablegen AsmParser record.
605 Record *AsmParser;
606
Chris Lattnerb80ab362010-11-01 01:37:30 +0000607 /// Target - The target information.
608 CodeGenTarget &Target;
609
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000610 /// The classes which are needed for matching.
David Blaikied749e342014-11-28 20:35:57 +0000611 std::forward_list<ClassInfo> Classes;
Jim Grosbach0eccfc22010-10-29 22:13:48 +0000612
Chris Lattnerad776812010-11-01 05:06:45 +0000613 /// The information on the matchables to match.
David Blaikie6c13c362014-11-28 21:20:24 +0000614 std::forward_list<MatchableInfo> Matchables;
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000615
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +0000616 /// Info for custom matching operands by user defined methods.
617 std::vector<OperandMatchEntry> OperandMatchInfo;
618
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000619 /// Map of Register records to their class information.
Sean Silvac8f56572012-09-19 01:47:01 +0000620 typedef std::map<Record*, ClassInfo*, LessRecordByID> RegisterClassesTy;
621 RegisterClassesTy RegisterClasses;
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000622
Daniel Dunbareefe8612010-07-19 05:44:09 +0000623 /// Map of Predicate records to their subtarget information.
David Blaikief6d4b1c2014-11-28 22:01:06 +0000624 std::map<Record*, std::unique_ptr<SubtargetFeatureInfo>,
625 LessRecordByID> SubtargetFeatures;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000626
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +0000627 /// Map of AsmOperandClass records to their class information.
628 std::map<Record*, ClassInfo*> AsmOperandClasses;
629
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000630private:
631 /// Map of token to class information which has already been constructed.
632 std::map<std::string, ClassInfo*> TokenClasses;
633
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000634 /// Map of RegisterClass records to their class information.
635 std::map<Record*, ClassInfo*> RegisterClassClasses;
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000636
637private:
638 /// getTokenClass - Lookup or create the class for the given token.
Chris Lattner60db0a62010-02-09 00:34:28 +0000639 ClassInfo *getTokenClass(StringRef Token);
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000640
641 /// getOperandClass - Lookup or create the class for the given operand.
Bob Wilsonb9b24222011-01-26 19:44:55 +0000642 ClassInfo *getOperandClass(const CGIOperandList::OperandInfo &OI,
Jim Grosbachd1f1b792011-10-28 22:32:53 +0000643 int SubOpIdx);
644 ClassInfo *getOperandClass(Record *Rec, int SubOpIdx);
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000645
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000646 /// buildRegisterClasses - Build the ClassInfo* instances for register
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000647 /// classes.
Craig Topper71b7b682014-08-21 05:55:13 +0000648 void buildRegisterClasses(SmallPtrSetImpl<Record*> &SingletonRegisters);
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000649
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000650 /// buildOperandClasses - Build the ClassInfo* instances for user defined
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000651 /// operand classes.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000652 void buildOperandClasses();
Daniel Dunbarbb98db22009-08-11 02:59:53 +0000653
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000654 void buildInstructionOperandReference(MatchableInfo *II, StringRef OpName,
Bob Wilsonb9b24222011-01-26 19:44:55 +0000655 unsigned AsmOpIdx);
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000656 void buildAliasOperandReference(MatchableInfo *II, StringRef OpName,
Chris Lattner4efe13d2010-11-04 02:11:18 +0000657 MatchableInfo::AsmOperand &Op);
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000658
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000659public:
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000660 AsmMatcherInfo(Record *AsmParser,
661 CodeGenTarget &Target,
Chris Lattner89dcb682010-12-15 04:48:22 +0000662 RecordKeeper &Records);
Daniel Dunbare4318712009-08-11 20:59:47 +0000663
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000664 /// buildInfo - Construct the various tables used during matching.
665 void buildInfo();
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000666
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000667 /// buildOperandMatchInfo - Build the necessary information to handle user
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +0000668 /// defined operand parsing methods.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000669 void buildOperandMatchInfo();
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +0000670
Chris Lattner43690072010-10-30 20:15:02 +0000671 /// getSubtargetFeature - Lookup or create the subtarget feature info for the
672 /// given operand.
David Blaikief6d4b1c2014-11-28 22:01:06 +0000673 SubtargetFeatureInfo *getSubtargetFeature(Record *Def) const {
Chris Lattner43690072010-10-30 20:15:02 +0000674 assert(Def->isSubClassOf("Predicate") && "Invalid predicate type!");
Craig Topper42bd8192014-11-28 03:53:00 +0000675 const auto &I = SubtargetFeatures.find(Def);
David Blaikief6d4b1c2014-11-28 22:01:06 +0000676 return I == SubtargetFeatures.end() ? nullptr : I->second.get();
Chris Lattner43690072010-10-30 20:15:02 +0000677 }
Chris Lattner77d369c2010-12-13 00:23:57 +0000678
Chris Lattner89dcb682010-12-15 04:48:22 +0000679 RecordKeeper &getRecords() const {
680 return Records;
Chris Lattner77d369c2010-12-13 00:23:57 +0000681 }
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000682};
683
Jakob Stoklund Olesene6aed132012-06-11 15:37:55 +0000684} // End anonymous namespace
Daniel Dunbare10787e2009-08-07 08:26:05 +0000685
Craig Topper42bd8192014-11-28 03:53:00 +0000686void MatchableInfo::dump() const {
Chris Lattner9f093812010-11-06 06:43:11 +0000687 errs() << TheDef->getName() << " -- " << "flattened:\"" << AsmString <<"\"\n";
Daniel Dunbare10787e2009-08-07 08:26:05 +0000688
Chris Lattnerd64b7c02010-11-02 01:03:43 +0000689 for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
Craig Topper42bd8192014-11-28 03:53:00 +0000690 const AsmOperand &Op = AsmOperands[i];
Daniel Dunbarc32aa062009-08-09 05:18:30 +0000691 errs() << " op[" << i << "] = " << Op.Class->ClassName << " - ";
Chris Lattner4779e3e92010-11-04 00:57:06 +0000692 errs() << '\"' << Op.Token << "\"\n";
Daniel Dunbare10787e2009-08-07 08:26:05 +0000693 }
694}
695
Jim Grosbach31c2d3f2012-04-19 23:59:23 +0000696static std::pair<StringRef, StringRef>
Jakob Stoklund Olesend7b66962012-08-22 23:33:58 +0000697parseTwoOperandConstraint(StringRef S, ArrayRef<SMLoc> Loc) {
Jim Grosbach31c2d3f2012-04-19 23:59:23 +0000698 // Split via the '='.
699 std::pair<StringRef, StringRef> Ops = S.split('=');
700 if (Ops.second == "")
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000701 PrintFatalError(Loc, "missing '=' in two-operand alias constraint");
Jim Grosbach31c2d3f2012-04-19 23:59:23 +0000702 // Trim whitespace and the leading '$' on the operand names.
703 size_t start = Ops.first.find_first_of('$');
704 if (start == std::string::npos)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000705 PrintFatalError(Loc, "expected '$' prefix on asm operand name");
Jim Grosbach31c2d3f2012-04-19 23:59:23 +0000706 Ops.first = Ops.first.slice(start + 1, std::string::npos);
707 size_t end = Ops.first.find_last_of(" \t");
708 Ops.first = Ops.first.slice(0, end);
709 // Now the second operand.
710 start = Ops.second.find_first_of('$');
711 if (start == std::string::npos)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000712 PrintFatalError(Loc, "expected '$' prefix on asm operand name");
Jim Grosbach31c2d3f2012-04-19 23:59:23 +0000713 Ops.second = Ops.second.slice(start + 1, std::string::npos);
714 end = Ops.second.find_last_of(" \t");
715 Ops.first = Ops.first.slice(0, end);
716 return Ops;
717}
718
719void MatchableInfo::formTwoOperandAlias(StringRef Constraint) {
720 // Figure out which operands are aliased and mark them as tied.
721 std::pair<StringRef, StringRef> Ops =
722 parseTwoOperandConstraint(Constraint, TheDef->getLoc());
723
724 // Find the AsmOperands that refer to the operands we're aliasing.
725 int SrcAsmOperand = findAsmOperandNamed(Ops.first);
726 int DstAsmOperand = findAsmOperandNamed(Ops.second);
727 if (SrcAsmOperand == -1)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000728 PrintFatalError(TheDef->getLoc(),
Benjamin Kramer48e7e852014-03-29 17:17:15 +0000729 "unknown source two-operand alias operand '" + Ops.first +
730 "'.");
Jim Grosbach31c2d3f2012-04-19 23:59:23 +0000731 if (DstAsmOperand == -1)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000732 PrintFatalError(TheDef->getLoc(),
Benjamin Kramer48e7e852014-03-29 17:17:15 +0000733 "unknown destination two-operand alias operand '" +
734 Ops.second + "'.");
Jim Grosbach31c2d3f2012-04-19 23:59:23 +0000735
736 // Find the ResOperand that refers to the operand we're aliasing away
737 // and update it to refer to the combined operand instead.
738 for (unsigned i = 0, e = ResOperands.size(); i != e; ++i) {
739 ResOperand &Op = ResOperands[i];
740 if (Op.Kind == ResOperand::RenderAsmOperand &&
741 Op.AsmOperandNum == (unsigned)SrcAsmOperand) {
742 Op.AsmOperandNum = DstAsmOperand;
743 break;
744 }
745 }
746 // Remove the AsmOperand for the alias operand.
747 AsmOperands.erase(AsmOperands.begin() + SrcAsmOperand);
748 // Adjust the ResOperand references to any AsmOperands that followed
749 // the one we just deleted.
750 for (unsigned i = 0, e = ResOperands.size(); i != e; ++i) {
751 ResOperand &Op = ResOperands[i];
752 switch(Op.Kind) {
753 default:
754 // Nothing to do for operands that don't reference AsmOperands.
755 break;
756 case ResOperand::RenderAsmOperand:
757 if (Op.AsmOperandNum > (unsigned)SrcAsmOperand)
758 --Op.AsmOperandNum;
759 break;
760 case ResOperand::TiedOperand:
761 if (Op.TiedOperandNum > (unsigned)SrcAsmOperand)
762 --Op.TiedOperandNum;
763 break;
764 }
765 }
766}
767
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000768void MatchableInfo::initialize(const AsmMatcherInfo &Info,
Craig Topper71b7b682014-08-21 05:55:13 +0000769 SmallPtrSetImpl<Record*> &SingletonRegisters,
Devang Patel6d676e42012-01-07 01:33:34 +0000770 int AsmVariantNo, std::string &RegisterPrefix) {
Devang Patel9bdc5052012-01-10 17:50:43 +0000771 AsmVariantID = AsmVariantNo;
Jim Grosbach0bba00d2012-01-24 21:06:59 +0000772 AsmString =
Devang Patel6d676e42012-01-07 01:33:34 +0000773 CodeGenInstruction::FlattenAsmStringVariants(AsmString, AsmVariantNo);
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000774
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000775 tokenizeAsmString(Info);
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000776
Chris Lattnerba465f92010-11-01 04:53:48 +0000777 // Compute the require features.
778 std::vector<Record*> Predicates =TheDef->getValueAsListOfDefs("Predicates");
779 for (unsigned i = 0, e = Predicates.size(); i != e; ++i)
David Blaikief6d4b1c2014-11-28 22:01:06 +0000780 if (SubtargetFeatureInfo *Feature =
781 Info.getSubtargetFeature(Predicates[i]))
Chris Lattnerba465f92010-11-01 04:53:48 +0000782 RequiredFeatures.push_back(Feature);
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000783
Chris Lattnerba465f92010-11-01 04:53:48 +0000784 // Collect singleton registers, if used.
Chris Lattner28ea9b12010-11-02 17:30:52 +0000785 for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
Devang Patel6d676e42012-01-07 01:33:34 +0000786 extractSingletonRegisterForAsmOperand(i, Info, RegisterPrefix);
787 if (Record *Reg = AsmOperands[i].SingletonReg)
Chris Lattnerba465f92010-11-01 04:53:48 +0000788 SingletonRegisters.insert(Reg);
789 }
Joey Gouly0e76fa72013-09-12 10:28:05 +0000790
791 const RecordVal *DepMask = TheDef->getValue("DeprecatedFeatureMask");
792 if (!DepMask)
793 DepMask = TheDef->getValue("ComplexDeprecationPredicate");
794
795 HasDeprecation =
796 DepMask ? !DepMask->getValue()->getAsUnquotedString().empty() : false;
Chris Lattnerba465f92010-11-01 04:53:48 +0000797}
798
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000799/// tokenizeAsmString - Tokenize a simplified assembly string.
800void MatchableInfo::tokenizeAsmString(const AsmMatcherInfo &Info) {
Chris Lattner28ea9b12010-11-02 17:30:52 +0000801 StringRef String = AsmString;
802 unsigned Prev = 0;
803 bool InTok = true;
804 for (unsigned i = 0, e = String.size(); i != e; ++i) {
805 switch (String[i]) {
806 case '[':
807 case ']':
808 case '*':
809 case '!':
810 case ' ':
811 case '\t':
812 case ',':
813 if (InTok) {
Chris Lattner896cf042010-11-03 19:47:34 +0000814 AsmOperands.push_back(AsmOperand(String.slice(Prev, i)));
Chris Lattner28ea9b12010-11-02 17:30:52 +0000815 InTok = false;
816 }
817 if (!isspace(String[i]) && String[i] != ',')
Chris Lattner896cf042010-11-03 19:47:34 +0000818 AsmOperands.push_back(AsmOperand(String.substr(i, 1)));
Chris Lattner28ea9b12010-11-02 17:30:52 +0000819 Prev = i + 1;
820 break;
821
822 case '\\':
823 if (InTok) {
Chris Lattner896cf042010-11-03 19:47:34 +0000824 AsmOperands.push_back(AsmOperand(String.slice(Prev, i)));
Chris Lattner28ea9b12010-11-02 17:30:52 +0000825 InTok = false;
826 }
827 ++i;
828 assert(i != String.size() && "Invalid quoted character");
Chris Lattner896cf042010-11-03 19:47:34 +0000829 AsmOperands.push_back(AsmOperand(String.substr(i, 1)));
Chris Lattner28ea9b12010-11-02 17:30:52 +0000830 Prev = i + 1;
831 break;
832
833 case '$': {
Chris Lattner28ea9b12010-11-02 17:30:52 +0000834 if (InTok) {
Chris Lattner896cf042010-11-03 19:47:34 +0000835 AsmOperands.push_back(AsmOperand(String.slice(Prev, i)));
Chris Lattner28ea9b12010-11-02 17:30:52 +0000836 InTok = false;
837 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000838
Chris Lattnerd6746d52010-11-06 22:06:03 +0000839 // If this isn't "${", treat like a normal token.
840 if (i + 1 == String.size() || String[i + 1] != '{') {
841 Prev = i;
842 break;
843 }
Chris Lattner28ea9b12010-11-02 17:30:52 +0000844
845 StringRef::iterator End = std::find(String.begin() + i, String.end(),'}');
846 assert(End != String.end() && "Missing brace in operand reference!");
847 size_t EndPos = End - String.begin();
Chris Lattner896cf042010-11-03 19:47:34 +0000848 AsmOperands.push_back(AsmOperand(String.slice(i, EndPos+1)));
Chris Lattner28ea9b12010-11-02 17:30:52 +0000849 Prev = EndPos + 1;
850 i = EndPos;
851 break;
852 }
853
854 case '.':
Vladimir Medicd3dade22013-08-01 09:25:27 +0000855 if (!Info.AsmParser->getValueAsBit("MnemonicContainsDot")) {
Vladimir Medic75429ad2013-07-16 09:22:38 +0000856 if (InTok)
857 AsmOperands.push_back(AsmOperand(String.slice(Prev, i)));
858 Prev = i;
859 }
Chris Lattner28ea9b12010-11-02 17:30:52 +0000860 InTok = true;
861 break;
862
863 default:
864 InTok = true;
865 }
866 }
867 if (InTok && Prev != String.size())
Chris Lattner896cf042010-11-03 19:47:34 +0000868 AsmOperands.push_back(AsmOperand(String.substr(Prev)));
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000869
Chris Lattner28ea9b12010-11-02 17:30:52 +0000870 // The first token of the instruction is the mnemonic, which must be a
871 // simple string, not a $foo variable or a singleton register.
Jim Grosbach8eeb3532011-11-30 23:16:25 +0000872 if (AsmOperands.empty())
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000873 PrintFatalError(TheDef->getLoc(),
Jim Grosbach8eeb3532011-11-30 23:16:25 +0000874 "Instruction '" + TheDef->getName() + "' has no tokens");
Chris Lattner28ea9b12010-11-02 17:30:52 +0000875 Mnemonic = AsmOperands[0].Token;
Jim Grosbach90e8c5e2012-05-06 17:33:14 +0000876 if (Mnemonic.empty())
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000877 PrintFatalError(TheDef->getLoc(),
Jim Grosbach90e8c5e2012-05-06 17:33:14 +0000878 "Missing instruction mnemonic");
Devang Patel6d676e42012-01-07 01:33:34 +0000879 // FIXME : Check and raise an error if it is a register.
Devang Pateld803f45e2012-01-07 01:22:23 +0000880 if (Mnemonic[0] == '$')
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000881 PrintFatalError(TheDef->getLoc(),
Benjamin Kramer48e7e852014-03-29 17:17:15 +0000882 "Invalid instruction mnemonic '" + Mnemonic + "'!");
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000883
Chris Lattner28ea9b12010-11-02 17:30:52 +0000884 // Remove the first operand, it is tracked in the mnemonic field.
885 AsmOperands.erase(AsmOperands.begin());
886}
887
Jim Grosbach8c2beaa2012-04-19 17:52:32 +0000888bool MatchableInfo::validate(StringRef CommentDelimiter, bool Hack) const {
Chris Lattnerad776812010-11-01 05:06:45 +0000889 // Reject matchables with no .s string.
Chris Lattner39bc53b2010-11-01 04:34:44 +0000890 if (AsmString.empty())
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000891 PrintFatalError(TheDef->getLoc(), "instruction with empty asm string");
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000892
Chris Lattnerad776812010-11-01 05:06:45 +0000893 // Reject any matchables with a newline in them, they should be marked
Chris Lattner39bc53b2010-11-01 04:34:44 +0000894 // isCodeGenOnly if they are pseudo instructions.
895 if (AsmString.find('\n') != std::string::npos)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000896 PrintFatalError(TheDef->getLoc(),
Chris Lattner39bc53b2010-11-01 04:34:44 +0000897 "multiline instruction is not valid for the asmparser, "
898 "mark it isCodeGenOnly");
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000899
Chris Lattner178f4bb2010-11-01 04:44:29 +0000900 // Remove comments from the asm string. We know that the asmstring only
901 // has one line.
902 if (!CommentDelimiter.empty() &&
903 StringRef(AsmString).find(CommentDelimiter) != StringRef::npos)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000904 PrintFatalError(TheDef->getLoc(),
Chris Lattner178f4bb2010-11-01 04:44:29 +0000905 "asmstring for instruction has comment character in it, "
906 "mark it isCodeGenOnly");
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000907
Chris Lattnerad776812010-11-01 05:06:45 +0000908 // Reject matchables with operand modifiers, these aren't something we can
Bob Wilson266d2ba2011-01-20 18:38:07 +0000909 // handle, the target should be refactored to use operands instead of
910 // modifiers.
Chris Lattner39bc53b2010-11-01 04:34:44 +0000911 //
912 // Also, check for instructions which reference the operand multiple times;
913 // this implies a constraint we would not honor.
914 std::set<std::string> OperandNames;
Chris Lattner28ea9b12010-11-02 17:30:52 +0000915 for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
916 StringRef Tok = AsmOperands[i].Token;
917 if (Tok[0] == '$' && Tok.find(':') != StringRef::npos)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000918 PrintFatalError(TheDef->getLoc(),
Benjamin Kramer48e7e852014-03-29 17:17:15 +0000919 "matchable with operand modifier '" + Tok +
920 "' not supported by asm matcher. Mark isCodeGenOnly!");
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000921
Chris Lattnerad776812010-11-01 05:06:45 +0000922 // Verify that any operand is only mentioned once.
Chris Lattner4d23eb22010-11-02 23:18:43 +0000923 // We reject aliases and ignore instructions for now.
Chris Lattner28ea9b12010-11-02 17:30:52 +0000924 if (Tok[0] == '$' && !OperandNames.insert(Tok).second) {
Chris Lattnerad776812010-11-01 05:06:45 +0000925 if (!Hack)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +0000926 PrintFatalError(TheDef->getLoc(),
Benjamin Kramer48e7e852014-03-29 17:17:15 +0000927 "ERROR: matchable with tied operand '" + Tok +
928 "' can never be matched!");
Chris Lattnerad776812010-11-01 05:06:45 +0000929 // FIXME: Should reject these. The ARM backend hits this with $lane in a
930 // bunch of instructions. It is unclear what the right answer is.
Chris Lattner39bc53b2010-11-01 04:34:44 +0000931 DEBUG({
Chris Lattner9f093812010-11-06 06:43:11 +0000932 errs() << "warning: '" << TheDef->getName() << "': "
Chris Lattnerad776812010-11-01 05:06:45 +0000933 << "ignoring instruction with tied operand '"
Benjamin Kramer48e7e852014-03-29 17:17:15 +0000934 << Tok << "'\n";
Chris Lattner39bc53b2010-11-01 04:34:44 +0000935 });
936 return false;
937 }
938 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000939
Chris Lattner39bc53b2010-11-01 04:34:44 +0000940 return true;
941}
942
Jim Grosbach0bba00d2012-01-24 21:06:59 +0000943/// extractSingletonRegisterForAsmOperand - Extract singleton register,
Devang Patel700e2e72012-01-09 21:30:46 +0000944/// if present, from specified token.
Devang Patel6d676e42012-01-07 01:33:34 +0000945void MatchableInfo::
Jim Grosbach0bba00d2012-01-24 21:06:59 +0000946extractSingletonRegisterForAsmOperand(unsigned OperandNo,
Devang Patel700e2e72012-01-09 21:30:46 +0000947 const AsmMatcherInfo &Info,
Jim Grosbach3263a072012-04-11 21:02:33 +0000948 std::string &RegisterPrefix) {
Devang Patel700e2e72012-01-09 21:30:46 +0000949 StringRef Tok = AsmOperands[OperandNo].Token;
Devang Patel6d676e42012-01-07 01:33:34 +0000950 if (RegisterPrefix.empty()) {
Devang Patel700e2e72012-01-09 21:30:46 +0000951 std::string LoweredTok = Tok.lower();
952 if (const CodeGenRegister *Reg = Info.Target.getRegisterByName(LoweredTok))
953 AsmOperands[OperandNo].SingletonReg = Reg->TheDef;
Devang Patel6d676e42012-01-07 01:33:34 +0000954 return;
Jim Grosbach0bba00d2012-01-24 21:06:59 +0000955 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000956
Devang Patel6d676e42012-01-07 01:33:34 +0000957 if (!Tok.startswith(RegisterPrefix))
958 return;
959
960 StringRef RegName = Tok.substr(RegisterPrefix.size());
Chris Lattner77d3ead2010-11-02 18:10:06 +0000961 if (const CodeGenRegister *Reg = Info.Target.getRegisterByName(RegName))
Devang Patel700e2e72012-01-09 21:30:46 +0000962 AsmOperands[OperandNo].SingletonReg = Reg->TheDef;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +0000963
Chris Lattnerf7a01e92010-11-01 01:47:07 +0000964 // If there is no register prefix (i.e. "%" in "%eax"), then this may
965 // be some random non-register token, just ignore it.
Devang Patel6d676e42012-01-07 01:33:34 +0000966 return;
Chris Lattnerb80ab362010-11-01 01:37:30 +0000967}
968
Chris Lattner60db0a62010-02-09 00:34:28 +0000969static std::string getEnumNameForToken(StringRef Str) {
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000970 std::string Res;
Jim Grosbach0eccfc22010-10-29 22:13:48 +0000971
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000972 for (StringRef::iterator it = Str.begin(), ie = Str.end(); it != ie; ++it) {
973 switch (*it) {
974 case '*': Res += "_STAR_"; break;
975 case '%': Res += "_PCT_"; break;
976 case ':': Res += "_COLON_"; break;
Bill Wendling4a08e562010-11-18 23:36:54 +0000977 case '!': Res += "_EXCLAIM_"; break;
Bill Wendlinga01ea892011-01-22 09:44:32 +0000978 case '.': Res += "_DOT_"; break;
Tim Northoverb3cfb282013-01-10 16:47:31 +0000979 case '<': Res += "_LT_"; break;
980 case '>': Res += "_GT_"; break;
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000981 default:
Tim Northoverb3cfb282013-01-10 16:47:31 +0000982 if ((*it >= 'A' && *it <= 'Z') ||
983 (*it >= 'a' && *it <= 'z') ||
984 (*it >= '0' && *it <= '9'))
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000985 Res += *it;
Chris Lattner33fc3e02010-10-31 19:10:56 +0000986 else
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000987 Res += "_" + utostr((unsigned) *it) + "_";
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000988 }
989 }
990
991 return Res;
992}
993
Chris Lattner60db0a62010-02-09 00:34:28 +0000994ClassInfo *AsmMatcherInfo::getTokenClass(StringRef Token) {
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000995 ClassInfo *&Entry = TokenClasses[Token];
Jim Grosbach0eccfc22010-10-29 22:13:48 +0000996
Daniel Dunbar541efcc2009-08-08 07:50:56 +0000997 if (!Entry) {
David Blaikied749e342014-11-28 20:35:57 +0000998 Classes.emplace_front();
999 Entry = &Classes.front();
Daniel Dunbar541efcc2009-08-08 07:50:56 +00001000 Entry->Kind = ClassInfo::Token;
Daniel Dunbarc32aa062009-08-09 05:18:30 +00001001 Entry->ClassName = "Token";
Daniel Dunbar541efcc2009-08-08 07:50:56 +00001002 Entry->Name = "MCK_" + getEnumNameForToken(Token);
1003 Entry->ValueName = Token;
1004 Entry->PredicateMethod = "<invalid>";
1005 Entry->RenderMethod = "<invalid>";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00001006 Entry->ParserMethod = "";
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00001007 Entry->DiagnosticType = "";
Daniel Dunbar541efcc2009-08-08 07:50:56 +00001008 }
1009
1010 return Entry;
1011}
1012
1013ClassInfo *
Bob Wilsonb9b24222011-01-26 19:44:55 +00001014AsmMatcherInfo::getOperandClass(const CGIOperandList::OperandInfo &OI,
1015 int SubOpIdx) {
1016 Record *Rec = OI.Rec;
1017 if (SubOpIdx != -1)
Sean Silva88eb8dd2012-10-10 20:24:47 +00001018 Rec = cast<DefInit>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef();
Jim Grosbachd1f1b792011-10-28 22:32:53 +00001019 return getOperandClass(Rec, SubOpIdx);
1020}
Bob Wilsonb9b24222011-01-26 19:44:55 +00001021
Jim Grosbachd1f1b792011-10-28 22:32:53 +00001022ClassInfo *
1023AsmMatcherInfo::getOperandClass(Record *Rec, int SubOpIdx) {
Owen Andersona84be6c2011-06-27 21:06:21 +00001024 if (Rec->isSubClassOf("RegisterOperand")) {
1025 // RegisterOperand may have an associated ParserMatchClass. If it does,
1026 // use it, else just fall back to the underlying register class.
1027 const RecordVal *R = Rec->getValue("ParserMatchClass");
Craig Topper24064772014-04-15 07:20:03 +00001028 if (!R || !R->getValue())
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00001029 PrintFatalError("Record `" + Rec->getName() +
1030 "' does not have a ParserMatchClass!\n");
Owen Andersona84be6c2011-06-27 21:06:21 +00001031
Sean Silvafb509ed2012-10-10 20:24:43 +00001032 if (DefInit *DI= dyn_cast<DefInit>(R->getValue())) {
Owen Andersona84be6c2011-06-27 21:06:21 +00001033 Record *MatchClass = DI->getDef();
1034 if (ClassInfo *CI = AsmOperandClasses[MatchClass])
1035 return CI;
1036 }
1037
1038 // No custom match class. Just use the register class.
1039 Record *ClassRec = Rec->getValueAsDef("RegClass");
1040 if (!ClassRec)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00001041 PrintFatalError(Rec->getLoc(), "RegisterOperand `" + Rec->getName() +
Owen Andersona84be6c2011-06-27 21:06:21 +00001042 "' has no associated register class!\n");
1043 if (ClassInfo *CI = RegisterClassClasses[ClassRec])
1044 return CI;
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00001045 PrintFatalError(Rec->getLoc(), "register class has no class info!");
Owen Andersona84be6c2011-06-27 21:06:21 +00001046 }
1047
1048
Bob Wilsonb9b24222011-01-26 19:44:55 +00001049 if (Rec->isSubClassOf("RegisterClass")) {
1050 if (ClassInfo *CI = RegisterClassClasses[Rec])
Chris Lattner77d3ead2010-11-02 18:10:06 +00001051 return CI;
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00001052 PrintFatalError(Rec->getLoc(), "register class has no class info!");
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001053 }
Daniel Dunbar8e33cb22009-08-09 07:20:21 +00001054
Jim Grosbachf6cb1ee2012-09-12 17:40:25 +00001055 if (!Rec->isSubClassOf("Operand"))
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00001056 PrintFatalError(Rec->getLoc(), "Operand `" + Rec->getName() +
Jim Grosbachf6cb1ee2012-09-12 17:40:25 +00001057 "' does not derive from class Operand!\n");
Bob Wilsonb9b24222011-01-26 19:44:55 +00001058 Record *MatchClass = Rec->getValueAsDef("ParserMatchClass");
Chris Lattner77d3ead2010-11-02 18:10:06 +00001059 if (ClassInfo *CI = AsmOperandClasses[MatchClass])
1060 return CI;
Daniel Dunbar17410a42009-08-10 18:41:10 +00001061
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00001062 PrintFatalError(Rec->getLoc(), "operand has no match class!");
Daniel Dunbar541efcc2009-08-08 07:50:56 +00001063}
1064
Tim Northoverc74e6912013-09-16 16:43:19 +00001065struct LessRegisterSet {
Tim Northover9c30f7a2013-09-16 17:33:40 +00001066 bool operator() (const RegisterSet &LHS, const RegisterSet & RHS) const {
Tim Northoverc74e6912013-09-16 16:43:19 +00001067 // std::set<T> defines its own compariso "operator<", but it
1068 // performs a lexicographical comparison by T's innate comparison
1069 // for some reason. We don't want non-deterministic pointer
1070 // comparisons so use this instead.
1071 return std::lexicographical_compare(LHS.begin(), LHS.end(),
1072 RHS.begin(), RHS.end(),
1073 LessRecordByID());
1074 }
1075};
1076
Chris Lattnerf7a01e92010-11-01 01:47:07 +00001077void AsmMatcherInfo::
Craig Topper71b7b682014-08-21 05:55:13 +00001078buildRegisterClasses(SmallPtrSetImpl<Record*> &SingletonRegisters) {
Jakob Stoklund Olesen8e188be2011-06-18 04:26:06 +00001079 const std::vector<CodeGenRegister*> &Registers =
1080 Target.getRegBank().getRegisters();
Jakob Stoklund Olesen19be2ab2011-09-29 22:28:37 +00001081 ArrayRef<CodeGenRegisterClass*> RegClassList =
1082 Target.getRegBank().getRegClasses();
Daniel Dunbar17410a42009-08-10 18:41:10 +00001083
Tim Northoverc74e6912013-09-16 16:43:19 +00001084 typedef std::set<RegisterSet, LessRegisterSet> RegisterSetSet;
1085
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001086 // The register sets used for matching.
Tim Northoverc74e6912013-09-16 16:43:19 +00001087 RegisterSetSet RegisterSets;
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001088
Jim Grosbach0eccfc22010-10-29 22:13:48 +00001089 // Gather the defined sets.
Craig Topper03ec8012014-11-25 20:11:31 +00001090 for (const CodeGenRegisterClass *RC : RegClassList)
1091 RegisterSets.insert(RegisterSet(RC->getOrder().begin(),
1092 RC->getOrder().end()));
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00001093
1094 // Add any required singleton sets.
Craig Topper03ec8012014-11-25 20:11:31 +00001095 for (Record *Rec : SingletonRegisters) {
Tim Northoverc74e6912013-09-16 16:43:19 +00001096 RegisterSets.insert(RegisterSet(&Rec, &Rec + 1));
Chris Lattnerf7a01e92010-11-01 01:47:07 +00001097 }
Jim Grosbach0eccfc22010-10-29 22:13:48 +00001098
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001099 // Introduce derived sets where necessary (when a register does not determine
1100 // a unique register set class), and build the mapping of registers to the set
1101 // they should classify to.
Tim Northoverc74e6912013-09-16 16:43:19 +00001102 std::map<Record*, RegisterSet> RegisterMap;
Craig Topper03ec8012014-11-25 20:11:31 +00001103 for (const CodeGenRegister *CGR : Registers) {
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001104 // Compute the intersection of all sets containing this register.
Tim Northoverc74e6912013-09-16 16:43:19 +00001105 RegisterSet ContainingSet;
Jim Grosbach0eccfc22010-10-29 22:13:48 +00001106
Craig Topper03ec8012014-11-25 20:11:31 +00001107 for (const RegisterSet &RS : RegisterSets) {
1108 if (!RS.count(CGR->TheDef))
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001109 continue;
1110
1111 if (ContainingSet.empty()) {
Craig Topper03ec8012014-11-25 20:11:31 +00001112 ContainingSet = RS;
Chris Lattner77d3ead2010-11-02 18:10:06 +00001113 continue;
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001114 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001115
Tim Northoverc74e6912013-09-16 16:43:19 +00001116 RegisterSet Tmp;
Chris Lattner77d3ead2010-11-02 18:10:06 +00001117 std::swap(Tmp, ContainingSet);
Tim Northoverc74e6912013-09-16 16:43:19 +00001118 std::insert_iterator<RegisterSet> II(ContainingSet,
1119 ContainingSet.begin());
Craig Topper03ec8012014-11-25 20:11:31 +00001120 std::set_intersection(Tmp.begin(), Tmp.end(), RS.begin(), RS.end(), II,
Tim Northoverc74e6912013-09-16 16:43:19 +00001121 LessRecordByID());
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001122 }
1123
1124 if (!ContainingSet.empty()) {
1125 RegisterSets.insert(ContainingSet);
Craig Topper03ec8012014-11-25 20:11:31 +00001126 RegisterMap.insert(std::make_pair(CGR->TheDef, ContainingSet));
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001127 }
1128 }
1129
1130 // Construct the register classes.
Tim Northoverc74e6912013-09-16 16:43:19 +00001131 std::map<RegisterSet, ClassInfo*, LessRegisterSet> RegisterSetClasses;
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001132 unsigned Index = 0;
Craig Topper03ec8012014-11-25 20:11:31 +00001133 for (const RegisterSet &RS : RegisterSets) {
David Blaikied749e342014-11-28 20:35:57 +00001134 Classes.emplace_front();
1135 ClassInfo *CI = &Classes.front();
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001136 CI->Kind = ClassInfo::RegisterClass0 + Index;
1137 CI->ClassName = "Reg" + utostr(Index);
1138 CI->Name = "MCK_Reg" + utostr(Index);
1139 CI->ValueName = "";
1140 CI->PredicateMethod = ""; // unused
1141 CI->RenderMethod = "addRegOperands";
Craig Topper03ec8012014-11-25 20:11:31 +00001142 CI->Registers = RS;
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00001143 // FIXME: diagnostic type.
1144 CI->DiagnosticType = "";
Craig Topper03ec8012014-11-25 20:11:31 +00001145 RegisterSetClasses.insert(std::make_pair(RS, CI));
1146 ++Index;
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001147 }
1148
1149 // Find the superclasses; we could compute only the subgroup lattice edges,
1150 // but there isn't really a point.
Craig Topper03ec8012014-11-25 20:11:31 +00001151 for (const RegisterSet &RS : RegisterSets) {
1152 ClassInfo *CI = RegisterSetClasses[RS];
1153 for (const RegisterSet &RS2 : RegisterSets)
1154 if (RS != RS2 &&
1155 std::includes(RS2.begin(), RS2.end(), RS.begin(), RS.end(),
Tim Northoverc74e6912013-09-16 16:43:19 +00001156 LessRecordByID()))
Craig Topper03ec8012014-11-25 20:11:31 +00001157 CI->SuperClasses.push_back(RegisterSetClasses[RS2]);
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001158 }
1159
1160 // Name the register classes which correspond to a user defined RegisterClass.
Craig Topper03ec8012014-11-25 20:11:31 +00001161 for (const CodeGenRegisterClass *RC : RegClassList) {
Jakob Stoklund Olesenbd92dc62011-10-04 15:28:08 +00001162 // Def will be NULL for non-user defined register classes.
Craig Topper03ec8012014-11-25 20:11:31 +00001163 Record *Def = RC->getDef();
Jakob Stoklund Olesenbd92dc62011-10-04 15:28:08 +00001164 if (!Def)
1165 continue;
Craig Topper03ec8012014-11-25 20:11:31 +00001166 ClassInfo *CI = RegisterSetClasses[RegisterSet(RC->getOrder().begin(),
1167 RC->getOrder().end())];
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001168 if (CI->ValueName.empty()) {
Craig Topper03ec8012014-11-25 20:11:31 +00001169 CI->ClassName = RC->getName();
1170 CI->Name = "MCK_" + RC->getName();
1171 CI->ValueName = RC->getName();
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001172 } else
Craig Topper03ec8012014-11-25 20:11:31 +00001173 CI->ValueName = CI->ValueName + "," + RC->getName();
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001174
Jakob Stoklund Olesenbd92dc62011-10-04 15:28:08 +00001175 RegisterClassClasses.insert(std::make_pair(Def, CI));
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001176 }
1177
1178 // Populate the map for individual registers.
Tim Northoverc74e6912013-09-16 16:43:19 +00001179 for (std::map<Record*, RegisterSet>::iterator it = RegisterMap.begin(),
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001180 ie = RegisterMap.end(); it != ie; ++it)
Chris Lattner77d3ead2010-11-02 18:10:06 +00001181 RegisterClasses[it->first] = RegisterSetClasses[it->second];
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00001182
1183 // Name the register classes which correspond to singleton registers.
Craig Topper03ec8012014-11-25 20:11:31 +00001184 for (Record *Rec : SingletonRegisters) {
Chris Lattner77d3ead2010-11-02 18:10:06 +00001185 ClassInfo *CI = RegisterClasses[Rec];
Chris Lattnerf7a01e92010-11-01 01:47:07 +00001186 assert(CI && "Missing singleton register class info!");
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00001187
Chris Lattnerf7a01e92010-11-01 01:47:07 +00001188 if (CI->ValueName.empty()) {
1189 CI->ClassName = Rec->getName();
1190 CI->Name = "MCK_" + Rec->getName();
1191 CI->ValueName = Rec->getName();
1192 } else
1193 CI->ValueName = CI->ValueName + "," + Rec->getName();
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00001194 }
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001195}
1196
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001197void AsmMatcherInfo::buildOperandClasses() {
Chris Lattnere3c48de2010-11-01 23:57:23 +00001198 std::vector<Record*> AsmOperands =
1199 Records.getAllDerivedDefinitions("AsmOperandClass");
Daniel Dunbarcf181532010-01-30 01:02:37 +00001200
1201 // Pre-populate AsmOperandClasses map.
David Blaikied749e342014-11-28 20:35:57 +00001202 for (Record *Rec : AsmOperands) {
1203 Classes.emplace_front();
1204 AsmOperandClasses[Rec] = &Classes.front();
1205 }
Daniel Dunbarcf181532010-01-30 01:02:37 +00001206
Daniel Dunbar17410a42009-08-10 18:41:10 +00001207 unsigned Index = 0;
Craig Topper03ec8012014-11-25 20:11:31 +00001208 for (Record *Rec : AsmOperands) {
1209 ClassInfo *CI = AsmOperandClasses[Rec];
Daniel Dunbar17410a42009-08-10 18:41:10 +00001210 CI->Kind = ClassInfo::UserClass0 + Index;
1211
Craig Topper03ec8012014-11-25 20:11:31 +00001212 ListInit *Supers = Rec->getValueAsListInit("SuperClasses");
Daniel Dunbar346782c2010-05-22 21:02:29 +00001213 for (unsigned i = 0, e = Supers->getSize(); i != e; ++i) {
Sean Silvafb509ed2012-10-10 20:24:43 +00001214 DefInit *DI = dyn_cast<DefInit>(Supers->getElement(i));
Daniel Dunbar346782c2010-05-22 21:02:29 +00001215 if (!DI) {
Craig Topper03ec8012014-11-25 20:11:31 +00001216 PrintError(Rec->getLoc(), "Invalid super class reference!");
Daniel Dunbar346782c2010-05-22 21:02:29 +00001217 continue;
1218 }
1219
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001220 ClassInfo *SC = AsmOperandClasses[DI->getDef()];
1221 if (!SC)
Craig Topper03ec8012014-11-25 20:11:31 +00001222 PrintError(Rec->getLoc(), "Invalid super class reference!");
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001223 else
1224 CI->SuperClasses.push_back(SC);
Daniel Dunbar17410a42009-08-10 18:41:10 +00001225 }
Craig Topper03ec8012014-11-25 20:11:31 +00001226 CI->ClassName = Rec->getValueAsString("Name");
Daniel Dunbar17410a42009-08-10 18:41:10 +00001227 CI->Name = "MCK_" + CI->ClassName;
Craig Topper03ec8012014-11-25 20:11:31 +00001228 CI->ValueName = Rec->getName();
Daniel Dunbaraeb1feb2009-08-10 21:00:45 +00001229
1230 // Get or construct the predicate method name.
Craig Topper03ec8012014-11-25 20:11:31 +00001231 Init *PMName = Rec->getValueInit("PredicateMethod");
Sean Silvafb509ed2012-10-10 20:24:43 +00001232 if (StringInit *SI = dyn_cast<StringInit>(PMName)) {
Daniel Dunbaraeb1feb2009-08-10 21:00:45 +00001233 CI->PredicateMethod = SI->getValue();
1234 } else {
Sean Silva88eb8dd2012-10-10 20:24:47 +00001235 assert(isa<UnsetInit>(PMName) && "Unexpected PredicateMethod field!");
Daniel Dunbaraeb1feb2009-08-10 21:00:45 +00001236 CI->PredicateMethod = "is" + CI->ClassName;
1237 }
1238
1239 // Get or construct the render method name.
Craig Topper03ec8012014-11-25 20:11:31 +00001240 Init *RMName = Rec->getValueInit("RenderMethod");
Sean Silvafb509ed2012-10-10 20:24:43 +00001241 if (StringInit *SI = dyn_cast<StringInit>(RMName)) {
Daniel Dunbaraeb1feb2009-08-10 21:00:45 +00001242 CI->RenderMethod = SI->getValue();
1243 } else {
Sean Silva88eb8dd2012-10-10 20:24:47 +00001244 assert(isa<UnsetInit>(RMName) && "Unexpected RenderMethod field!");
Daniel Dunbaraeb1feb2009-08-10 21:00:45 +00001245 CI->RenderMethod = "add" + CI->ClassName + "Operands";
1246 }
1247
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00001248 // Get the parse method name or leave it as empty.
Craig Topper03ec8012014-11-25 20:11:31 +00001249 Init *PRMName = Rec->getValueInit("ParserMethod");
Sean Silvafb509ed2012-10-10 20:24:43 +00001250 if (StringInit *SI = dyn_cast<StringInit>(PRMName))
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00001251 CI->ParserMethod = SI->getValue();
1252
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00001253 // Get the diagnostic type or leave it as empty.
1254 // Get the parse method name or leave it as empty.
Craig Topper03ec8012014-11-25 20:11:31 +00001255 Init *DiagnosticType = Rec->getValueInit("DiagnosticType");
Sean Silvafb509ed2012-10-10 20:24:43 +00001256 if (StringInit *SI = dyn_cast<StringInit>(DiagnosticType))
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00001257 CI->DiagnosticType = SI->getValue();
1258
Craig Topper03ec8012014-11-25 20:11:31 +00001259 ++Index;
Daniel Dunbar17410a42009-08-10 18:41:10 +00001260 }
Daniel Dunbarbb98db22009-08-11 02:59:53 +00001261}
1262
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001263AsmMatcherInfo::AsmMatcherInfo(Record *asmParser,
1264 CodeGenTarget &target,
Chris Lattner89dcb682010-12-15 04:48:22 +00001265 RecordKeeper &records)
Devang Patel6d676e42012-01-07 01:33:34 +00001266 : Records(records), AsmParser(asmParser), Target(target) {
Daniel Dunbare4318712009-08-11 20:59:47 +00001267}
1268
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001269/// buildOperandMatchInfo - Build the necessary information to handle user
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00001270/// defined operand parsing methods.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001271void AsmMatcherInfo::buildOperandMatchInfo() {
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00001272
Jim Grosbach925a6d02012-04-18 23:46:25 +00001273 /// Map containing a mask with all operands indices that can be found for
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00001274 /// that class inside a instruction.
Benjamin Kramer3a377bc2014-03-01 11:47:00 +00001275 typedef std::map<ClassInfo *, unsigned, less_ptr<ClassInfo>> OpClassMaskTy;
Sean Silva835139b2012-09-19 01:47:03 +00001276 OpClassMaskTy OpClassMask;
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00001277
Craig Topperf34dad92014-11-28 03:53:02 +00001278 for (const auto &MI : Matchables) {
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00001279 OpClassMask.clear();
1280
1281 // Keep track of all operands of this instructions which belong to the
1282 // same class.
David Blaikie6c13c362014-11-28 21:20:24 +00001283 for (unsigned i = 0, e = MI.AsmOperands.size(); i != e; ++i) {
1284 const MatchableInfo::AsmOperand &Op = MI.AsmOperands[i];
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00001285 if (Op.Class->ParserMethod.empty())
1286 continue;
1287 unsigned &OperandMask = OpClassMask[Op.Class];
1288 OperandMask |= (1 << i);
1289 }
1290
1291 // Generate operand match info for each mnemonic/operand class pair.
Craig Topper42bd8192014-11-28 03:53:00 +00001292 for (const auto &OCM : OpClassMask) {
1293 unsigned OpMask = OCM.second;
1294 ClassInfo *CI = OCM.first;
David Blaikie6c13c362014-11-28 21:20:24 +00001295 OperandMatchInfo.push_back(OperandMatchEntry::create(&MI, CI, OpMask));
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00001296 }
1297 }
1298}
1299
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001300void AsmMatcherInfo::buildInfo() {
Chris Lattnera0e87192010-10-30 20:07:57 +00001301 // Build information about all of the AssemblerPredicates.
1302 std::vector<Record*> AllPredicates =
1303 Records.getAllDerivedDefinitions("Predicate");
1304 for (unsigned i = 0, e = AllPredicates.size(); i != e; ++i) {
1305 Record *Pred = AllPredicates[i];
1306 // Ignore predicates that are not intended for the assembler.
1307 if (!Pred->getValueAsBit("AssemblerMatcherPredicate"))
1308 continue;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001309
Chris Lattner178f4bb2010-11-01 04:44:29 +00001310 if (Pred->getName().empty())
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00001311 PrintFatalError(Pred->getLoc(), "Predicate has no name!");
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001312
David Blaikief6d4b1c2014-11-28 22:01:06 +00001313 uint64_t FeatureNo = SubtargetFeatures.size();
1314 SubtargetFeatures[Pred] =
1315 llvm::make_unique<SubtargetFeatureInfo>(Pred, FeatureNo);
1316 DEBUG(SubtargetFeatures[Pred]->dump());
1317 assert(FeatureNo < 64 && "Too many subtarget features!");
Chris Lattnera0e87192010-10-30 20:07:57 +00001318 }
Jim Grosbach0eccfc22010-10-29 22:13:48 +00001319
Chris Lattner33fc3e02010-10-31 19:10:56 +00001320 // Parse the instructions; we need to do this first so that we can gather the
1321 // singleton register classes.
Chris Lattnerf7a01e92010-11-01 01:47:07 +00001322 SmallPtrSet<Record*, 16> SingletonRegisters;
Devang Patel85d684a2012-01-09 19:13:28 +00001323 unsigned VariantCount = Target.getAsmParserVariantCount();
1324 for (unsigned VC = 0; VC != VariantCount; ++VC) {
1325 Record *AsmVariant = Target.getAsmParserVariant(VC);
Jim Grosbach56e63262012-04-17 00:01:04 +00001326 std::string CommentDelimiter =
1327 AsmVariant->getValueAsString("CommentDelimiter");
Devang Patel85d684a2012-01-09 19:13:28 +00001328 std::string RegisterPrefix = AsmVariant->getValueAsString("RegisterPrefix");
1329 int AsmVariantNo = AsmVariant->getValueAsInt("Variant");
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001330
Craig Topper03ec8012014-11-25 20:11:31 +00001331 for (const CodeGenInstruction *CGI : Target.instructions()) {
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001332
Devang Patel85d684a2012-01-09 19:13:28 +00001333 // If the tblgen -match-prefix option is specified (for tblgen hackers),
1334 // filter the set of instructions we consider.
Craig Topper03ec8012014-11-25 20:11:31 +00001335 if (!StringRef(CGI->TheDef->getName()).startswith(MatchPrefix))
Jim Grosbach3263a072012-04-11 21:02:33 +00001336 continue;
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001337
Devang Patel85d684a2012-01-09 19:13:28 +00001338 // Ignore "codegen only" instructions.
Craig Topper03ec8012014-11-25 20:11:31 +00001339 if (CGI->TheDef->getValueAsBit("isCodeGenOnly"))
Jim Grosbach3263a072012-04-11 21:02:33 +00001340 continue;
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001341
David Blaikie6c13c362014-11-28 21:20:24 +00001342 Matchables.emplace_front(*CGI);
1343 MatchableInfo *II = &Matchables.front();
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001344
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001345 II->initialize(*this, SingletonRegisters, AsmVariantNo, RegisterPrefix);
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001346
Devang Patel85d684a2012-01-09 19:13:28 +00001347 // Ignore instructions which shouldn't be matched and diagnose invalid
1348 // instruction definitions with an error.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001349 if (!II->validate(CommentDelimiter, true))
David Blaikie6c13c362014-11-28 21:20:24 +00001350 Matchables.pop_front();
Chris Lattner743081d2010-11-04 00:43:46 +00001351 }
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001352
Devang Patel85d684a2012-01-09 19:13:28 +00001353 // Parse all of the InstAlias definitions and stick them in the list of
1354 // matchables.
1355 std::vector<Record*> AllInstAliases =
1356 Records.getAllDerivedDefinitions("InstAlias");
1357 for (unsigned i = 0, e = AllInstAliases.size(); i != e; ++i) {
David Blaikie4e3c6ca2014-11-28 21:59:58 +00001358 auto Alias = llvm::make_unique<CodeGenInstAlias>(AllInstAliases[i],
1359 AsmVariantNo, Target);
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001360
Devang Patel85d684a2012-01-09 19:13:28 +00001361 // If the tblgen -match-prefix option is specified (for tblgen hackers),
1362 // filter the set of instruction aliases we consider, based on the target
1363 // instruction.
Jim Grosbach56e63262012-04-17 00:01:04 +00001364 if (!StringRef(Alias->ResultInst->TheDef->getName())
1365 .startswith( MatchPrefix))
Jim Grosbach3263a072012-04-11 21:02:33 +00001366 continue;
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001367
David Blaikie4e3c6ca2014-11-28 21:59:58 +00001368 Matchables.emplace_front(std::move(Alias));
David Blaikie6c13c362014-11-28 21:20:24 +00001369 MatchableInfo *II = &Matchables.front();
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001370
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001371 II->initialize(*this, SingletonRegisters, AsmVariantNo, RegisterPrefix);
Jim Grosbach0bba00d2012-01-24 21:06:59 +00001372
Devang Patel85d684a2012-01-09 19:13:28 +00001373 // Validate the alias definitions.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001374 II->validate(CommentDelimiter, false);
Devang Patel85d684a2012-01-09 19:13:28 +00001375 }
Chris Lattner488c2012010-11-01 04:05:41 +00001376 }
Chris Lattnerd8adec72010-11-01 04:03:32 +00001377
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00001378 // Build info for the register classes.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001379 buildRegisterClasses(SingletonRegisters);
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00001380
1381 // Build info for the user defined assembly operand classes.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001382 buildOperandClasses();
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00001383
Chris Lattner4779e3e92010-11-04 00:57:06 +00001384 // Build the information about matchables, now that we have fully formed
1385 // classes.
David Blaikie6c13c362014-11-28 21:20:24 +00001386 std::forward_list<MatchableInfo> NewMatchables;
Craig Topperf34dad92014-11-28 03:53:02 +00001387 for (auto &II : Matchables) {
Chris Lattner82d88ce2010-09-06 21:01:37 +00001388 // Parse the tokens after the mnemonic.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001389 // Note: buildInstructionOperandReference may insert new AsmOperands, so
Bob Wilsonb9b24222011-01-26 19:44:55 +00001390 // don't precompute the loop bound.
David Blaikie6c13c362014-11-28 21:20:24 +00001391 for (unsigned i = 0; i != II.AsmOperands.size(); ++i) {
1392 MatchableInfo::AsmOperand &Op = II.AsmOperands[i];
Chris Lattner28ea9b12010-11-02 17:30:52 +00001393 StringRef Token = Op.Token;
Daniel Dunbare10787e2009-08-07 08:26:05 +00001394
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00001395 // Check for singleton registers.
David Blaikie6c13c362014-11-28 21:20:24 +00001396 if (Record *RegRecord = II.AsmOperands[i].SingletonReg) {
Chris Lattner28ea9b12010-11-02 17:30:52 +00001397 Op.Class = RegisterClasses[RegRecord];
Chris Lattnerb80ab362010-11-01 01:37:30 +00001398 assert(Op.Class && Op.Class->Registers.size() == 1 &&
1399 "Unexpected class for singleton register");
Chris Lattnerb80ab362010-11-01 01:37:30 +00001400 continue;
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00001401 }
1402
Daniel Dunbare10787e2009-08-07 08:26:05 +00001403 // Check for simple tokens.
1404 if (Token[0] != '$') {
Chris Lattner28ea9b12010-11-02 17:30:52 +00001405 Op.Class = getTokenClass(Token);
Daniel Dunbare10787e2009-08-07 08:26:05 +00001406 continue;
1407 }
1408
Chris Lattnerd6746d52010-11-06 22:06:03 +00001409 if (Token.size() > 1 && isdigit(Token[1])) {
1410 Op.Class = getTokenClass(Token);
1411 continue;
1412 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001413
Chris Lattner4efe13d2010-11-04 02:11:18 +00001414 // Otherwise this is an operand reference.
Chris Lattnerccde4632010-11-04 01:58:23 +00001415 StringRef OperandName;
1416 if (Token[1] == '{')
1417 OperandName = Token.substr(2, Token.size() - 3);
1418 else
1419 OperandName = Token.substr(1);
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001420
David Blaikie6c13c362014-11-28 21:20:24 +00001421 if (II.DefRec.is<const CodeGenInstruction *>())
1422 buildInstructionOperandReference(&II, OperandName, i);
Chris Lattner4efe13d2010-11-04 02:11:18 +00001423 else
David Blaikie6c13c362014-11-28 21:20:24 +00001424 buildAliasOperandReference(&II, OperandName, Op);
Daniel Dunbare10787e2009-08-07 08:26:05 +00001425 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001426
David Blaikie6c13c362014-11-28 21:20:24 +00001427 if (II.DefRec.is<const CodeGenInstruction *>()) {
1428 II.buildInstructionResultOperands();
Jim Grosbach31c2d3f2012-04-19 23:59:23 +00001429 // If the instruction has a two-operand alias, build up the
1430 // matchable here. We'll add them in bulk at the end to avoid
1431 // confusing this loop.
1432 std::string Constraint =
David Blaikie6c13c362014-11-28 21:20:24 +00001433 II.TheDef->getValueAsString("TwoOperandAliasConstraint");
Jim Grosbach31c2d3f2012-04-19 23:59:23 +00001434 if (Constraint != "") {
1435 // Start by making a copy of the original matchable.
David Blaikie6c13c362014-11-28 21:20:24 +00001436 NewMatchables.emplace_front(II);
Jim Grosbach31c2d3f2012-04-19 23:59:23 +00001437
1438 // Adjust it to be a two-operand alias.
David Blaikie6c13c362014-11-28 21:20:24 +00001439 NewMatchables.front().formTwoOperandAlias(Constraint);
Jim Grosbach31c2d3f2012-04-19 23:59:23 +00001440 }
1441 } else
David Blaikie6c13c362014-11-28 21:20:24 +00001442 II.buildAliasResultOperands();
Daniel Dunbare10787e2009-08-07 08:26:05 +00001443 }
David Blaikie6c13c362014-11-28 21:20:24 +00001444 Matchables.splice_after(Matchables.before_begin(), NewMatchables);
Daniel Dunbar8e33cb22009-08-09 07:20:21 +00001445
Jim Grosbachba395922011-12-06 23:43:54 +00001446 // Process token alias definitions and set up the associated superclass
1447 // information.
1448 std::vector<Record*> AllTokenAliases =
1449 Records.getAllDerivedDefinitions("TokenAlias");
1450 for (unsigned i = 0, e = AllTokenAliases.size(); i != e; ++i) {
1451 Record *Rec = AllTokenAliases[i];
1452 ClassInfo *FromClass = getTokenClass(Rec->getValueAsString("FromToken"));
1453 ClassInfo *ToClass = getTokenClass(Rec->getValueAsString("ToToken"));
Jim Grosbach37f6dcb32012-04-17 21:23:52 +00001454 if (FromClass == ToClass)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00001455 PrintFatalError(Rec->getLoc(),
Jim Grosbach37f6dcb32012-04-17 21:23:52 +00001456 "error: Destination value identical to source value.");
Jim Grosbachba395922011-12-06 23:43:54 +00001457 FromClass->SuperClasses.push_back(ToClass);
1458 }
1459
Chris Lattner0ab5e2c2011-04-15 05:18:47 +00001460 // Reorder classes so that classes precede super classes.
David Blaikied749e342014-11-28 20:35:57 +00001461 Classes.sort();
Daniel Dunbare10787e2009-08-07 08:26:05 +00001462}
1463
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001464/// buildInstructionOperandReference - The specified operand is a reference to a
Chris Lattner4779e3e92010-11-04 00:57:06 +00001465/// named operand such as $src. Resolve the Class and OperandInfo pointers.
1466void AsmMatcherInfo::
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001467buildInstructionOperandReference(MatchableInfo *II,
Chris Lattnerccde4632010-11-04 01:58:23 +00001468 StringRef OperandName,
Bob Wilsonb9b24222011-01-26 19:44:55 +00001469 unsigned AsmOpIdx) {
Chris Lattner4efe13d2010-11-04 02:11:18 +00001470 const CodeGenInstruction &CGI = *II->DefRec.get<const CodeGenInstruction*>();
1471 const CGIOperandList &Operands = CGI.Operands;
Bob Wilsonb9b24222011-01-26 19:44:55 +00001472 MatchableInfo::AsmOperand *Op = &II->AsmOperands[AsmOpIdx];
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001473
Chris Lattnerfecdad62010-11-06 07:14:44 +00001474 // Map this token to an operand.
Chris Lattner4779e3e92010-11-04 00:57:06 +00001475 unsigned Idx;
1476 if (!Operands.hasOperandNamed(OperandName, Idx))
Benjamin Kramer48e7e852014-03-29 17:17:15 +00001477 PrintFatalError(II->TheDef->getLoc(),
1478 "error: unable to find operand: '" + OperandName + "'");
Chris Lattner897a1402010-11-04 01:55:23 +00001479
Bob Wilsonb9b24222011-01-26 19:44:55 +00001480 // If the instruction operand has multiple suboperands, but the parser
1481 // match class for the asm operand is still the default "ImmAsmOperand",
1482 // then handle each suboperand separately.
1483 if (Op->SubOpIdx == -1 && Operands[Idx].MINumOperands > 1) {
1484 Record *Rec = Operands[Idx].Rec;
1485 assert(Rec->isSubClassOf("Operand") && "Unexpected operand!");
1486 Record *MatchClass = Rec->getValueAsDef("ParserMatchClass");
1487 if (MatchClass && MatchClass->getValueAsString("Name") == "Imm") {
1488 // Insert remaining suboperands after AsmOpIdx in II->AsmOperands.
1489 StringRef Token = Op->Token; // save this in case Op gets moved
1490 for (unsigned SI = 1, SE = Operands[Idx].MINumOperands; SI != SE; ++SI) {
1491 MatchableInfo::AsmOperand NewAsmOp(Token);
1492 NewAsmOp.SubOpIdx = SI;
1493 II->AsmOperands.insert(II->AsmOperands.begin()+AsmOpIdx+SI, NewAsmOp);
1494 }
1495 // Replace Op with first suboperand.
1496 Op = &II->AsmOperands[AsmOpIdx]; // update the pointer in case it moved
1497 Op->SubOpIdx = 0;
1498 }
1499 }
1500
Chris Lattner897a1402010-11-04 01:55:23 +00001501 // Set up the operand class.
Bob Wilsonb9b24222011-01-26 19:44:55 +00001502 Op->Class = getOperandClass(Operands[Idx], Op->SubOpIdx);
Chris Lattner897a1402010-11-04 01:55:23 +00001503
1504 // If the named operand is tied, canonicalize it to the untied operand.
1505 // For example, something like:
1506 // (outs GPR:$dst), (ins GPR:$src)
1507 // with an asmstring of
1508 // "inc $src"
1509 // we want to canonicalize to:
1510 // "inc $dst"
1511 // so that we know how to provide the $dst operand when filling in the result.
Ulrich Weigande037a492013-04-27 18:48:23 +00001512 int OITied = -1;
1513 if (Operands[Idx].MINumOperands == 1)
1514 OITied = Operands[Idx].getTiedRegister();
Chris Lattner4779e3e92010-11-04 00:57:06 +00001515 if (OITied != -1) {
1516 // The tied operand index is an MIOperand index, find the operand that
1517 // contains it.
Bob Wilsonb9b24222011-01-26 19:44:55 +00001518 std::pair<unsigned, unsigned> Idx = Operands.getSubOperandNumber(OITied);
1519 OperandName = Operands[Idx.first].Name;
1520 Op->SubOpIdx = Idx.second;
Chris Lattner4779e3e92010-11-04 00:57:06 +00001521 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001522
Bob Wilsonb9b24222011-01-26 19:44:55 +00001523 Op->SrcOpName = OperandName;
Chris Lattner4779e3e92010-11-04 00:57:06 +00001524}
1525
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001526/// buildAliasOperandReference - When parsing an operand reference out of the
Chris Lattnerb625dd22010-11-06 07:06:09 +00001527/// matching string (e.g. "movsx $src, $dst"), determine what the class of the
1528/// operand reference is by looking it up in the result pattern definition.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001529void AsmMatcherInfo::buildAliasOperandReference(MatchableInfo *II,
Chris Lattner4efe13d2010-11-04 02:11:18 +00001530 StringRef OperandName,
1531 MatchableInfo::AsmOperand &Op) {
1532 const CodeGenInstAlias &CGA = *II->DefRec.get<const CodeGenInstAlias*>();
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001533
Chris Lattner4efe13d2010-11-04 02:11:18 +00001534 // Set up the operand class.
Chris Lattnerb625dd22010-11-06 07:06:09 +00001535 for (unsigned i = 0, e = CGA.ResultOperands.size(); i != e; ++i)
Chris Lattnerb6f8e822010-11-06 19:25:43 +00001536 if (CGA.ResultOperands[i].isRecord() &&
1537 CGA.ResultOperands[i].getName() == OperandName) {
Chris Lattnerfecdad62010-11-06 07:14:44 +00001538 // It's safe to go with the first one we find, because CodeGenInstAlias
1539 // validates that all operands with the same name have the same record.
Bob Wilsonb9b24222011-01-26 19:44:55 +00001540 Op.SubOpIdx = CGA.ResultInstOperandIndex[i].second;
Jim Grosbachd1f1b792011-10-28 22:32:53 +00001541 // Use the match class from the Alias definition, not the
1542 // destination instruction, as we may have an immediate that's
1543 // being munged by the match class.
1544 Op.Class = getOperandClass(CGA.ResultOperands[i].getRecord(),
Bob Wilsonb9b24222011-01-26 19:44:55 +00001545 Op.SubOpIdx);
Chris Lattnerb625dd22010-11-06 07:06:09 +00001546 Op.SrcOpName = OperandName;
1547 return;
Chris Lattner4efe13d2010-11-04 02:11:18 +00001548 }
Chris Lattnerb625dd22010-11-06 07:06:09 +00001549
Benjamin Kramer48e7e852014-03-29 17:17:15 +00001550 PrintFatalError(II->TheDef->getLoc(),
1551 "error: unable to find operand: '" + OperandName + "'");
Chris Lattner4efe13d2010-11-04 02:11:18 +00001552}
1553
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001554void MatchableInfo::buildInstructionResultOperands() {
Chris Lattnerfecdad62010-11-06 07:14:44 +00001555 const CodeGenInstruction *ResultInst = getResultInst();
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001556
Chris Lattnerfecdad62010-11-06 07:14:44 +00001557 // Loop over all operands of the result instruction, determining how to
1558 // populate them.
1559 for (unsigned i = 0, e = ResultInst->Operands.size(); i != e; ++i) {
1560 const CGIOperandList::OperandInfo &OpInfo = ResultInst->Operands[i];
Chris Lattner7108dad2010-11-04 01:42:59 +00001561
1562 // If this is a tied operand, just copy from the previously handled operand.
Ulrich Weigande037a492013-04-27 18:48:23 +00001563 int TiedOp = -1;
1564 if (OpInfo.MINumOperands == 1)
1565 TiedOp = OpInfo.getTiedRegister();
Chris Lattner7108dad2010-11-04 01:42:59 +00001566 if (TiedOp != -1) {
Bob Wilsonb9b24222011-01-26 19:44:55 +00001567 ResOperands.push_back(ResOperand::getTiedOp(TiedOp));
Chris Lattner7108dad2010-11-04 01:42:59 +00001568 continue;
1569 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001570
Bob Wilsonb9b24222011-01-26 19:44:55 +00001571 // Find out what operand from the asmparser this MCInst operand comes from.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001572 int SrcOperand = findAsmOperandNamed(OpInfo.Name);
Ulrich Weigande037a492013-04-27 18:48:23 +00001573 if (OpInfo.Name.empty() || SrcOperand == -1) {
1574 // This may happen for operands that are tied to a suboperand of a
1575 // complex operand. Simply use a dummy value here; nobody should
1576 // use this operand slot.
1577 // FIXME: The long term goal is for the MCOperand list to not contain
1578 // tied operands at all.
1579 ResOperands.push_back(ResOperand::getImmOp(0));
1580 continue;
1581 }
Chris Lattner7108dad2010-11-04 01:42:59 +00001582
Bob Wilsonb9b24222011-01-26 19:44:55 +00001583 // Check if the one AsmOperand populates the entire operand.
1584 unsigned NumOperands = OpInfo.MINumOperands;
1585 if (AsmOperands[SrcOperand].SubOpIdx == -1) {
1586 ResOperands.push_back(ResOperand::getRenderedOp(SrcOperand, NumOperands));
Chris Lattner743081d2010-11-04 00:43:46 +00001587 continue;
1588 }
Bob Wilsonb9b24222011-01-26 19:44:55 +00001589
1590 // Add a separate ResOperand for each suboperand.
1591 for (unsigned AI = 0; AI < NumOperands; ++AI) {
1592 assert(AsmOperands[SrcOperand+AI].SubOpIdx == (int)AI &&
1593 AsmOperands[SrcOperand+AI].SrcOpName == OpInfo.Name &&
1594 "unexpected AsmOperands for suboperands");
1595 ResOperands.push_back(ResOperand::getRenderedOp(SrcOperand + AI, 1));
1596 }
Chris Lattner743081d2010-11-04 00:43:46 +00001597 }
1598}
1599
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001600void MatchableInfo::buildAliasResultOperands() {
Chris Lattner8188fb22010-11-06 07:31:43 +00001601 const CodeGenInstAlias &CGA = *DefRec.get<const CodeGenInstAlias*>();
1602 const CodeGenInstruction *ResultInst = getResultInst();
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001603
Chris Lattner8188fb22010-11-06 07:31:43 +00001604 // Loop over all operands of the result instruction, determining how to
1605 // populate them.
1606 unsigned AliasOpNo = 0;
Bob Wilsonb9b24222011-01-26 19:44:55 +00001607 unsigned LastOpNo = CGA.ResultInstOperandIndex.size();
Chris Lattner8188fb22010-11-06 07:31:43 +00001608 for (unsigned i = 0, e = ResultInst->Operands.size(); i != e; ++i) {
Bob Wilsonb9b24222011-01-26 19:44:55 +00001609 const CGIOperandList::OperandInfo *OpInfo = &ResultInst->Operands[i];
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001610
Chris Lattner8188fb22010-11-06 07:31:43 +00001611 // If this is a tied operand, just copy from the previously handled operand.
Ulrich Weigande037a492013-04-27 18:48:23 +00001612 int TiedOp = -1;
1613 if (OpInfo->MINumOperands == 1)
1614 TiedOp = OpInfo->getTiedRegister();
Chris Lattner8188fb22010-11-06 07:31:43 +00001615 if (TiedOp != -1) {
Bob Wilsonb9b24222011-01-26 19:44:55 +00001616 ResOperands.push_back(ResOperand::getTiedOp(TiedOp));
Chris Lattner4869d342010-11-06 19:57:21 +00001617 continue;
1618 }
1619
Bob Wilsonb9b24222011-01-26 19:44:55 +00001620 // Handle all the suboperands for this operand.
1621 const std::string &OpName = OpInfo->Name;
1622 for ( ; AliasOpNo < LastOpNo &&
1623 CGA.ResultInstOperandIndex[AliasOpNo].first == i; ++AliasOpNo) {
1624 int SubIdx = CGA.ResultInstOperandIndex[AliasOpNo].second;
1625
1626 // Find out what operand from the asmparser that this MCInst operand
1627 // comes from.
1628 switch (CGA.ResultOperands[AliasOpNo].Kind) {
Bob Wilsonb9b24222011-01-26 19:44:55 +00001629 case CodeGenInstAlias::ResultOperand::K_Record: {
1630 StringRef Name = CGA.ResultOperands[AliasOpNo].getName();
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001631 int SrcOperand = findAsmOperand(Name, SubIdx);
Bob Wilsonb9b24222011-01-26 19:44:55 +00001632 if (SrcOperand == -1)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00001633 PrintFatalError(TheDef->getLoc(), "Instruction '" +
Bob Wilsonb9b24222011-01-26 19:44:55 +00001634 TheDef->getName() + "' has operand '" + OpName +
1635 "' that doesn't appear in asm string!");
1636 unsigned NumOperands = (SubIdx == -1 ? OpInfo->MINumOperands : 1);
1637 ResOperands.push_back(ResOperand::getRenderedOp(SrcOperand,
1638 NumOperands));
1639 break;
1640 }
1641 case CodeGenInstAlias::ResultOperand::K_Imm: {
1642 int64_t ImmVal = CGA.ResultOperands[AliasOpNo].getImm();
1643 ResOperands.push_back(ResOperand::getImmOp(ImmVal));
1644 break;
1645 }
1646 case CodeGenInstAlias::ResultOperand::K_Reg: {
1647 Record *Reg = CGA.ResultOperands[AliasOpNo].getRegister();
1648 ResOperands.push_back(ResOperand::getRegOp(Reg));
1649 break;
1650 }
1651 }
Chris Lattner4869d342010-11-06 19:57:21 +00001652 }
Chris Lattner8188fb22010-11-06 07:31:43 +00001653 }
1654}
Chris Lattner743081d2010-11-04 00:43:46 +00001655
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001656static unsigned getConverterOperandID(const std::string &Name,
1657 SetVector<std::string> &Table,
1658 bool &IsNew) {
1659 IsNew = Table.insert(Name);
1660
1661 unsigned ID = IsNew ? Table.size() - 1 :
1662 std::find(Table.begin(), Table.end(), Name) - Table.begin();
1663
1664 assert(ID < Table.size());
1665
1666 return ID;
1667}
1668
Chad Rosierf4e35dc2012-10-01 23:45:51 +00001669static void emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
David Blaikie6c13c362014-11-28 21:20:24 +00001670 std::forward_list<MatchableInfo> &Infos,
Chad Rosierf4e35dc2012-10-01 23:45:51 +00001671 raw_ostream &OS) {
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001672 SetVector<std::string> OperandConversionKinds;
1673 SetVector<std::string> InstructionConversionKinds;
1674 std::vector<std::vector<uint8_t> > ConversionTable;
1675 size_t MaxRowLength = 2; // minimum is custom converter plus terminator.
Jim Grosbach0eccfc22010-10-29 22:13:48 +00001676
Chris Lattnerf29c0b62010-01-14 22:21:20 +00001677 // TargetOperandClass - This is the target's operand class, like X86Operand.
1678 std::string TargetOperandClass = Target.getName() + "Operand";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00001679
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001680 // Write the convert function to a separate stream, so we can drop it after
1681 // the enum. We'll build up the conversion handlers for the individual
1682 // operand types opportunistically as we encounter them.
1683 std::string ConvertFnBody;
1684 raw_string_ostream CvtOS(ConvertFnBody);
1685 // Start the unified conversion function.
Chad Rosier98cfa102012-08-31 00:03:31 +00001686 CvtOS << "void " << Target.getName() << ClassName << "::\n"
Chad Rosierba284b92012-09-05 01:02:38 +00001687 << "convertToMCInst(unsigned Kind, MCInst &Inst, "
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001688 << "unsigned Opcode,\n"
David Blaikie960ea3f2014-06-08 16:18:35 +00001689 << " const OperandVector"
1690 << " &Operands) {\n"
Chad Rosier98cfa102012-08-31 00:03:31 +00001691 << " assert(Kind < CVT_NUM_SIGNATURES && \"Invalid signature!\");\n"
Craig Topper91506102012-09-18 01:41:49 +00001692 << " const uint8_t *Converter = ConversionTable[Kind];\n"
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001693 << " Inst.setOpcode(Opcode);\n"
Craig Topper91506102012-09-18 01:41:49 +00001694 << " for (const uint8_t *p = Converter; *p; p+= 2) {\n"
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001695 << " switch (*p) {\n"
1696 << " default: llvm_unreachable(\"invalid conversion entry!\");\n"
1697 << " case CVT_Reg:\n"
1698 << " static_cast<" << TargetOperandClass
David Blaikie960ea3f2014-06-08 16:18:35 +00001699 << "&>(*Operands[*(p + 1)]).addRegOperands(Inst, 1);\n"
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001700 << " break;\n"
1701 << " case CVT_Tied:\n"
1702 << " Inst.addOperand(Inst.getOperand(*(p + 1)));\n"
1703 << " break;\n";
1704
Chad Rosier738ea252012-08-30 17:59:25 +00001705 std::string OperandFnBody;
1706 raw_string_ostream OpOS(OperandFnBody);
1707 // Start the operand number lookup function.
Chad Rosierf4e35dc2012-10-01 23:45:51 +00001708 OpOS << "void " << Target.getName() << ClassName << "::\n"
1709 << "convertToMapAndConstraints(unsigned Kind,\n";
Chad Rosier380a74a2012-10-02 00:25:57 +00001710 OpOS.indent(27);
David Blaikie960ea3f2014-06-08 16:18:35 +00001711 OpOS << "const OperandVector &Operands) {\n"
Chad Rosier98cfa102012-08-31 00:03:31 +00001712 << " assert(Kind < CVT_NUM_SIGNATURES && \"Invalid signature!\");\n"
Chad Rosierf4e35dc2012-10-01 23:45:51 +00001713 << " unsigned NumMCOperands = 0;\n"
Craig Topper91506102012-09-18 01:41:49 +00001714 << " const uint8_t *Converter = ConversionTable[Kind];\n"
1715 << " for (const uint8_t *p = Converter; *p; p+= 2) {\n"
Chad Rosier738ea252012-08-30 17:59:25 +00001716 << " switch (*p) {\n"
1717 << " default: llvm_unreachable(\"invalid conversion entry!\");\n"
1718 << " case CVT_Reg:\n"
Chad Rosier2f480a82012-10-12 22:53:36 +00001719 << " Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);\n"
Chad Rosier72450332013-01-15 23:07:53 +00001720 << " Operands[*(p + 1)]->setConstraint(\"r\");\n"
Chad Rosier2f480a82012-10-12 22:53:36 +00001721 << " ++NumMCOperands;\n"
1722 << " break;\n"
Chad Rosier738ea252012-08-30 17:59:25 +00001723 << " case CVT_Tied:\n"
Chad Rosierf4e35dc2012-10-01 23:45:51 +00001724 << " ++NumMCOperands;\n"
Chad Rosier738ea252012-08-30 17:59:25 +00001725 << " break;\n";
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001726
1727 // Pre-populate the operand conversion kinds with the standard always
1728 // available entries.
1729 OperandConversionKinds.insert("CVT_Done");
1730 OperandConversionKinds.insert("CVT_Reg");
1731 OperandConversionKinds.insert("CVT_Tied");
1732 enum { CVT_Done, CVT_Reg, CVT_Tied };
1733
Craig Topperf34dad92014-11-28 03:53:02 +00001734 for (auto &II : Infos) {
Daniel Dunbar77b7c3f2011-02-04 17:12:15 +00001735 // Check if we have a custom match function.
Daniel Dunbar5f74b392011-04-01 20:23:52 +00001736 std::string AsmMatchConverter =
David Blaikie6c13c362014-11-28 21:20:24 +00001737 II.getResultInst()->TheDef->getValueAsString("AsmMatchConverter");
Daniel Dunbar77b7c3f2011-02-04 17:12:15 +00001738 if (!AsmMatchConverter.empty()) {
Daniel Dunbar5f74b392011-04-01 20:23:52 +00001739 std::string Signature = "ConvertCustom_" + AsmMatchConverter;
David Blaikie6c13c362014-11-28 21:20:24 +00001740 II.ConversionFnKind = Signature;
Daniel Dunbar77b7c3f2011-02-04 17:12:15 +00001741
1742 // Check if we have already generated this signature.
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001743 if (!InstructionConversionKinds.insert(Signature))
Daniel Dunbar77b7c3f2011-02-04 17:12:15 +00001744 continue;
1745
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001746 // Remember this converter for the kind enum.
1747 unsigned KindID = OperandConversionKinds.size();
Tim Northoverb3cfb282013-01-10 16:47:31 +00001748 OperandConversionKinds.insert("CVT_" +
1749 getEnumNameForToken(AsmMatchConverter));
Daniel Dunbar77b7c3f2011-02-04 17:12:15 +00001750
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001751 // Add the converter row for this instruction.
1752 ConversionTable.push_back(std::vector<uint8_t>());
1753 ConversionTable.back().push_back(KindID);
1754 ConversionTable.back().push_back(CVT_Done);
1755
1756 // Add the handler to the conversion driver function.
Tim Northoverb3cfb282013-01-10 16:47:31 +00001757 CvtOS << " case CVT_"
1758 << getEnumNameForToken(AsmMatchConverter) << ":\n"
Chad Rosier451ef132012-08-31 22:12:31 +00001759 << " " << AsmMatchConverter << "(Inst, Operands);\n"
Chad Rosier98cfa102012-08-31 00:03:31 +00001760 << " break;\n";
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001761
Chad Rosier738ea252012-08-30 17:59:25 +00001762 // FIXME: Handle the operand number lookup for custom match functions.
Daniel Dunbar77b7c3f2011-02-04 17:12:15 +00001763 continue;
1764 }
1765
Daniel Dunbare10787e2009-08-07 08:26:05 +00001766 // Build the conversion function signature.
1767 std::string Signature = "Convert";
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001768
1769 std::vector<uint8_t> ConversionRow;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001770
Chris Lattner5cf8a4a2010-11-02 21:49:44 +00001771 // Compute the convert enum and the case body.
David Blaikie6c13c362014-11-28 21:20:24 +00001772 MaxRowLength = std::max(MaxRowLength, II.ResOperands.size() * 2 + 1);
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001773
David Blaikie6c13c362014-11-28 21:20:24 +00001774 for (unsigned i = 0, e = II.ResOperands.size(); i != e; ++i) {
1775 const MatchableInfo::ResOperand &OpInfo = II.ResOperands[i];
Jim Grosbach0eccfc22010-10-29 22:13:48 +00001776
Chris Lattner743081d2010-11-04 00:43:46 +00001777 // Generate code to populate each result operand.
1778 switch (OpInfo.Kind) {
Chris Lattner743081d2010-11-04 00:43:46 +00001779 case MatchableInfo::ResOperand::RenderAsmOperand: {
1780 // This comes from something we parsed.
Craig Topper03ec8012014-11-25 20:11:31 +00001781 const MatchableInfo::AsmOperand &Op =
David Blaikie6c13c362014-11-28 21:20:24 +00001782 II.AsmOperands[OpInfo.AsmOperandNum];
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001783
Chris Lattnere032dbf2010-11-02 22:55:03 +00001784 // Registers are always converted the same, don't duplicate the
1785 // conversion function based on them.
Chris Lattnere032dbf2010-11-02 22:55:03 +00001786 Signature += "__";
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001787 std::string Class;
1788 Class = Op.Class->isRegisterClass() ? "Reg" : Op.Class->ClassName;
1789 Signature += Class;
Bob Wilsonb9b24222011-01-26 19:44:55 +00001790 Signature += utostr(OpInfo.MINumOperands);
Chris Lattner743081d2010-11-04 00:43:46 +00001791 Signature += "_" + itostr(OpInfo.AsmOperandNum);
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001792
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001793 // Add the conversion kind, if necessary, and get the associated ID
1794 // the index of its entry in the vector).
1795 std::string Name = "CVT_" + (Op.Class->isRegisterClass() ? "Reg" :
1796 Op.Class->RenderMethod);
Tim Northoverb3cfb282013-01-10 16:47:31 +00001797 Name = getEnumNameForToken(Name);
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001798
1799 bool IsNewConverter = false;
1800 unsigned ID = getConverterOperandID(Name, OperandConversionKinds,
1801 IsNewConverter);
1802
1803 // Add the operand entry to the instruction kind conversion row.
1804 ConversionRow.push_back(ID);
1805 ConversionRow.push_back(OpInfo.AsmOperandNum + 1);
1806
1807 if (!IsNewConverter)
1808 break;
1809
1810 // This is a new operand kind. Add a handler for it to the
1811 // converter driver.
1812 CvtOS << " case " << Name << ":\n"
1813 << " static_cast<" << TargetOperandClass
David Blaikie960ea3f2014-06-08 16:18:35 +00001814 << "&>(*Operands[*(p + 1)])." << Op.Class->RenderMethod
1815 << "(Inst, " << OpInfo.MINumOperands << ");\n"
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001816 << " break;\n";
Chad Rosier738ea252012-08-30 17:59:25 +00001817
1818 // Add a handler for the operand number lookup.
1819 OpOS << " case " << Name << ":\n"
Chad Rosier72450332013-01-15 23:07:53 +00001820 << " Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);\n";
1821
1822 if (Op.Class->isRegisterClass())
1823 OpOS << " Operands[*(p + 1)]->setConstraint(\"r\");\n";
1824 else
1825 OpOS << " Operands[*(p + 1)]->setConstraint(\"m\");\n";
1826 OpOS << " NumMCOperands += " << OpInfo.MINumOperands << ";\n"
Chad Rosier738ea252012-08-30 17:59:25 +00001827 << " break;\n";
Chris Lattner743081d2010-11-04 00:43:46 +00001828 break;
Daniel Dunbarf22553a2010-02-10 08:15:48 +00001829 }
Chris Lattner743081d2010-11-04 00:43:46 +00001830 case MatchableInfo::ResOperand::TiedOperand: {
1831 // If this operand is tied to a previous one, just copy the MCInst
1832 // operand from the earlier one.We can only tie single MCOperand values.
Ulrich Weigande037a492013-04-27 18:48:23 +00001833 assert(OpInfo.MINumOperands == 1 && "Not a singular MCOperand");
Chris Lattner743081d2010-11-04 00:43:46 +00001834 unsigned TiedOp = OpInfo.TiedOperandNum;
Chris Lattner0ab5e2c2011-04-15 05:18:47 +00001835 assert(i > TiedOp && "Tied operand precedes its target!");
Chris Lattner743081d2010-11-04 00:43:46 +00001836 Signature += "__Tie" + utostr(TiedOp);
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001837 ConversionRow.push_back(CVT_Tied);
1838 ConversionRow.push_back(TiedOp);
Chris Lattner743081d2010-11-04 00:43:46 +00001839 break;
1840 }
Chris Lattnerb6f8e822010-11-06 19:25:43 +00001841 case MatchableInfo::ResOperand::ImmOperand: {
1842 int64_t Val = OpInfo.ImmVal;
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001843 std::string Ty = "imm_" + itostr(Val);
1844 Signature += "__" + Ty;
1845
1846 std::string Name = "CVT_" + Ty;
1847 bool IsNewConverter = false;
1848 unsigned ID = getConverterOperandID(Name, OperandConversionKinds,
1849 IsNewConverter);
1850 // Add the operand entry to the instruction kind conversion row.
1851 ConversionRow.push_back(ID);
1852 ConversionRow.push_back(0);
1853
1854 if (!IsNewConverter)
1855 break;
1856
1857 CvtOS << " case " << Name << ":\n"
1858 << " Inst.addOperand(MCOperand::CreateImm(" << Val << "));\n"
1859 << " break;\n";
1860
Chad Rosier738ea252012-08-30 17:59:25 +00001861 OpOS << " case " << Name << ":\n"
Chad Rosier2f480a82012-10-12 22:53:36 +00001862 << " Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);\n"
1863 << " Operands[*(p + 1)]->setConstraint(\"\");\n"
Chad Rosierf4e35dc2012-10-01 23:45:51 +00001864 << " ++NumMCOperands;\n"
Chad Rosier738ea252012-08-30 17:59:25 +00001865 << " break;\n";
Chris Lattnerb6f8e822010-11-06 19:25:43 +00001866 break;
1867 }
Chris Lattner4869d342010-11-06 19:57:21 +00001868 case MatchableInfo::ResOperand::RegOperand: {
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001869 std::string Reg, Name;
Craig Topper24064772014-04-15 07:20:03 +00001870 if (!OpInfo.Register) {
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001871 Name = "reg0";
1872 Reg = "0";
Bob Wilson03912ab2011-01-14 22:58:09 +00001873 } else {
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001874 Reg = getQualifiedName(OpInfo.Register);
1875 Name = "reg" + OpInfo.Register->getName();
Bob Wilson03912ab2011-01-14 22:58:09 +00001876 }
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001877 Signature += "__" + Name;
1878 Name = "CVT_" + Name;
1879 bool IsNewConverter = false;
1880 unsigned ID = getConverterOperandID(Name, OperandConversionKinds,
1881 IsNewConverter);
1882 // Add the operand entry to the instruction kind conversion row.
1883 ConversionRow.push_back(ID);
1884 ConversionRow.push_back(0);
1885
1886 if (!IsNewConverter)
1887 break;
1888 CvtOS << " case " << Name << ":\n"
1889 << " Inst.addOperand(MCOperand::CreateReg(" << Reg << "));\n"
1890 << " break;\n";
Chad Rosier738ea252012-08-30 17:59:25 +00001891
1892 OpOS << " case " << Name << ":\n"
Chad Rosier2f480a82012-10-12 22:53:36 +00001893 << " Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);\n"
1894 << " Operands[*(p + 1)]->setConstraint(\"m\");\n"
Chad Rosierf4e35dc2012-10-01 23:45:51 +00001895 << " ++NumMCOperands;\n"
Chad Rosier738ea252012-08-30 17:59:25 +00001896 << " break;\n";
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001897 }
Chris Lattner743081d2010-11-04 00:43:46 +00001898 }
Daniel Dunbare10787e2009-08-07 08:26:05 +00001899 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00001900
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001901 // If there were no operands, add to the signature to that effect
1902 if (Signature == "Convert")
1903 Signature += "_NoOperands";
1904
David Blaikie6c13c362014-11-28 21:20:24 +00001905 II.ConversionFnKind = Signature;
Daniel Dunbare10787e2009-08-07 08:26:05 +00001906
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001907 // Save the signature. If we already have it, don't add a new row
1908 // to the table.
1909 if (!InstructionConversionKinds.insert(Signature))
Daniel Dunbare10787e2009-08-07 08:26:05 +00001910 continue;
1911
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001912 // Add the row to the table.
1913 ConversionTable.push_back(ConversionRow);
Daniel Dunbare10787e2009-08-07 08:26:05 +00001914 }
Daniel Dunbar71330282009-08-08 05:24:34 +00001915
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001916 // Finish up the converter driver function.
Chad Rosierc38826c2012-09-03 17:39:57 +00001917 CvtOS << " }\n }\n}\n\n";
Daniel Dunbar71330282009-08-08 05:24:34 +00001918
Chad Rosier738ea252012-08-30 17:59:25 +00001919 // Finish up the operand number lookup function.
Chad Rosierf4e35dc2012-10-01 23:45:51 +00001920 OpOS << " }\n }\n}\n\n";
Chad Rosier738ea252012-08-30 17:59:25 +00001921
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001922 OS << "namespace {\n";
Daniel Dunbar71330282009-08-08 05:24:34 +00001923
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001924 // Output the operand conversion kind enum.
1925 OS << "enum OperatorConversionKind {\n";
1926 for (unsigned i = 0, e = OperandConversionKinds.size(); i != e; ++i)
1927 OS << " " << OperandConversionKinds[i] << ",\n";
1928 OS << " CVT_NUM_CONVERTERS\n";
Daniel Dunbar71330282009-08-08 05:24:34 +00001929 OS << "};\n\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00001930
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001931 // Output the instruction conversion kind enum.
1932 OS << "enum InstructionConversionKind {\n";
1933 for (SetVector<std::string>::const_iterator
1934 i = InstructionConversionKinds.begin(),
1935 e = InstructionConversionKinds.end(); i != e; ++i)
1936 OS << " " << *i << ",\n";
1937 OS << " CVT_NUM_SIGNATURES\n";
1938 OS << "};\n\n";
1939
1940
1941 OS << "} // end anonymous namespace\n\n";
1942
1943 // Output the conversion table.
Craig Topper91506102012-09-18 01:41:49 +00001944 OS << "static const uint8_t ConversionTable[CVT_NUM_SIGNATURES]["
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001945 << MaxRowLength << "] = {\n";
1946
1947 for (unsigned Row = 0, ERow = ConversionTable.size(); Row != ERow; ++Row) {
1948 assert(ConversionTable[Row].size() % 2 == 0 && "bad conversion row!");
1949 OS << " // " << InstructionConversionKinds[Row] << "\n";
1950 OS << " { ";
1951 for (unsigned i = 0, e = ConversionTable[Row].size(); i != e; i += 2)
1952 OS << OperandConversionKinds[ConversionTable[Row][i]] << ", "
1953 << (unsigned)(ConversionTable[Row][i + 1]) << ", ";
1954 OS << "CVT_Done },\n";
1955 }
1956
1957 OS << "};\n\n";
1958
1959 // Spit out the conversion driver function.
Daniel Dunbar71330282009-08-08 05:24:34 +00001960 OS << CvtOS.str();
Jim Grosbachc93f6c72012-08-22 01:06:23 +00001961
Chad Rosier738ea252012-08-30 17:59:25 +00001962 // Spit out the operand number lookup function.
1963 OS << OpOS.str();
Daniel Dunbarb6d6aa22009-07-31 02:32:59 +00001964}
1965
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001966/// emitMatchClassEnumeration - Emit the enumeration for match class kinds.
1967static void emitMatchClassEnumeration(CodeGenTarget &Target,
David Blaikied749e342014-11-28 20:35:57 +00001968 std::forward_list<ClassInfo> &Infos,
1969 raw_ostream &OS) {
Daniel Dunbar541efcc2009-08-08 07:50:56 +00001970 OS << "namespace {\n\n";
1971
1972 OS << "/// MatchClassKind - The kinds of classes which participate in\n"
1973 << "/// instruction matching.\n";
1974 OS << "enum MatchClassKind {\n";
1975 OS << " InvalidMatchClass = 0,\n";
Craig Topperf34dad92014-11-28 03:53:02 +00001976 for (const auto &CI : Infos) {
David Blaikied749e342014-11-28 20:35:57 +00001977 OS << " " << CI.Name << ", // ";
1978 if (CI.Kind == ClassInfo::Token) {
1979 OS << "'" << CI.ValueName << "'\n";
1980 } else if (CI.isRegisterClass()) {
1981 if (!CI.ValueName.empty())
1982 OS << "register class '" << CI.ValueName << "'\n";
Daniel Dunbar541efcc2009-08-08 07:50:56 +00001983 else
1984 OS << "derived register class\n";
1985 } else {
David Blaikied749e342014-11-28 20:35:57 +00001986 OS << "user defined class '" << CI.ValueName << "'\n";
Daniel Dunbar541efcc2009-08-08 07:50:56 +00001987 }
1988 }
1989 OS << " NumMatchClassKinds\n";
1990 OS << "};\n\n";
1991
1992 OS << "}\n\n";
1993}
1994
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00001995/// emitValidateOperandClass - Emit the function to validate an operand class.
1996static void emitValidateOperandClass(AsmMatcherInfo &Info,
Jim Grosbach6e2e29b2011-02-10 00:08:28 +00001997 raw_ostream &OS) {
David Blaikie960ea3f2014-06-08 16:18:35 +00001998 OS << "static unsigned validateOperandClass(MCParsedAsmOperand &GOp, "
Jim Grosbach6e2e29b2011-02-10 00:08:28 +00001999 << "MatchClassKind Kind) {\n";
David Blaikie960ea3f2014-06-08 16:18:35 +00002000 OS << " " << Info.Target.getName() << "Operand &Operand = ("
2001 << Info.Target.getName() << "Operand&)GOp;\n";
Daniel Dunbarbb98db22009-08-11 02:59:53 +00002002
Kevin Enderby1b87c802011-07-15 18:30:43 +00002003 // The InvalidMatchClass is not to match any operand.
2004 OS << " if (Kind == InvalidMatchClass)\n";
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002005 OS << " return MCTargetAsmParser::Match_InvalidOperand;\n\n";
Kevin Enderby1b87c802011-07-15 18:30:43 +00002006
Jim Grosbach6e2e29b2011-02-10 00:08:28 +00002007 // Check for Token operands first.
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002008 // FIXME: Use a more specific diagnostic type.
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002009 OS << " if (Operand.isToken())\n";
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002010 OS << " return isSubclass(matchTokenString(Operand.getToken()), Kind) ?\n"
2011 << " MCTargetAsmParser::Match_Success :\n"
2012 << " MCTargetAsmParser::Match_InvalidOperand;\n\n";
Daniel Dunbarbb98db22009-08-11 02:59:53 +00002013
Jim Grosbach6e2e29b2011-02-10 00:08:28 +00002014 // Check the user classes. We don't care what order since we're only
2015 // actually matching against one of them.
Craig Topperf34dad92014-11-28 03:53:02 +00002016 for (const auto &CI : Info.Classes) {
David Blaikied749e342014-11-28 20:35:57 +00002017 if (!CI.isUserClass())
Daniel Dunbarbb98db22009-08-11 02:59:53 +00002018 continue;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002019
David Blaikied749e342014-11-28 20:35:57 +00002020 OS << " // '" << CI.ClassName << "' class\n";
2021 OS << " if (Kind == " << CI.Name << ") {\n";
2022 OS << " if (Operand." << CI.PredicateMethod << "())\n";
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002023 OS << " return MCTargetAsmParser::Match_Success;\n";
David Blaikied749e342014-11-28 20:35:57 +00002024 if (!CI.DiagnosticType.empty())
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002025 OS << " return " << Info.Target.getName() << "AsmParser::Match_"
David Blaikied749e342014-11-28 20:35:57 +00002026 << CI.DiagnosticType << ";\n";
Daniel Dunbarbb98db22009-08-11 02:59:53 +00002027 OS << " }\n\n";
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002028 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002029
Owen Anderson8a503f22012-07-16 23:20:09 +00002030 // Check for register operands, including sub-classes.
2031 OS << " if (Operand.isReg()) {\n";
2032 OS << " MatchClassKind OpKind;\n";
2033 OS << " switch (Operand.getReg()) {\n";
2034 OS << " default: OpKind = InvalidMatchClass; break;\n";
Craig Topper03ec8012014-11-25 20:11:31 +00002035 for (const auto &RC : Info.RegisterClasses)
Owen Anderson8a503f22012-07-16 23:20:09 +00002036 OS << " case " << Info.Target.getName() << "::"
Craig Topper03ec8012014-11-25 20:11:31 +00002037 << RC.first->getName() << ": OpKind = " << RC.second->Name
Owen Anderson8a503f22012-07-16 23:20:09 +00002038 << "; break;\n";
2039 OS << " }\n";
2040 OS << " return isSubclass(OpKind, Kind) ? "
2041 << "MCTargetAsmParser::Match_Success :\n "
2042 << " MCTargetAsmParser::Match_InvalidOperand;\n }\n\n";
2043
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002044 // Generic fallthrough match failure case for operands that don't have
2045 // specialized diagnostic types.
2046 OS << " return MCTargetAsmParser::Match_InvalidOperand;\n";
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002047 OS << "}\n\n";
2048}
2049
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002050/// emitIsSubclass - Emit the subclass predicate function.
2051static void emitIsSubclass(CodeGenTarget &Target,
David Blaikied749e342014-11-28 20:35:57 +00002052 std::forward_list<ClassInfo> &Infos,
Daniel Dunbar2587b612009-08-10 16:05:47 +00002053 raw_ostream &OS) {
Dmitri Gribenko8d302402012-09-15 20:22:05 +00002054 OS << "/// isSubclass - Compute whether \\p A is a subclass of \\p B.\n";
Jim Grosbach1f5c5aa2011-12-06 22:07:02 +00002055 OS << "static bool isSubclass(MatchClassKind A, MatchClassKind B) {\n";
Daniel Dunbar2587b612009-08-10 16:05:47 +00002056 OS << " if (A == B)\n";
2057 OS << " return true;\n\n";
2058
Reid Klecknerd78273f2013-08-06 22:51:21 +00002059 std::string OStr;
2060 raw_string_ostream SS(OStr);
Aaron Ballmane59e3582013-07-15 16:53:32 +00002061 unsigned Count = 0;
2062 SS << " switch (A) {\n";
2063 SS << " default:\n";
2064 SS << " return false;\n";
Craig Topperf34dad92014-11-28 03:53:02 +00002065 for (const auto &A : Infos) {
Jim Grosbachba395922011-12-06 23:43:54 +00002066 std::vector<StringRef> SuperClasses;
Craig Topperf34dad92014-11-28 03:53:02 +00002067 for (const auto &B : Infos) {
David Blaikied749e342014-11-28 20:35:57 +00002068 if (&A != &B && A.isSubsetOf(B))
2069 SuperClasses.push_back(B.Name);
Daniel Dunbar2587b612009-08-10 16:05:47 +00002070 }
Jim Grosbachba395922011-12-06 23:43:54 +00002071
2072 if (SuperClasses.empty())
2073 continue;
Aaron Ballmane59e3582013-07-15 16:53:32 +00002074 ++Count;
Jim Grosbachba395922011-12-06 23:43:54 +00002075
David Blaikied749e342014-11-28 20:35:57 +00002076 SS << "\n case " << A.Name << ":\n";
Jim Grosbachba395922011-12-06 23:43:54 +00002077
2078 if (SuperClasses.size() == 1) {
Aaron Ballmane59e3582013-07-15 16:53:32 +00002079 SS << " return B == " << SuperClasses.back().str() << ";\n";
Jim Grosbachba395922011-12-06 23:43:54 +00002080 continue;
2081 }
2082
Aaron Ballmane59e3582013-07-15 16:53:32 +00002083 if (!SuperClasses.empty()) {
2084 SS << " switch (B) {\n";
2085 SS << " default: return false;\n";
2086 for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
2087 SS << " case " << SuperClasses[i].str() << ": return true;\n";
2088 SS << " }\n";
2089 } else {
2090 // No case statement to emit
2091 SS << " return false;\n";
2092 }
Daniel Dunbar2587b612009-08-10 16:05:47 +00002093 }
Aaron Ballmane59e3582013-07-15 16:53:32 +00002094 SS << " }\n";
2095
2096 // If there were case statements emitted into the string stream, write them
2097 // to the output stream, otherwise write the default.
2098 if (Count)
2099 OS << SS.str();
2100 else
2101 OS << " return false;\n";
2102
Daniel Dunbar2587b612009-08-10 16:05:47 +00002103 OS << "}\n\n";
2104}
2105
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002106/// emitMatchTokenString - Emit the function to match a token string to the
Daniel Dunbar66f4f542009-08-08 21:22:41 +00002107/// appropriate match class value.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002108static void emitMatchTokenString(CodeGenTarget &Target,
David Blaikied749e342014-11-28 20:35:57 +00002109 std::forward_list<ClassInfo> &Infos,
Daniel Dunbar66f4f542009-08-08 21:22:41 +00002110 raw_ostream &OS) {
2111 // Construct the match list.
Chris Lattnerca5a3552010-09-06 02:01:51 +00002112 std::vector<StringMatcher::StringPair> Matches;
Craig Topperf34dad92014-11-28 03:53:02 +00002113 for (const auto &CI : Infos) {
David Blaikied749e342014-11-28 20:35:57 +00002114 if (CI.Kind == ClassInfo::Token)
David Blaikie6297eb52014-11-28 21:20:22 +00002115 Matches.push_back(
2116 StringMatcher::StringPair(CI.ValueName, "return " + CI.Name + ";"));
Daniel Dunbar66f4f542009-08-08 21:22:41 +00002117 }
2118
Jim Grosbach1f5c5aa2011-12-06 22:07:02 +00002119 OS << "static MatchClassKind matchTokenString(StringRef Name) {\n";
Daniel Dunbar66f4f542009-08-08 21:22:41 +00002120
Chris Lattnerca5a3552010-09-06 02:01:51 +00002121 StringMatcher("Name", Matches, OS).Emit();
Daniel Dunbar66f4f542009-08-08 21:22:41 +00002122
2123 OS << " return InvalidMatchClass;\n";
2124 OS << "}\n\n";
2125}
Chris Lattner00e2e742009-08-08 20:02:57 +00002126
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002127/// emitMatchRegisterName - Emit the function to match a string to the target
Daniel Dunbard0470d72009-08-07 21:01:44 +00002128/// specific register enum.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002129static void emitMatchRegisterName(CodeGenTarget &Target, Record *AsmParser,
Daniel Dunbard0470d72009-08-07 21:01:44 +00002130 raw_ostream &OS) {
Daniel Dunbar66f4f542009-08-08 21:22:41 +00002131 // Construct the match list.
Chris Lattnerca5a3552010-09-06 02:01:51 +00002132 std::vector<StringMatcher::StringPair> Matches;
Jakob Stoklund Olesen8e188be2011-06-18 04:26:06 +00002133 const std::vector<CodeGenRegister*> &Regs =
2134 Target.getRegBank().getRegisters();
2135 for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
2136 const CodeGenRegister *Reg = Regs[i];
2137 if (Reg->TheDef->getValueAsString("AsmName").empty())
Daniel Dunbare2eec052009-07-17 18:51:11 +00002138 continue;
2139
Chris Lattnerca5a3552010-09-06 02:01:51 +00002140 Matches.push_back(StringMatcher::StringPair(
Jakob Stoklund Olesen8e188be2011-06-18 04:26:06 +00002141 Reg->TheDef->getValueAsString("AsmName"),
2142 "return " + utostr(Reg->EnumValue) + ";"));
Daniel Dunbare2eec052009-07-17 18:51:11 +00002143 }
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002144
Chris Lattner60db0a62010-02-09 00:34:28 +00002145 OS << "static unsigned MatchRegisterName(StringRef Name) {\n";
Daniel Dunbar66f4f542009-08-08 21:22:41 +00002146
Chris Lattnerca5a3552010-09-06 02:01:51 +00002147 StringMatcher("Name", Matches, OS).Emit();
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002148
Daniel Dunbar66f4f542009-08-08 21:22:41 +00002149 OS << " return 0;\n";
Daniel Dunbare10787e2009-08-07 08:26:05 +00002150 OS << "}\n\n";
Daniel Dunbard0470d72009-08-07 21:01:44 +00002151}
Daniel Dunbarb6d6aa22009-07-31 02:32:59 +00002152
Daniel Sanders3ea92742014-05-21 10:11:24 +00002153static const char *getMinimalTypeForRange(uint64_t Range) {
Tim Northover26bb14e2014-08-18 11:49:42 +00002154 assert(Range <= 0xFFFFFFFFFFFFFFFFULL && "Enum too large");
2155 if (Range > 0xFFFFFFFFULL)
2156 return "uint64_t";
Daniel Sanders3ea92742014-05-21 10:11:24 +00002157 if (Range > 0xFFFF)
2158 return "uint32_t";
2159 if (Range > 0xFF)
2160 return "uint16_t";
2161 return "uint8_t";
2162}
2163
2164static const char *getMinimalRequiredFeaturesType(const AsmMatcherInfo &Info) {
2165 uint64_t MaxIndex = Info.SubtargetFeatures.size();
2166 if (MaxIndex > 0)
2167 MaxIndex--;
2168 return getMinimalTypeForRange(1ULL << MaxIndex);
2169}
2170
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002171/// emitSubtargetFeatureFlagEnumeration - Emit the subtarget feature flag
Daniel Dunbareefe8612010-07-19 05:44:09 +00002172/// definitions.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002173static void emitSubtargetFeatureFlagEnumeration(AsmMatcherInfo &Info,
Daniel Dunbareefe8612010-07-19 05:44:09 +00002174 raw_ostream &OS) {
2175 OS << "// Flags for subtarget features that participate in "
2176 << "instruction matching.\n";
Daniel Sanders3ea92742014-05-21 10:11:24 +00002177 OS << "enum SubtargetFeatureFlag : " << getMinimalRequiredFeaturesType(Info)
2178 << " {\n";
Craig Topper42bd8192014-11-28 03:53:00 +00002179 for (const auto &SF : Info.SubtargetFeatures) {
David Blaikief6d4b1c2014-11-28 22:01:06 +00002180 SubtargetFeatureInfo &SFI = *SF.second;
Tim Northover26bb14e2014-08-18 11:49:42 +00002181 OS << " " << SFI.getEnumName() << " = (1ULL << " << SFI.Index << "),\n";
Daniel Dunbareefe8612010-07-19 05:44:09 +00002182 }
2183 OS << " Feature_None = 0\n";
2184 OS << "};\n\n";
2185}
2186
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002187/// emitOperandDiagnosticTypes - Emit the operand matching diagnostic types.
2188static void emitOperandDiagnosticTypes(AsmMatcherInfo &Info, raw_ostream &OS) {
2189 // Get the set of diagnostic types from all of the operand classes.
2190 std::set<StringRef> Types;
2191 for (std::map<Record*, ClassInfo*>::const_iterator
2192 I = Info.AsmOperandClasses.begin(),
2193 E = Info.AsmOperandClasses.end(); I != E; ++I) {
2194 if (!I->second->DiagnosticType.empty())
2195 Types.insert(I->second->DiagnosticType);
2196 }
2197
2198 if (Types.empty()) return;
2199
2200 // Now emit the enum entries.
2201 for (std::set<StringRef>::const_iterator I = Types.begin(), E = Types.end();
2202 I != E; ++I)
2203 OS << " Match_" << *I << ",\n";
2204 OS << " END_OPERAND_DIAGNOSTIC_TYPES\n";
2205}
2206
Jim Grosbach5117ef72012-04-24 22:40:08 +00002207/// emitGetSubtargetFeatureName - Emit the helper function to get the
2208/// user-level name for a subtarget feature.
2209static void emitGetSubtargetFeatureName(AsmMatcherInfo &Info, raw_ostream &OS) {
2210 OS << "// User-level names for subtarget features that participate in\n"
2211 << "// instruction matching.\n"
Tim Northover26bb14e2014-08-18 11:49:42 +00002212 << "static const char *getSubtargetFeatureName(uint64_t Val) {\n";
Aaron Ballmane59e3582013-07-15 16:53:32 +00002213 if (!Info.SubtargetFeatures.empty()) {
2214 OS << " switch(Val) {\n";
Craig Topper42bd8192014-11-28 03:53:00 +00002215 for (const auto &SF : Info.SubtargetFeatures) {
David Blaikief6d4b1c2014-11-28 22:01:06 +00002216 SubtargetFeatureInfo &SFI = *SF.second;
Aaron Ballmane59e3582013-07-15 16:53:32 +00002217 // FIXME: Totally just a placeholder name to get the algorithm working.
2218 OS << " case " << SFI.getEnumName() << ": return \""
2219 << SFI.TheDef->getValueAsString("PredicateName") << "\";\n";
2220 }
2221 OS << " default: return \"(unknown)\";\n";
2222 OS << " }\n";
2223 } else {
2224 // Nothing to emit, so skip the switch
2225 OS << " return \"(unknown)\";\n";
Jim Grosbach5117ef72012-04-24 22:40:08 +00002226 }
Aaron Ballmane59e3582013-07-15 16:53:32 +00002227 OS << "}\n\n";
Jim Grosbach5117ef72012-04-24 22:40:08 +00002228}
2229
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002230/// emitComputeAvailableFeatures - Emit the function to compute the list of
Daniel Dunbareefe8612010-07-19 05:44:09 +00002231/// available features given a subtarget.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002232static void emitComputeAvailableFeatures(AsmMatcherInfo &Info,
Daniel Dunbareefe8612010-07-19 05:44:09 +00002233 raw_ostream &OS) {
2234 std::string ClassName =
2235 Info.AsmParser->getValueAsString("AsmParserClassName");
2236
Tim Northover26bb14e2014-08-18 11:49:42 +00002237 OS << "uint64_t " << Info.Target.getName() << ClassName << "::\n"
Evan Cheng4d1ca962011-07-08 01:53:10 +00002238 << "ComputeAvailableFeatures(uint64_t FB) const {\n";
Tim Northover26bb14e2014-08-18 11:49:42 +00002239 OS << " uint64_t Features = 0;\n";
Craig Topper42bd8192014-11-28 03:53:00 +00002240 for (const auto &SF : Info.SubtargetFeatures) {
David Blaikief6d4b1c2014-11-28 22:01:06 +00002241 SubtargetFeatureInfo &SFI = *SF.second;
Evan Cheng4d1ca962011-07-08 01:53:10 +00002242
2243 OS << " if (";
Jim Grosbach56e63262012-04-17 00:01:04 +00002244 std::string CondStorage =
2245 SFI.TheDef->getValueAsString("AssemblerCondString");
Evan Cheng1a6d5512011-07-08 18:04:22 +00002246 StringRef Conds = CondStorage;
Evan Cheng4d1ca962011-07-08 01:53:10 +00002247 std::pair<StringRef,StringRef> Comma = Conds.split(',');
2248 bool First = true;
2249 do {
2250 if (!First)
2251 OS << " && ";
2252
2253 bool Neg = false;
2254 StringRef Cond = Comma.first;
2255 if (Cond[0] == '!') {
2256 Neg = true;
2257 Cond = Cond.substr(1);
2258 }
2259
2260 OS << "((FB & " << Info.Target.getName() << "::" << Cond << ")";
2261 if (Neg)
2262 OS << " == 0";
2263 else
2264 OS << " != 0";
2265 OS << ")";
2266
2267 if (Comma.second.empty())
2268 break;
2269
2270 First = false;
2271 Comma = Comma.second.split(',');
2272 } while (true);
2273
2274 OS << ")\n";
Chris Lattnera0e87192010-10-30 20:07:57 +00002275 OS << " Features |= " << SFI.getEnumName() << ";\n";
Daniel Dunbareefe8612010-07-19 05:44:09 +00002276 }
2277 OS << " return Features;\n";
2278 OS << "}\n\n";
2279}
2280
Chris Lattner43690072010-10-30 20:15:02 +00002281static std::string GetAliasRequiredFeatures(Record *R,
2282 const AsmMatcherInfo &Info) {
Chris Lattner2cb092d2010-10-30 19:23:13 +00002283 std::vector<Record*> ReqFeatures = R->getValueAsListOfDefs("Predicates");
Chris Lattner2cb092d2010-10-30 19:23:13 +00002284 std::string Result;
2285 unsigned NumFeatures = 0;
2286 for (unsigned i = 0, e = ReqFeatures.size(); i != e; ++i) {
David Blaikief6d4b1c2014-11-28 22:01:06 +00002287 SubtargetFeatureInfo *F = Info.getSubtargetFeature(ReqFeatures[i]);
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002288
Craig Topper24064772014-04-15 07:20:03 +00002289 if (!F)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00002290 PrintFatalError(R->getLoc(), "Predicate '" + ReqFeatures[i]->getName() +
Chris Lattner517dc952010-11-01 02:09:21 +00002291 "' is not marked as an AssemblerPredicate!");
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002292
Chris Lattner517dc952010-11-01 02:09:21 +00002293 if (NumFeatures)
2294 Result += '|';
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002295
Chris Lattner517dc952010-11-01 02:09:21 +00002296 Result += F->getEnumName();
2297 ++NumFeatures;
Chris Lattner2cb092d2010-10-30 19:23:13 +00002298 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002299
Chris Lattner2cb092d2010-10-30 19:23:13 +00002300 if (NumFeatures > 1)
2301 Result = '(' + Result + ')';
2302 return Result;
2303}
2304
Chad Rosier9f7a2212013-04-18 22:35:36 +00002305static void emitMnemonicAliasVariant(raw_ostream &OS,const AsmMatcherInfo &Info,
2306 std::vector<Record*> &Aliases,
2307 unsigned Indent = 0,
2308 StringRef AsmParserVariantName = StringRef()){
Chris Lattnercf9b6e32010-10-30 18:56:12 +00002309 // Keep track of all the aliases from a mnemonic. Use an std::map so that the
2310 // iteration order of the map is stable.
2311 std::map<std::string, std::vector<Record*> > AliasesFromMnemonic;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002312
Chris Lattnerba7b4fe2010-10-30 17:36:36 +00002313 for (unsigned i = 0, e = Aliases.size(); i != e; ++i) {
2314 Record *R = Aliases[i];
Chad Rosier9f7a2212013-04-18 22:35:36 +00002315 // FIXME: Allow AssemblerVariantName to be a comma separated list.
2316 std::string AsmVariantName = R->getValueAsString("AsmVariantName");
2317 if (AsmVariantName != AsmParserVariantName)
2318 continue;
Chris Lattnercf9b6e32010-10-30 18:56:12 +00002319 AliasesFromMnemonic[R->getValueAsString("FromMnemonic")].push_back(R);
Chris Lattnerba7b4fe2010-10-30 17:36:36 +00002320 }
Chad Rosier9f7a2212013-04-18 22:35:36 +00002321 if (AliasesFromMnemonic.empty())
2322 return;
Vladimir Medic75429ad2013-07-16 09:22:38 +00002323
Chris Lattnercf9b6e32010-10-30 18:56:12 +00002324 // Process each alias a "from" mnemonic at a time, building the code executed
2325 // by the string remapper.
2326 std::vector<StringMatcher::StringPair> Cases;
2327 for (std::map<std::string, std::vector<Record*> >::iterator
2328 I = AliasesFromMnemonic.begin(), E = AliasesFromMnemonic.end();
2329 I != E; ++I) {
Chris Lattnercf9b6e32010-10-30 18:56:12 +00002330 const std::vector<Record*> &ToVec = I->second;
Chris Lattner2cb092d2010-10-30 19:23:13 +00002331
2332 // Loop through each alias and emit code that handles each case. If there
2333 // are two instructions without predicates, emit an error. If there is one,
2334 // emit it last.
2335 std::string MatchCode;
2336 int AliasWithNoPredicate = -1;
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002337
Chris Lattner2cb092d2010-10-30 19:23:13 +00002338 for (unsigned i = 0, e = ToVec.size(); i != e; ++i) {
2339 Record *R = ToVec[i];
Chris Lattner43690072010-10-30 20:15:02 +00002340 std::string FeatureMask = GetAliasRequiredFeatures(R, Info);
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002341
Chris Lattner2cb092d2010-10-30 19:23:13 +00002342 // If this unconditionally matches, remember it for later and diagnose
2343 // duplicates.
2344 if (FeatureMask.empty()) {
2345 if (AliasWithNoPredicate != -1) {
2346 // We can't have two aliases from the same mnemonic with no predicate.
2347 PrintError(ToVec[AliasWithNoPredicate]->getLoc(),
2348 "two MnemonicAliases with the same 'from' mnemonic!");
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00002349 PrintFatalError(R->getLoc(), "this is the other MnemonicAlias.");
Chris Lattner2cb092d2010-10-30 19:23:13 +00002350 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002351
Chris Lattner2cb092d2010-10-30 19:23:13 +00002352 AliasWithNoPredicate = i;
2353 continue;
2354 }
Joerg Sonnenberger07cbde92011-02-17 23:22:19 +00002355 if (R->getValueAsString("ToMnemonic") == I->first)
Joerg Sonnenberger635debe2012-10-25 20:33:17 +00002356 PrintFatalError(R->getLoc(), "MnemonicAlias to the same string");
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002357
Chris Lattnerf9ec2fb2010-10-30 19:47:49 +00002358 if (!MatchCode.empty())
2359 MatchCode += "else ";
Chris Lattner2cb092d2010-10-30 19:23:13 +00002360 MatchCode += "if ((Features & " + FeatureMask + ") == "+FeatureMask+")\n";
2361 MatchCode += " Mnemonic = \"" +R->getValueAsString("ToMnemonic")+"\";\n";
Chris Lattnercf9b6e32010-10-30 18:56:12 +00002362 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002363
Chris Lattner2cb092d2010-10-30 19:23:13 +00002364 if (AliasWithNoPredicate != -1) {
2365 Record *R = ToVec[AliasWithNoPredicate];
Chris Lattnerf9ec2fb2010-10-30 19:47:49 +00002366 if (!MatchCode.empty())
2367 MatchCode += "else\n ";
2368 MatchCode += "Mnemonic = \"" + R->getValueAsString("ToMnemonic")+"\";\n";
Chris Lattner2cb092d2010-10-30 19:23:13 +00002369 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002370
Chris Lattner2cb092d2010-10-30 19:23:13 +00002371 MatchCode += "return;";
2372
2373 Cases.push_back(std::make_pair(I->first, MatchCode));
Chris Lattnercf9b6e32010-10-30 18:56:12 +00002374 }
Chad Rosier9f7a2212013-04-18 22:35:36 +00002375 StringMatcher("Mnemonic", Cases, OS).Emit(Indent);
2376}
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002377
Chad Rosier9f7a2212013-04-18 22:35:36 +00002378/// emitMnemonicAliases - If the target has any MnemonicAlias<> definitions,
2379/// emit a function for them and return true, otherwise return false.
2380static bool emitMnemonicAliases(raw_ostream &OS, const AsmMatcherInfo &Info,
2381 CodeGenTarget &Target) {
2382 // Ignore aliases when match-prefix is set.
2383 if (!MatchPrefix.empty())
2384 return false;
2385
2386 std::vector<Record*> Aliases =
2387 Info.getRecords().getAllDerivedDefinitions("MnemonicAlias");
2388 if (Aliases.empty()) return false;
2389
2390 OS << "static void applyMnemonicAliases(StringRef &Mnemonic, "
Tim Northover26bb14e2014-08-18 11:49:42 +00002391 "uint64_t Features, unsigned VariantID) {\n";
Chad Rosier9f7a2212013-04-18 22:35:36 +00002392 OS << " switch (VariantID) {\n";
2393 unsigned VariantCount = Target.getAsmParserVariantCount();
2394 for (unsigned VC = 0; VC != VariantCount; ++VC) {
2395 Record *AsmVariant = Target.getAsmParserVariant(VC);
2396 int AsmParserVariantNo = AsmVariant->getValueAsInt("Variant");
2397 std::string AsmParserVariantName = AsmVariant->getValueAsString("Name");
2398 OS << " case " << AsmParserVariantNo << ":\n";
2399 emitMnemonicAliasVariant(OS, Info, Aliases, /*Indent=*/2,
2400 AsmParserVariantName);
2401 OS << " break;\n";
2402 }
2403 OS << " }\n";
2404
2405 // Emit aliases that apply to all variants.
2406 emitMnemonicAliasVariant(OS, Info, Aliases);
2407
Daniel Dunbare46bc4c2011-01-18 01:59:30 +00002408 OS << "}\n\n";
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002409
Chris Lattner477fba4f2010-10-30 18:48:18 +00002410 return true;
Chris Lattnerba7b4fe2010-10-30 17:36:36 +00002411}
2412
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002413static void emitCustomOperandParsing(raw_ostream &OS, CodeGenTarget &Target,
Craig Topper7ecfa6d2012-09-18 07:02:21 +00002414 const AsmMatcherInfo &Info, StringRef ClassName,
2415 StringToOffsetTable &StringTable,
2416 unsigned MaxMnemonicIndex) {
2417 unsigned MaxMask = 0;
2418 for (std::vector<OperandMatchEntry>::const_iterator it =
2419 Info.OperandMatchInfo.begin(), ie = Info.OperandMatchInfo.end();
2420 it != ie; ++it) {
2421 MaxMask |= it->OperandMask;
2422 }
2423
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002424 // Emit the static custom operand parsing table;
2425 OS << "namespace {\n";
2426 OS << " struct OperandMatchEntry {\n";
Daniel Sanders3ea92742014-05-21 10:11:24 +00002427 OS << " " << getMinimalRequiredFeaturesType(Info)
Craig Topper4de73732012-04-02 07:48:39 +00002428 << " RequiredFeatures;\n";
Craig Topper7ecfa6d2012-09-18 07:02:21 +00002429 OS << " " << getMinimalTypeForRange(MaxMnemonicIndex)
2430 << " Mnemonic;\n";
David Blaikied749e342014-11-28 20:35:57 +00002431 OS << " " << getMinimalTypeForRange(std::distance(
2432 Info.Classes.begin(), Info.Classes.end())) << " Class;\n";
Craig Topper7ecfa6d2012-09-18 07:02:21 +00002433 OS << " " << getMinimalTypeForRange(MaxMask)
2434 << " OperandMask;\n\n";
Benjamin Kramer0764a3f2012-03-03 20:44:43 +00002435 OS << " StringRef getMnemonic() const {\n";
2436 OS << " return StringRef(MnemonicTable + Mnemonic + 1,\n";
2437 OS << " MnemonicTable[Mnemonic]);\n";
2438 OS << " }\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002439 OS << " };\n\n";
2440
2441 OS << " // Predicate for searching for an opcode.\n";
2442 OS << " struct LessOpcodeOperand {\n";
2443 OS << " bool operator()(const OperandMatchEntry &LHS, StringRef RHS) {\n";
Benjamin Kramer0764a3f2012-03-03 20:44:43 +00002444 OS << " return LHS.getMnemonic() < RHS;\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002445 OS << " }\n";
2446 OS << " bool operator()(StringRef LHS, const OperandMatchEntry &RHS) {\n";
Benjamin Kramer0764a3f2012-03-03 20:44:43 +00002447 OS << " return LHS < RHS.getMnemonic();\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002448 OS << " }\n";
2449 OS << " bool operator()(const OperandMatchEntry &LHS,";
2450 OS << " const OperandMatchEntry &RHS) {\n";
Benjamin Kramer0764a3f2012-03-03 20:44:43 +00002451 OS << " return LHS.getMnemonic() < RHS.getMnemonic();\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002452 OS << " }\n";
2453 OS << " };\n";
2454
2455 OS << "} // end anonymous namespace.\n\n";
2456
2457 OS << "static const OperandMatchEntry OperandMatchTable["
2458 << Info.OperandMatchInfo.size() << "] = {\n";
2459
Benjamin Kramer0764a3f2012-03-03 20:44:43 +00002460 OS << " /* Operand List Mask, Mnemonic, Operand Class, Features */\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002461 for (std::vector<OperandMatchEntry>::const_iterator it =
2462 Info.OperandMatchInfo.begin(), ie = Info.OperandMatchInfo.end();
2463 it != ie; ++it) {
2464 const OperandMatchEntry &OMI = *it;
2465 const MatchableInfo &II = *OMI.MI;
2466
Craig Topper7ecfa6d2012-09-18 07:02:21 +00002467 OS << " { ";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002468
Craig Topper7ecfa6d2012-09-18 07:02:21 +00002469 // Write the required features mask.
2470 if (!II.RequiredFeatures.empty()) {
2471 for (unsigned i = 0, e = II.RequiredFeatures.size(); i != e; ++i) {
2472 if (i) OS << "|";
2473 OS << II.RequiredFeatures[i]->getEnumName();
2474 }
2475 } else
2476 OS << "0";
2477
2478 // Store a pascal-style length byte in the mnemonic.
2479 std::string LenMnemonic = char(II.Mnemonic.size()) + II.Mnemonic.str();
2480 OS << ", " << StringTable.GetOrAddStringOffset(LenMnemonic, false)
2481 << " /* " << II.Mnemonic << " */, ";
2482
2483 OS << OMI.CI->Name;
2484
2485 OS << ", " << OMI.OperandMask;
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002486 OS << " /* ";
2487 bool printComma = false;
2488 for (int i = 0, e = 31; i !=e; ++i)
2489 if (OMI.OperandMask & (1 << i)) {
2490 if (printComma)
2491 OS << ", ";
2492 OS << i;
2493 printComma = true;
2494 }
2495 OS << " */";
2496
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002497 OS << " },\n";
2498 }
2499 OS << "};\n\n";
2500
2501 // Emit the operand class switch to call the correct custom parser for
2502 // the found operand class.
Jim Grosbach861e49c2011-02-12 01:34:40 +00002503 OS << Target.getName() << ClassName << "::OperandMatchResultTy "
2504 << Target.getName() << ClassName << "::\n"
David Blaikie960ea3f2014-06-08 16:18:35 +00002505 << "tryCustomParseOperand(OperandVector"
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002506 << " &Operands,\n unsigned MCK) {\n\n"
2507 << " switch(MCK) {\n";
2508
Craig Topperf34dad92014-11-28 03:53:02 +00002509 for (const auto &CI : Info.Classes) {
David Blaikied749e342014-11-28 20:35:57 +00002510 if (CI.ParserMethod.empty())
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002511 continue;
David Blaikied749e342014-11-28 20:35:57 +00002512 OS << " case " << CI.Name << ":\n"
2513 << " return " << CI.ParserMethod << "(Operands);\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002514 }
2515
2516 OS << " default:\n";
Jim Grosbach861e49c2011-02-12 01:34:40 +00002517 OS << " return MatchOperand_NoMatch;\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002518 OS << " }\n";
Jim Grosbach861e49c2011-02-12 01:34:40 +00002519 OS << " return MatchOperand_NoMatch;\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002520 OS << "}\n\n";
2521
2522 // Emit the static custom operand parser. This code is very similar with
2523 // the other matcher. Also use MatchResultTy here just in case we go for
2524 // a better error handling.
Jim Grosbach861e49c2011-02-12 01:34:40 +00002525 OS << Target.getName() << ClassName << "::OperandMatchResultTy "
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002526 << Target.getName() << ClassName << "::\n"
David Blaikie960ea3f2014-06-08 16:18:35 +00002527 << "MatchOperandParserImpl(OperandVector"
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002528 << " &Operands,\n StringRef Mnemonic) {\n";
2529
2530 // Emit code to get the available features.
2531 OS << " // Get the current feature set.\n";
Tim Northover26bb14e2014-08-18 11:49:42 +00002532 OS << " uint64_t AvailableFeatures = getAvailableFeatures();\n\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002533
2534 OS << " // Get the next operand index.\n";
2535 OS << " unsigned NextOpNum = Operands.size()-1;\n";
2536
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002537 // Emit code to search the table.
2538 OS << " // Search the table.\n";
2539 OS << " std::pair<const OperandMatchEntry*, const OperandMatchEntry*>";
2540 OS << " MnemonicRange =\n";
2541 OS << " std::equal_range(OperandMatchTable, OperandMatchTable+"
2542 << Info.OperandMatchInfo.size() << ", Mnemonic,\n"
2543 << " LessOpcodeOperand());\n\n";
2544
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002545 OS << " if (MnemonicRange.first == MnemonicRange.second)\n";
Jim Grosbach861e49c2011-02-12 01:34:40 +00002546 OS << " return MatchOperand_NoMatch;\n\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002547
2548 OS << " for (const OperandMatchEntry *it = MnemonicRange.first,\n"
2549 << " *ie = MnemonicRange.second; it != ie; ++it) {\n";
2550
2551 OS << " // equal_range guarantees that instruction mnemonic matches.\n";
Benjamin Kramer0764a3f2012-03-03 20:44:43 +00002552 OS << " assert(Mnemonic == it->getMnemonic());\n\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002553
2554 // Emit check that the required features are available.
2555 OS << " // check if the available features match\n";
2556 OS << " if ((AvailableFeatures & it->RequiredFeatures) "
2557 << "!= it->RequiredFeatures) {\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002558 OS << " continue;\n";
2559 OS << " }\n\n";
2560
2561 // Emit check to ensure the operand number matches.
2562 OS << " // check if the operand in question has a custom parser.\n";
2563 OS << " if (!(it->OperandMask & (1 << NextOpNum)))\n";
2564 OS << " continue;\n\n";
2565
2566 // Emit call to the custom parser method
2567 OS << " // call custom parse method to handle the operand\n";
Jim Grosbach861e49c2011-02-12 01:34:40 +00002568 OS << " OperandMatchResultTy Result = ";
Jim Grosbach1f5c5aa2011-12-06 22:07:02 +00002569 OS << "tryCustomParseOperand(Operands, it->Class);\n";
Jim Grosbach861e49c2011-02-12 01:34:40 +00002570 OS << " if (Result != MatchOperand_NoMatch)\n";
2571 OS << " return Result;\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002572 OS << " }\n\n";
2573
Jim Grosbach861e49c2011-02-12 01:34:40 +00002574 OS << " // Okay, we had no match.\n";
2575 OS << " return MatchOperand_NoMatch;\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002576 OS << "}\n\n";
2577}
2578
Daniel Dunbard0470d72009-08-07 21:01:44 +00002579void AsmMatcherEmitter::run(raw_ostream &OS) {
Chris Lattner77d369c2010-12-13 00:23:57 +00002580 CodeGenTarget Target(Records);
Daniel Dunbard0470d72009-08-07 21:01:44 +00002581 Record *AsmParser = Target.getAsmParser();
2582 std::string ClassName = AsmParser->getValueAsString("AsmParserClassName");
2583
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002584 // Compute the information on the instructions to match.
Chris Lattner77d369c2010-12-13 00:23:57 +00002585 AsmMatcherInfo Info(AsmParser, Target, Records);
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002586 Info.buildInfo();
Daniel Dunbarb6d6aa22009-07-31 02:32:59 +00002587
Daniel Dunbar3b8a4662010-02-02 23:46:36 +00002588 // Sort the instruction table using the partial order on classes. We use
2589 // stable_sort to ensure that ambiguous instructions are still
2590 // deterministically ordered.
David Blaikie6c13c362014-11-28 21:20:24 +00002591 Info.Matchables.sort();
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002592
Daniel Dunbar71330282009-08-08 05:24:34 +00002593 DEBUG_WITH_TYPE("instruction_info", {
Craig Topperf34dad92014-11-28 03:53:02 +00002594 for (const auto &MI : Info.Matchables)
David Blaikie6c13c362014-11-28 21:20:24 +00002595 MI.dump();
Daniel Dunbare10787e2009-08-07 08:26:05 +00002596 });
Daniel Dunbarb6d6aa22009-07-31 02:32:59 +00002597
Chris Lattnerad776812010-11-01 05:06:45 +00002598 // Check for ambiguous matchables.
Chris Lattnerc0658cb2010-09-06 21:28:52 +00002599 DEBUG_WITH_TYPE("ambiguous_instrs", {
2600 unsigned NumAmbiguous = 0;
David Blaikie6c13c362014-11-28 21:20:24 +00002601 for (auto I = Info.Matchables.begin(), E = Info.Matchables.end(); I != E;
2602 ++I) {
2603 for (auto J = std::next(I); J != E; ++J) {
2604 const MatchableInfo &A = *I;
2605 const MatchableInfo &B = *J;
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002606
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002607 if (A.couldMatchAmbiguouslyWith(B)) {
Chris Lattnerad776812010-11-01 05:06:45 +00002608 errs() << "warning: ambiguous matchables:\n";
Chris Lattnerc0658cb2010-09-06 21:28:52 +00002609 A.dump();
2610 errs() << "\nis incomparable with:\n";
2611 B.dump();
2612 errs() << "\n\n";
Chris Lattnerfdb7dec2010-09-06 20:21:47 +00002613 ++NumAmbiguous;
2614 }
Daniel Dunbarf573b562009-08-09 06:05:33 +00002615 }
Daniel Dunbar3239f022009-08-09 04:00:06 +00002616 }
Chris Lattnerfdb7dec2010-09-06 20:21:47 +00002617 if (NumAmbiguous)
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002618 errs() << "warning: " << NumAmbiguous
Chris Lattnerad776812010-11-01 05:06:45 +00002619 << " ambiguous matchables!\n";
Chris Lattnerc0658cb2010-09-06 21:28:52 +00002620 });
Daniel Dunbar3239f022009-08-09 04:00:06 +00002621
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002622 // Compute the information on the custom operand parsing.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002623 Info.buildOperandMatchInfo();
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002624
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00002625 // Write the output.
2626
Chris Lattner3e4582a2010-09-06 19:11:01 +00002627 // Information for the class declaration.
2628 OS << "\n#ifdef GET_ASSEMBLER_HEADER\n";
2629 OS << "#undef GET_ASSEMBLER_HEADER\n";
Jim Grosbach860a84d2011-02-11 21:31:55 +00002630 OS << " // This should be included into the middle of the declaration of\n";
Evan Cheng11424442011-07-26 00:24:13 +00002631 OS << " // your subclasses implementation of MCTargetAsmParser.\n";
Tim Northover26bb14e2014-08-18 11:49:42 +00002632 OS << " uint64_t ComputeAvailableFeatures(uint64_t FeatureBits) const;\n";
Chad Rosierba284b92012-09-05 01:02:38 +00002633 OS << " void convertToMCInst(unsigned Kind, MCInst &Inst, "
Daniel Dunbar191524e2011-02-04 23:17:40 +00002634 << "unsigned Opcode,\n"
David Blaikie960ea3f2014-06-08 16:18:35 +00002635 << " const OperandVector "
Daniel Dunbar191524e2011-02-04 23:17:40 +00002636 << "&Operands);\n";
Chad Rosier380a74a2012-10-02 00:25:57 +00002637 OS << " void convertToMapAndConstraints(unsigned Kind,\n ";
David Blaikie960ea3f2014-06-08 16:18:35 +00002638 OS << " const OperandVector &Operands) override;\n";
Craig Topper39012cc2014-03-09 18:03:14 +00002639 OS << " bool mnemonicIsValid(StringRef Mnemonic, unsigned VariantID) override;\n";
Chad Rosier8f06e7d2012-10-05 18:41:14 +00002640 OS << " unsigned MatchInstructionImpl(\n";
2641 OS.indent(27);
David Blaikie960ea3f2014-06-08 16:18:35 +00002642 OS << "const OperandVector &Operands,\n"
Chad Rosier2f480a82012-10-12 22:53:36 +00002643 << " MCInst &Inst,\n"
Tim Northover26bb14e2014-08-18 11:49:42 +00002644 << " uint64_t &ErrorInfo,"
Chad Rosier380a74a2012-10-02 00:25:57 +00002645 << " bool matchingInlineAsm,\n"
2646 << " unsigned VariantID = 0);\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002647
2648 if (Info.OperandMatchInfo.size()) {
Jim Grosbach861e49c2011-02-12 01:34:40 +00002649 OS << "\n enum OperandMatchResultTy {\n";
2650 OS << " MatchOperand_Success, // operand matched successfully\n";
2651 OS << " MatchOperand_NoMatch, // operand did not match\n";
2652 OS << " MatchOperand_ParseFail // operand matched but had errors\n";
2653 OS << " };\n";
2654 OS << " OperandMatchResultTy MatchOperandParserImpl(\n";
David Blaikie960ea3f2014-06-08 16:18:35 +00002655 OS << " OperandVector &Operands,\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002656 OS << " StringRef Mnemonic);\n";
2657
Jim Grosbach1f5c5aa2011-12-06 22:07:02 +00002658 OS << " OperandMatchResultTy tryCustomParseOperand(\n";
David Blaikie960ea3f2014-06-08 16:18:35 +00002659 OS << " OperandVector &Operands,\n";
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002660 OS << " unsigned MCK);\n\n";
2661 }
2662
Chris Lattner3e4582a2010-09-06 19:11:01 +00002663 OS << "#endif // GET_ASSEMBLER_HEADER_INFO\n\n";
2664
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002665 // Emit the operand match diagnostic enum names.
2666 OS << "\n#ifdef GET_OPERAND_DIAGNOSTIC_TYPES\n";
2667 OS << "#undef GET_OPERAND_DIAGNOSTIC_TYPES\n\n";
2668 emitOperandDiagnosticTypes(Info, OS);
2669 OS << "#endif // GET_OPERAND_DIAGNOSTIC_TYPES\n\n";
2670
2671
Chris Lattner3e4582a2010-09-06 19:11:01 +00002672 OS << "\n#ifdef GET_REGISTER_MATCHER\n";
2673 OS << "#undef GET_REGISTER_MATCHER\n\n";
2674
Daniel Dunbareefe8612010-07-19 05:44:09 +00002675 // Emit the subtarget feature enumeration.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002676 emitSubtargetFeatureFlagEnumeration(Info, OS);
Daniel Dunbareefe8612010-07-19 05:44:09 +00002677
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00002678 // Emit the function to match a register name to number.
Akira Hatanaka7605630c2012-08-17 20:16:42 +00002679 // This should be omitted for Mips target
2680 if (AsmParser->getValueAsBit("ShouldEmitMatchRegisterName"))
2681 emitMatchRegisterName(Target, AsmParser, OS);
Chris Lattner3e4582a2010-09-06 19:11:01 +00002682
2683 OS << "#endif // GET_REGISTER_MATCHER\n\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002684
Craig Topper3ec7c2a2012-04-25 06:56:34 +00002685 OS << "\n#ifdef GET_SUBTARGET_FEATURE_NAME\n";
2686 OS << "#undef GET_SUBTARGET_FEATURE_NAME\n\n";
Daniel Dunbar3fb754a2009-08-11 23:23:44 +00002687
Jim Grosbach5117ef72012-04-24 22:40:08 +00002688 // Generate the helper function to get the names for subtarget features.
2689 emitGetSubtargetFeatureName(Info, OS);
2690
Craig Topper3ec7c2a2012-04-25 06:56:34 +00002691 OS << "#endif // GET_SUBTARGET_FEATURE_NAME\n\n";
2692
2693 OS << "\n#ifdef GET_MATCHER_IMPLEMENTATION\n";
2694 OS << "#undef GET_MATCHER_IMPLEMENTATION\n\n";
2695
Chris Lattner477fba4f2010-10-30 18:48:18 +00002696 // Generate the function that remaps for mnemonic aliases.
Chad Rosier9f7a2212013-04-18 22:35:36 +00002697 bool HasMnemonicAliases = emitMnemonicAliases(OS, Info, Target);
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002698
Chad Rosierf4e35dc2012-10-01 23:45:51 +00002699 // Generate the convertToMCInst function to convert operands into an MCInst.
2700 // Also, generate the convertToMapAndConstraints function for MS-style inline
2701 // assembly. The latter doesn't actually generate a MCInst.
2702 emitConvertFuncs(Target, ClassName, Info.Matchables, OS);
Daniel Dunbarb6d6aa22009-07-31 02:32:59 +00002703
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002704 // Emit the enumeration for classes which participate in matching.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002705 emitMatchClassEnumeration(Target, Info.Classes, OS);
Daniel Dunbarb6d6aa22009-07-31 02:32:59 +00002706
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002707 // Emit the routine to match token strings to their match class.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002708 emitMatchTokenString(Target, Info.Classes, OS);
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002709
Daniel Dunbar2587b612009-08-10 16:05:47 +00002710 // Emit the subclass predicate routine.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002711 emitIsSubclass(Target, Info.Classes, OS);
Daniel Dunbar2587b612009-08-10 16:05:47 +00002712
Jim Grosbach6e2e29b2011-02-10 00:08:28 +00002713 // Emit the routine to validate an operand against a match class.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002714 emitValidateOperandClass(Info, OS);
Jim Grosbach6e2e29b2011-02-10 00:08:28 +00002715
Daniel Dunbareefe8612010-07-19 05:44:09 +00002716 // Emit the available features compute function.
Jim Grosbach8c2beaa2012-04-19 17:52:32 +00002717 emitComputeAvailableFeatures(Info, OS);
Daniel Dunbareefe8612010-07-19 05:44:09 +00002718
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002719
Craig Toppere2cfeb32012-09-18 06:10:45 +00002720 StringToOffsetTable StringTable;
2721
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002722 size_t MaxNumOperands = 0;
Craig Toppere2cfeb32012-09-18 06:10:45 +00002723 unsigned MaxMnemonicIndex = 0;
Joey Gouly0e76fa72013-09-12 10:28:05 +00002724 bool HasDeprecation = false;
Craig Topperf34dad92014-11-28 03:53:02 +00002725 for (const auto &MI : Info.Matchables) {
David Blaikie6c13c362014-11-28 21:20:24 +00002726 MaxNumOperands = std::max(MaxNumOperands, MI.AsmOperands.size());
2727 HasDeprecation |= MI.HasDeprecation;
Craig Toppere2cfeb32012-09-18 06:10:45 +00002728
2729 // Store a pascal-style length byte in the mnemonic.
David Blaikie6c13c362014-11-28 21:20:24 +00002730 std::string LenMnemonic = char(MI.Mnemonic.size()) + MI.Mnemonic.str();
Craig Toppere2cfeb32012-09-18 06:10:45 +00002731 MaxMnemonicIndex = std::max(MaxMnemonicIndex,
2732 StringTable.GetOrAddStringOffset(LenMnemonic, false));
2733 }
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002734
Craig Topper7ecfa6d2012-09-18 07:02:21 +00002735 OS << "static const char *const MnemonicTable =\n";
2736 StringTable.EmitString(OS);
2737 OS << ";\n\n";
2738
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002739 // Emit the static match table; unused classes get initalized to 0 which is
2740 // guaranteed to be InvalidMatchClass.
2741 //
2742 // FIXME: We can reduce the size of this table very easily. First, we change
2743 // it so that store the kinds in separate bit-fields for each index, which
2744 // only needs to be the max width used for classes at that index (we also need
2745 // to reject based on this during classification). If we then make sure to
2746 // order the match kinds appropriately (putting mnemonics last), then we
2747 // should only end up using a few bits for each class, especially the ones
2748 // following the mnemonic.
Chris Lattner6b6f3dd2010-09-06 21:08:38 +00002749 OS << "namespace {\n";
2750 OS << " struct MatchEntry {\n";
Craig Toppere2cfeb32012-09-18 06:10:45 +00002751 OS << " " << getMinimalTypeForRange(MaxMnemonicIndex)
2752 << " Mnemonic;\n";
Benjamin Kramer5aeee5f2012-03-03 19:13:26 +00002753 OS << " uint16_t Opcode;\n";
David Blaikie6c13c362014-11-28 21:20:24 +00002754 OS << " " << getMinimalTypeForRange(std::distance(Info.Matchables.begin(),
2755 Info.Matchables.end()))
2756 << " ConvertFn;\n";
Daniel Sanders3ea92742014-05-21 10:11:24 +00002757 OS << " " << getMinimalRequiredFeaturesType(Info)
Benjamin Kramer77dfde02011-10-17 16:18:09 +00002758 << " RequiredFeatures;\n";
David Blaikied749e342014-11-28 20:35:57 +00002759 OS << " " << getMinimalTypeForRange(
2760 std::distance(Info.Classes.begin(), Info.Classes.end()))
2761 << " Classes[" << MaxNumOperands << "];\n";
Benjamin Kramer5aeee5f2012-03-03 19:13:26 +00002762 OS << " StringRef getMnemonic() const {\n";
2763 OS << " return StringRef(MnemonicTable + Mnemonic + 1,\n";
2764 OS << " MnemonicTable[Mnemonic]);\n";
2765 OS << " }\n";
Chris Lattner81301972010-09-06 21:22:45 +00002766 OS << " };\n\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002767
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00002768 OS << " // Predicate for searching for an opcode.\n";
Chris Lattner81301972010-09-06 21:22:45 +00002769 OS << " struct LessOpcode {\n";
2770 OS << " bool operator()(const MatchEntry &LHS, StringRef RHS) {\n";
Benjamin Kramer5aeee5f2012-03-03 19:13:26 +00002771 OS << " return LHS.getMnemonic() < RHS;\n";
Chris Lattner81301972010-09-06 21:22:45 +00002772 OS << " }\n";
2773 OS << " bool operator()(StringRef LHS, const MatchEntry &RHS) {\n";
Benjamin Kramer5aeee5f2012-03-03 19:13:26 +00002774 OS << " return LHS < RHS.getMnemonic();\n";
Chris Lattner81301972010-09-06 21:22:45 +00002775 OS << " }\n";
Chris Lattner62823362010-09-07 06:10:48 +00002776 OS << " bool operator()(const MatchEntry &LHS, const MatchEntry &RHS) {\n";
Benjamin Kramer5aeee5f2012-03-03 19:13:26 +00002777 OS << " return LHS.getMnemonic() < RHS.getMnemonic();\n";
Chris Lattner62823362010-09-07 06:10:48 +00002778 OS << " }\n";
Chris Lattner6b6f3dd2010-09-06 21:08:38 +00002779 OS << " };\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002780
Chris Lattner6b6f3dd2010-09-06 21:08:38 +00002781 OS << "} // end anonymous namespace.\n\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002782
Craig Topper690d8ea2013-07-24 07:33:14 +00002783 unsigned VariantCount = Target.getAsmParserVariantCount();
2784 for (unsigned VC = 0; VC != VariantCount; ++VC) {
2785 Record *AsmVariant = Target.getAsmParserVariant(VC);
Craig Topper690d8ea2013-07-24 07:33:14 +00002786 int AsmVariantNo = AsmVariant->getValueAsInt("Variant");
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002787
Craig Topper690d8ea2013-07-24 07:33:14 +00002788 OS << "static const MatchEntry MatchTable" << VC << "[] = {\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002789
Craig Topperf34dad92014-11-28 03:53:02 +00002790 for (const auto &MI : Info.Matchables) {
David Blaikie6c13c362014-11-28 21:20:24 +00002791 if (MI.AsmVariantID != AsmVariantNo)
Craig Topper690d8ea2013-07-24 07:33:14 +00002792 continue;
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002793
Craig Topper690d8ea2013-07-24 07:33:14 +00002794 // Store a pascal-style length byte in the mnemonic.
David Blaikie6c13c362014-11-28 21:20:24 +00002795 std::string LenMnemonic = char(MI.Mnemonic.size()) + MI.Mnemonic.str();
Craig Topper690d8ea2013-07-24 07:33:14 +00002796 OS << " { " << StringTable.GetOrAddStringOffset(LenMnemonic, false)
David Blaikie6c13c362014-11-28 21:20:24 +00002797 << " /* " << MI.Mnemonic << " */, " << Target.getName()
2798 << "::" << MI.getResultInst()->TheDef->getName() << ", "
2799 << MI.ConversionFnKind << ", ";
Craig Topper690d8ea2013-07-24 07:33:14 +00002800
2801 // Write the required features mask.
David Blaikie6c13c362014-11-28 21:20:24 +00002802 if (!MI.RequiredFeatures.empty()) {
2803 for (unsigned i = 0, e = MI.RequiredFeatures.size(); i != e; ++i) {
Craig Topper690d8ea2013-07-24 07:33:14 +00002804 if (i) OS << "|";
David Blaikie6c13c362014-11-28 21:20:24 +00002805 OS << MI.RequiredFeatures[i]->getEnumName();
Craig Topper690d8ea2013-07-24 07:33:14 +00002806 }
2807 } else
2808 OS << "0";
2809
2810 OS << ", { ";
David Blaikie6c13c362014-11-28 21:20:24 +00002811 for (unsigned i = 0, e = MI.AsmOperands.size(); i != e; ++i) {
2812 const MatchableInfo::AsmOperand &Op = MI.AsmOperands[i];
Craig Topper690d8ea2013-07-24 07:33:14 +00002813
2814 if (i) OS << ", ";
2815 OS << Op.Class->Name;
Daniel Dunbareefe8612010-07-19 05:44:09 +00002816 }
Craig Topper690d8ea2013-07-24 07:33:14 +00002817 OS << " }, },\n";
Craig Topper4de73732012-04-02 07:48:39 +00002818 }
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002819
Craig Topper690d8ea2013-07-24 07:33:14 +00002820 OS << "};\n\n";
2821 }
Daniel Dunbarb6d6aa22009-07-31 02:32:59 +00002822
Bob Wilson770681d72011-01-26 21:43:46 +00002823 // A method to determine if a mnemonic is in the list.
2824 OS << "bool " << Target.getName() << ClassName << "::\n"
Craig Topper690d8ea2013-07-24 07:33:14 +00002825 << "mnemonicIsValid(StringRef Mnemonic, unsigned VariantID) {\n";
2826 OS << " // Find the appropriate table for this asm variant.\n";
2827 OS << " const MatchEntry *Start, *End;\n";
2828 OS << " switch (VariantID) {\n";
2829 OS << " default: // unreachable\n";
2830 for (unsigned VC = 0; VC != VariantCount; ++VC) {
2831 Record *AsmVariant = Target.getAsmParserVariant(VC);
Craig Topper690d8ea2013-07-24 07:33:14 +00002832 int AsmVariantNo = AsmVariant->getValueAsInt("Variant");
Benjamin Kramer502b9e12014-04-12 16:15:53 +00002833 OS << " case " << AsmVariantNo << ": Start = std::begin(MatchTable" << VC
2834 << "); End = std::end(MatchTable" << VC << "); break;\n";
Craig Topper690d8ea2013-07-24 07:33:14 +00002835 }
2836 OS << " }\n";
Bob Wilson770681d72011-01-26 21:43:46 +00002837 OS << " // Search the table.\n";
2838 OS << " std::pair<const MatchEntry*, const MatchEntry*> MnemonicRange =\n";
Craig Topper690d8ea2013-07-24 07:33:14 +00002839 OS << " std::equal_range(Start, End, Mnemonic, LessOpcode());\n";
Bob Wilson770681d72011-01-26 21:43:46 +00002840 OS << " return MnemonicRange.first != MnemonicRange.second;\n";
2841 OS << "}\n\n";
2842
Chris Lattner6b6f3dd2010-09-06 21:08:38 +00002843 // Finally, build the match function.
David Blaikie960ea3f2014-06-08 16:18:35 +00002844 OS << "unsigned " << Target.getName() << ClassName << "::\n"
2845 << "MatchInstructionImpl(const OperandVector"
Chris Lattner6b6f3dd2010-09-06 21:08:38 +00002846 << " &Operands,\n";
Chad Rosier2f480a82012-10-12 22:53:36 +00002847 OS << " MCInst &Inst,\n"
Tim Northover26bb14e2014-08-18 11:49:42 +00002848 << "uint64_t &ErrorInfo, bool matchingInlineAsm, unsigned VariantID) {\n";
Daniel Dunbareefe8612010-07-19 05:44:09 +00002849
Chad Rosiereac13a32012-08-30 21:43:05 +00002850 OS << " // Eliminate obvious mismatches.\n";
2851 OS << " if (Operands.size() > " << (MaxNumOperands+1) << ") {\n";
2852 OS << " ErrorInfo = " << (MaxNumOperands+1) << ";\n";
2853 OS << " return Match_InvalidOperand;\n";
2854 OS << " }\n\n";
2855
Daniel Dunbareefe8612010-07-19 05:44:09 +00002856 // Emit code to get the available features.
2857 OS << " // Get the current feature set.\n";
Tim Northover26bb14e2014-08-18 11:49:42 +00002858 OS << " uint64_t AvailableFeatures = getAvailableFeatures();\n\n";
Daniel Dunbareefe8612010-07-19 05:44:09 +00002859
Chris Lattnerba7b4fe2010-10-30 17:36:36 +00002860 OS << " // Get the instruction mnemonic, which is the first token.\n";
2861 OS << " StringRef Mnemonic = ((" << Target.getName()
David Blaikie960ea3f2014-06-08 16:18:35 +00002862 << "Operand&)*Operands[0]).getToken();\n\n";
Chris Lattnerba7b4fe2010-10-30 17:36:36 +00002863
Chris Lattner477fba4f2010-10-30 18:48:18 +00002864 if (HasMnemonicAliases) {
2865 OS << " // Process all MnemonicAliases to remap the mnemonic.\n";
Chad Rosier9f7a2212013-04-18 22:35:36 +00002866 OS << " applyMnemonicAliases(Mnemonic, AvailableFeatures, VariantID);\n\n";
Chris Lattner477fba4f2010-10-30 18:48:18 +00002867 }
Bob Wilsonf4ee9e52011-01-26 21:26:19 +00002868
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002869 // Emit code to compute the class list for this operand vector.
Chris Lattnerabfe4222010-09-06 23:37:39 +00002870 OS << " // Some state to try to produce better error messages.\n";
Jim Grosbach120a96a2011-08-15 23:03:29 +00002871 OS << " bool HadMatchOtherThanFeatures = false;\n";
Jim Grosbachd152e2c2011-08-16 20:12:35 +00002872 OS << " bool HadMatchOtherThanPredicate = false;\n";
Jim Grosbach120a96a2011-08-15 23:03:29 +00002873 OS << " unsigned RetCode = Match_InvalidOperand;\n";
Tim Northover26bb14e2014-08-18 11:49:42 +00002874 OS << " uint64_t MissingFeatures = ~0ULL;\n";
Jim Grosbach860a84d2011-02-11 21:31:55 +00002875 OS << " // Set ErrorInfo to the operand that mismatches if it is\n";
Chris Lattnerabfe4222010-09-06 23:37:39 +00002876 OS << " // wrong for all instances of the instruction.\n";
2877 OS << " ErrorInfo = ~0U;\n";
Chris Lattner81301972010-09-06 21:22:45 +00002878
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002879 // Emit code to search the table.
Craig Topper690d8ea2013-07-24 07:33:14 +00002880 OS << " // Find the appropriate table for this asm variant.\n";
2881 OS << " const MatchEntry *Start, *End;\n";
2882 OS << " switch (VariantID) {\n";
2883 OS << " default: // unreachable\n";
2884 for (unsigned VC = 0; VC != VariantCount; ++VC) {
2885 Record *AsmVariant = Target.getAsmParserVariant(VC);
Craig Topper690d8ea2013-07-24 07:33:14 +00002886 int AsmVariantNo = AsmVariant->getValueAsInt("Variant");
Benjamin Kramer502b9e12014-04-12 16:15:53 +00002887 OS << " case " << AsmVariantNo << ": Start = std::begin(MatchTable" << VC
2888 << "); End = std::end(MatchTable" << VC << "); break;\n";
Craig Topper690d8ea2013-07-24 07:33:14 +00002889 }
2890 OS << " }\n";
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002891 OS << " // Search the table.\n";
Chris Lattner81301972010-09-06 21:22:45 +00002892 OS << " std::pair<const MatchEntry*, const MatchEntry*> MnemonicRange =\n";
Craig Topper690d8ea2013-07-24 07:33:14 +00002893 OS << " std::equal_range(Start, End, Mnemonic, LessOpcode());\n\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002894
Chris Lattner628fbec2010-09-06 21:54:15 +00002895 OS << " // Return a more specific error code if no mnemonics match.\n";
2896 OS << " if (MnemonicRange.first == MnemonicRange.second)\n";
2897 OS << " return Match_MnemonicFail;\n\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002898
Chris Lattner81301972010-09-06 21:22:45 +00002899 OS << " for (const MatchEntry *it = MnemonicRange.first, "
Chris Lattner9026ac02010-09-06 21:23:43 +00002900 << "*ie = MnemonicRange.second;\n";
Chris Lattner81301972010-09-06 21:22:45 +00002901 OS << " it != ie; ++it) {\n";
Daniel Dunbareefe8612010-07-19 05:44:09 +00002902
Gabor Greif7f3ce252010-09-07 06:06:06 +00002903 OS << " // equal_range guarantees that instruction mnemonic matches.\n";
Benjamin Kramer5aeee5f2012-03-03 19:13:26 +00002904 OS << " assert(Mnemonic == it->getMnemonic());\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002905
Daniel Dunbareefe8612010-07-19 05:44:09 +00002906 // Emit check that the subclasses match.
Chris Lattner339cc7b2010-09-06 22:11:18 +00002907 OS << " bool OperandsValid = true;\n";
2908 OS << " for (unsigned i = 0; i != " << MaxNumOperands << "; ++i) {\n";
Jim Grosbach6e2e29b2011-02-10 00:08:28 +00002909 OS << " if (i + 1 >= Operands.size()) {\n";
2910 OS << " OperandsValid = (it->Classes[i] == " <<"InvalidMatchClass);\n";
Bill Wendling98f0b772012-08-04 10:31:40 +00002911 OS << " if (!OperandsValid) ErrorInfo = i + 1;\n";
Jim Grosbache6ce2052011-05-03 19:09:56 +00002912 OS << " break;\n";
Jim Grosbach6e2e29b2011-02-10 00:08:28 +00002913 OS << " }\n";
David Blaikie960ea3f2014-06-08 16:18:35 +00002914 OS << " unsigned Diag = validateOperandClass(*Operands[i+1],\n";
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002915 OS.indent(43);
2916 OS << "(MatchClassKind)it->Classes[i]);\n";
2917 OS << " if (Diag == Match_Success)\n";
Chris Lattner339cc7b2010-09-06 22:11:18 +00002918 OS << " continue;\n";
Jim Grosbach86c652a2013-02-06 06:00:06 +00002919 OS << " // If the generic handler indicates an invalid operand\n";
2920 OS << " // failure, check for a special case.\n";
2921 OS << " if (Diag == Match_InvalidOperand) {\n";
David Blaikie960ea3f2014-06-08 16:18:35 +00002922 OS << " Diag = validateTargetOperandClass(*Operands[i+1],\n";
Jim Grosbach86c652a2013-02-06 06:00:06 +00002923 OS.indent(43);
2924 OS << "(MatchClassKind)it->Classes[i]);\n";
2925 OS << " if (Diag == Match_Success)\n";
2926 OS << " continue;\n";
2927 OS << " }\n";
Chris Lattnerabfe4222010-09-06 23:37:39 +00002928 OS << " // If this operand is broken for all of the instances of this\n";
2929 OS << " // mnemonic, keep track of it so we can report loc info.\n";
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002930 OS << " // If we already had a match that only failed due to a\n";
2931 OS << " // target predicate, that diagnostic is preferred.\n";
2932 OS << " if (!HadMatchOtherThanPredicate &&\n";
2933 OS << " (it == MnemonicRange.first || ErrorInfo <= i+1)) {\n";
Chris Lattner339cc7b2010-09-06 22:11:18 +00002934 OS << " ErrorInfo = i+1;\n";
Jim Grosbach8ccdbd12012-06-26 22:58:01 +00002935 OS << " // InvalidOperand is the default. Prefer specificity.\n";
2936 OS << " if (Diag != Match_InvalidOperand)\n";
2937 OS << " RetCode = Diag;\n";
Jim Grosbach3a8a0fa2012-06-22 23:56:44 +00002938 OS << " }\n";
Chris Lattner339cc7b2010-09-06 22:11:18 +00002939 OS << " // Otherwise, just reject this instance of the mnemonic.\n";
2940 OS << " OperandsValid = false;\n";
2941 OS << " break;\n";
2942 OS << " }\n\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00002943
Chris Lattner339cc7b2010-09-06 22:11:18 +00002944 OS << " if (!OperandsValid) continue;\n";
Chris Lattnerb4be28f2010-09-06 20:08:02 +00002945
2946 // Emit check that the required features are available.
2947 OS << " if ((AvailableFeatures & it->RequiredFeatures) "
2948 << "!= it->RequiredFeatures) {\n";
2949 OS << " HadMatchOtherThanFeatures = true;\n";
Tim Northover26bb14e2014-08-18 11:49:42 +00002950 OS << " uint64_t NewMissingFeatures = it->RequiredFeatures & "
Jim Grosbach9ec06a152012-06-18 19:45:46 +00002951 "~AvailableFeatures;\n";
Tim Northover26bb14e2014-08-18 11:49:42 +00002952 OS << " if (CountPopulation_64(NewMissingFeatures) <=\n"
2953 " CountPopulation_64(MissingFeatures))\n";
Jim Grosbach9ec06a152012-06-18 19:45:46 +00002954 OS << " MissingFeatures = NewMissingFeatures;\n";
Chris Lattnerb4be28f2010-09-06 20:08:02 +00002955 OS << " continue;\n";
2956 OS << " }\n";
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002957 OS << "\n";
Chad Rosierf4e35dc2012-10-01 23:45:51 +00002958 OS << " if (matchingInlineAsm) {\n";
Chad Rosierf4e35dc2012-10-01 23:45:51 +00002959 OS << " Inst.setOpcode(it->Opcode);\n";
Chad Rosier2f480a82012-10-12 22:53:36 +00002960 OS << " convertToMapAndConstraints(it->ConvertFn, Operands);\n";
Chad Rosierf4e35dc2012-10-01 23:45:51 +00002961 OS << " return Match_Success;\n";
2962 OS << " }\n\n";
Daniel Dunbar66193402011-02-04 17:12:23 +00002963 OS << " // We have selected a definite instruction, convert the parsed\n"
2964 << " // operands into the appropriate MCInst.\n";
Chad Rosierba284b92012-09-05 01:02:38 +00002965 OS << " convertToMCInst(it->ConvertFn, Inst, it->Opcode, Operands);\n";
Daniel Dunbar66193402011-02-04 17:12:23 +00002966 OS << "\n";
Daniel Dunbar451a4352010-03-18 20:05:56 +00002967
Jim Grosbach120a96a2011-08-15 23:03:29 +00002968 // Verify the instruction with the target-specific match predicate function.
2969 OS << " // We have a potential match. Check the target predicate to\n"
2970 << " // handle any context sensitive constraints.\n"
2971 << " unsigned MatchResult;\n"
2972 << " if ((MatchResult = checkTargetMatchPredicate(Inst)) !="
2973 << " Match_Success) {\n"
2974 << " Inst.clear();\n"
2975 << " RetCode = MatchResult;\n"
Jim Grosbachd152e2c2011-08-16 20:12:35 +00002976 << " HadMatchOtherThanPredicate = true;\n"
Jim Grosbach120a96a2011-08-15 23:03:29 +00002977 << " continue;\n"
2978 << " }\n\n";
2979
Daniel Dunbar451a4352010-03-18 20:05:56 +00002980 // Call the post-processing function, if used.
2981 std::string InsnCleanupFn =
2982 AsmParser->getValueAsString("AsmParserInstCleanup");
2983 if (!InsnCleanupFn.empty())
2984 OS << " " << InsnCleanupFn << "(Inst);\n";
2985
Joey Gouly0e76fa72013-09-12 10:28:05 +00002986 if (HasDeprecation) {
2987 OS << " std::string Info;\n";
2988 OS << " if (MII.get(Inst.getOpcode()).getDeprecatedInfo(Inst, STI, Info)) {\n";
David Blaikie960ea3f2014-06-08 16:18:35 +00002989 OS << " SMLoc Loc = ((" << Target.getName()
2990 << "Operand&)*Operands[0]).getStartLoc();\n";
Rafael Espindola961d4692014-11-11 05:18:41 +00002991 OS << " getParser().Warning(Loc, Info, None);\n";
Joey Gouly0e76fa72013-09-12 10:28:05 +00002992 OS << " }\n";
2993 }
2994
Chris Lattnera22a3682010-09-06 19:22:17 +00002995 OS << " return Match_Success;\n";
Daniel Dunbar541efcc2009-08-08 07:50:56 +00002996 OS << " }\n\n";
2997
Chris Lattnerb4be28f2010-09-06 20:08:02 +00002998 OS << " // Okay, we had no match. Try to return a useful error code.\n";
Chad Rosier4ee03842012-08-21 17:22:47 +00002999 OS << " if (HadMatchOtherThanPredicate || !HadMatchOtherThanFeatures)\n";
3000 OS << " return RetCode;\n\n";
Jim Grosbach9ec06a152012-06-18 19:45:46 +00003001 OS << " // Missing feature matches return which features were missing\n";
3002 OS << " ErrorInfo = MissingFeatures;\n";
Jim Grosbachd152e2c2011-08-16 20:12:35 +00003003 OS << " return Match_MissingFeature;\n";
Daniel Dunbarb6d6aa22009-07-31 02:32:59 +00003004 OS << "}\n\n";
Jim Grosbach0eccfc22010-10-29 22:13:48 +00003005
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00003006 if (Info.OperandMatchInfo.size())
Craig Topper7ecfa6d2012-09-18 07:02:21 +00003007 emitCustomOperandParsing(OS, Target, Info, ClassName, StringTable,
3008 MaxMnemonicIndex);
Bruno Cardoso Lopes2315beb2011-02-07 19:38:32 +00003009
Chris Lattner3e4582a2010-09-06 19:11:01 +00003010 OS << "#endif // GET_MATCHER_IMPLEMENTATION\n\n";
Daniel Dunbar3085b572009-07-11 19:39:44 +00003011}
Jakob Stoklund Olesene6aed132012-06-11 15:37:55 +00003012
3013namespace llvm {
3014
3015void EmitAsmMatcher(RecordKeeper &RK, raw_ostream &OS) {
3016 emitSourceFileHeader("Assembly Matcher Source Fragment", OS);
3017 AsmMatcherEmitter(RK).run(OS);
3018}
3019
3020} // End llvm namespace