Line data Source code
1 : //===- MIParser.cpp - Machine instructions parser implementation ----------===//
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 file implements the parsing of machine instructions.
11 : //
12 : //===----------------------------------------------------------------------===//
13 :
14 : #include "MIParser.h"
15 : #include "MILexer.h"
16 : #include "llvm/ADT/APInt.h"
17 : #include "llvm/ADT/APSInt.h"
18 : #include "llvm/ADT/ArrayRef.h"
19 : #include "llvm/ADT/DenseMap.h"
20 : #include "llvm/ADT/None.h"
21 : #include "llvm/ADT/Optional.h"
22 : #include "llvm/ADT/SmallVector.h"
23 : #include "llvm/ADT/StringMap.h"
24 : #include "llvm/ADT/StringRef.h"
25 : #include "llvm/ADT/StringSwitch.h"
26 : #include "llvm/ADT/Twine.h"
27 : #include "llvm/Analysis/MemoryLocation.h"
28 : #include "llvm/AsmParser/Parser.h"
29 : #include "llvm/AsmParser/SlotMapping.h"
30 : #include "llvm/CodeGen/MIRPrinter.h"
31 : #include "llvm/CodeGen/MachineBasicBlock.h"
32 : #include "llvm/CodeGen/MachineFrameInfo.h"
33 : #include "llvm/CodeGen/MachineFunction.h"
34 : #include "llvm/CodeGen/MachineInstr.h"
35 : #include "llvm/CodeGen/MachineInstrBuilder.h"
36 : #include "llvm/CodeGen/MachineMemOperand.h"
37 : #include "llvm/CodeGen/MachineOperand.h"
38 : #include "llvm/CodeGen/MachineRegisterInfo.h"
39 : #include "llvm/CodeGen/TargetInstrInfo.h"
40 : #include "llvm/CodeGen/TargetRegisterInfo.h"
41 : #include "llvm/CodeGen/TargetSubtargetInfo.h"
42 : #include "llvm/IR/BasicBlock.h"
43 : #include "llvm/IR/Constants.h"
44 : #include "llvm/IR/DataLayout.h"
45 : #include "llvm/IR/DebugInfoMetadata.h"
46 : #include "llvm/IR/DebugLoc.h"
47 : #include "llvm/IR/Function.h"
48 : #include "llvm/IR/InstrTypes.h"
49 : #include "llvm/IR/Instructions.h"
50 : #include "llvm/IR/Intrinsics.h"
51 : #include "llvm/IR/Metadata.h"
52 : #include "llvm/IR/Module.h"
53 : #include "llvm/IR/ModuleSlotTracker.h"
54 : #include "llvm/IR/Type.h"
55 : #include "llvm/IR/Value.h"
56 : #include "llvm/IR/ValueSymbolTable.h"
57 : #include "llvm/MC/LaneBitmask.h"
58 : #include "llvm/MC/MCContext.h"
59 : #include "llvm/MC/MCDwarf.h"
60 : #include "llvm/MC/MCInstrDesc.h"
61 : #include "llvm/MC/MCRegisterInfo.h"
62 : #include "llvm/Support/AtomicOrdering.h"
63 : #include "llvm/Support/BranchProbability.h"
64 : #include "llvm/Support/Casting.h"
65 : #include "llvm/Support/ErrorHandling.h"
66 : #include "llvm/Support/LowLevelTypeImpl.h"
67 : #include "llvm/Support/MemoryBuffer.h"
68 : #include "llvm/Support/SMLoc.h"
69 : #include "llvm/Support/SourceMgr.h"
70 : #include "llvm/Support/raw_ostream.h"
71 : #include "llvm/Target/TargetIntrinsicInfo.h"
72 : #include "llvm/Target/TargetMachine.h"
73 : #include <algorithm>
74 : #include <cassert>
75 : #include <cctype>
76 : #include <cstddef>
77 : #include <cstdint>
78 : #include <limits>
79 : #include <string>
80 : #include <utility>
81 :
82 : using namespace llvm;
83 :
84 4578 : PerFunctionMIParsingState::PerFunctionMIParsingState(MachineFunction &MF,
85 : SourceMgr &SM, const SlotMapping &IRSlots,
86 : const Name2RegClassMap &Names2RegClasses,
87 4578 : const Name2RegBankMap &Names2RegBanks)
88 : : MF(MF), SM(&SM), IRSlots(IRSlots), Names2RegClasses(Names2RegClasses),
89 4578 : Names2RegBanks(Names2RegBanks) {
90 4578 : }
91 :
92 48300 : VRegInfo &PerFunctionMIParsingState::getVRegInfo(unsigned Num) {
93 48300 : auto I = VRegInfos.insert(std::make_pair(Num, nullptr));
94 48300 : if (I.second) {
95 17241 : MachineRegisterInfo &MRI = MF.getRegInfo();
96 17241 : VRegInfo *Info = new (Allocator) VRegInfo;
97 17241 : Info->VReg = MRI.createIncompleteVirtualRegister();
98 17241 : I.first->second = Info;
99 : }
100 48300 : return *I.first->second;
101 : }
102 :
103 44 : VRegInfo &PerFunctionMIParsingState::getVRegInfoNamed(StringRef RegName) {
104 : assert(RegName != "" && "Expected named reg.");
105 :
106 88 : auto I = VRegInfosNamed.insert(std::make_pair(RegName.str(), nullptr));
107 44 : if (I.second) {
108 24 : VRegInfo *Info = new (Allocator) VRegInfo;
109 24 : Info->VReg = MF.getRegInfo().createIncompleteVirtualRegister(RegName);
110 24 : I.first->second = Info;
111 : }
112 44 : return *I.first->second;
113 : }
114 :
115 : namespace {
116 :
117 : /// A wrapper struct around the 'MachineOperand' struct that includes a source
118 : /// range and other attributes.
119 104993 : struct ParsedMachineOperand {
120 : MachineOperand Operand;
121 : StringRef::iterator Begin;
122 : StringRef::iterator End;
123 : Optional<unsigned> TiedDefIdx;
124 :
125 : ParsedMachineOperand(const MachineOperand &Operand, StringRef::iterator Begin,
126 : StringRef::iterator End, Optional<unsigned> &TiedDefIdx)
127 100977 : : Operand(Operand), Begin(Begin), End(End), TiedDefIdx(TiedDefIdx) {
128 : if (TiedDefIdx)
129 : assert(Operand.isReg() && Operand.isUse() &&
130 : "Only used register operands can be tied");
131 : }
132 : };
133 :
134 : class MIParser {
135 : MachineFunction &MF;
136 : SMDiagnostic &Error;
137 : StringRef Source, CurrentSource;
138 : MIToken Token;
139 : PerFunctionMIParsingState &PFS;
140 : /// Maps from instruction names to op codes.
141 : StringMap<unsigned> Names2InstrOpCodes;
142 : /// Maps from register names to registers.
143 : StringMap<unsigned> Names2Regs;
144 : /// Maps from register mask names to register masks.
145 : StringMap<const uint32_t *> Names2RegMasks;
146 : /// Maps from subregister names to subregister indices.
147 : StringMap<unsigned> Names2SubRegIndices;
148 : /// Maps from slot numbers to function's unnamed basic blocks.
149 : DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
150 : /// Maps from slot numbers to function's unnamed values.
151 : DenseMap<unsigned, const Value *> Slots2Values;
152 : /// Maps from target index names to target indices.
153 : StringMap<int> Names2TargetIndices;
154 : /// Maps from direct target flag names to the direct target flag values.
155 : StringMap<unsigned> Names2DirectTargetFlags;
156 : /// Maps from direct target flag names to the bitmask target flag values.
157 : StringMap<unsigned> Names2BitmaskTargetFlags;
158 : /// Maps from MMO target flag names to MMO target flag values.
159 : StringMap<MachineMemOperand::Flags> Names2MMOTargetFlags;
160 :
161 : public:
162 : MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
163 : StringRef Source);
164 :
165 : /// \p SkipChar gives the number of characters to skip before looking
166 : /// for the next token.
167 : void lex(unsigned SkipChar = 0);
168 :
169 : /// Report an error at the current location with the given message.
170 : ///
171 : /// This function always return true.
172 : bool error(const Twine &Msg);
173 :
174 : /// Report an error at the given location with the given message.
175 : ///
176 : /// This function always return true.
177 : bool error(StringRef::iterator Loc, const Twine &Msg);
178 :
179 : bool
180 : parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
181 : bool parseBasicBlocks();
182 : bool parse(MachineInstr *&MI);
183 : bool parseStandaloneMBB(MachineBasicBlock *&MBB);
184 : bool parseStandaloneNamedRegister(unsigned &Reg);
185 : bool parseStandaloneVirtualRegister(VRegInfo *&Info);
186 : bool parseStandaloneRegister(unsigned &Reg);
187 : bool parseStandaloneStackObject(int &FI);
188 : bool parseStandaloneMDNode(MDNode *&Node);
189 :
190 : bool
191 : parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
192 : bool parseBasicBlock(MachineBasicBlock &MBB,
193 : MachineBasicBlock *&AddFalthroughFrom);
194 : bool parseBasicBlockLiveins(MachineBasicBlock &MBB);
195 : bool parseBasicBlockSuccessors(MachineBasicBlock &MBB);
196 :
197 : bool parseNamedRegister(unsigned &Reg);
198 : bool parseVirtualRegister(VRegInfo *&Info);
199 : bool parseNamedVirtualRegister(VRegInfo *&Info);
200 : bool parseRegister(unsigned &Reg, VRegInfo *&VRegInfo);
201 : bool parseRegisterFlag(unsigned &Flags);
202 : bool parseRegisterClassOrBank(VRegInfo &RegInfo);
203 : bool parseSubRegisterIndex(unsigned &SubReg);
204 : bool parseRegisterTiedDefIndex(unsigned &TiedDefIdx);
205 : bool parseRegisterOperand(MachineOperand &Dest,
206 : Optional<unsigned> &TiedDefIdx, bool IsDef = false);
207 : bool parseImmediateOperand(MachineOperand &Dest);
208 : bool parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
209 : const Constant *&C);
210 : bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
211 : bool parseLowLevelType(StringRef::iterator Loc, LLT &Ty);
212 : bool parseTypedImmediateOperand(MachineOperand &Dest);
213 : bool parseFPImmediateOperand(MachineOperand &Dest);
214 : bool parseMBBReference(MachineBasicBlock *&MBB);
215 : bool parseMBBOperand(MachineOperand &Dest);
216 : bool parseStackFrameIndex(int &FI);
217 : bool parseStackObjectOperand(MachineOperand &Dest);
218 : bool parseFixedStackFrameIndex(int &FI);
219 : bool parseFixedStackObjectOperand(MachineOperand &Dest);
220 : bool parseGlobalValue(GlobalValue *&GV);
221 : bool parseGlobalAddressOperand(MachineOperand &Dest);
222 : bool parseConstantPoolIndexOperand(MachineOperand &Dest);
223 : bool parseSubRegisterIndexOperand(MachineOperand &Dest);
224 : bool parseJumpTableIndexOperand(MachineOperand &Dest);
225 : bool parseExternalSymbolOperand(MachineOperand &Dest);
226 : bool parseMCSymbolOperand(MachineOperand &Dest);
227 : bool parseMDNode(MDNode *&Node);
228 : bool parseDIExpression(MDNode *&Expr);
229 : bool parseMetadataOperand(MachineOperand &Dest);
230 : bool parseCFIOffset(int &Offset);
231 : bool parseCFIRegister(unsigned &Reg);
232 : bool parseCFIEscapeValues(std::string& Values);
233 : bool parseCFIOperand(MachineOperand &Dest);
234 : bool parseIRBlock(BasicBlock *&BB, const Function &F);
235 : bool parseBlockAddressOperand(MachineOperand &Dest);
236 : bool parseIntrinsicOperand(MachineOperand &Dest);
237 : bool parsePredicateOperand(MachineOperand &Dest);
238 : bool parseTargetIndexOperand(MachineOperand &Dest);
239 : bool parseCustomRegisterMaskOperand(MachineOperand &Dest);
240 : bool parseLiveoutRegisterMaskOperand(MachineOperand &Dest);
241 : bool parseMachineOperand(MachineOperand &Dest,
242 : Optional<unsigned> &TiedDefIdx);
243 : bool parseMachineOperandAndTargetFlags(MachineOperand &Dest,
244 : Optional<unsigned> &TiedDefIdx);
245 : bool parseOffset(int64_t &Offset);
246 : bool parseAlignment(unsigned &Alignment);
247 : bool parseAddrspace(unsigned &Addrspace);
248 : bool parseOperandsOffset(MachineOperand &Op);
249 : bool parseIRValue(const Value *&V);
250 : bool parseMemoryOperandFlag(MachineMemOperand::Flags &Flags);
251 : bool parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV);
252 : bool parseMachinePointerInfo(MachinePointerInfo &Dest);
253 : bool parseOptionalScope(LLVMContext &Context, SyncScope::ID &SSID);
254 : bool parseOptionalAtomicOrdering(AtomicOrdering &Order);
255 : bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
256 : bool parsePreOrPostInstrSymbol(MCSymbol *&Symbol);
257 :
258 : private:
259 : /// Convert the integer literal in the current token into an unsigned integer.
260 : ///
261 : /// Return true if an error occurred.
262 : bool getUnsigned(unsigned &Result);
263 :
264 : /// Convert the integer literal in the current token into an uint64.
265 : ///
266 : /// Return true if an error occurred.
267 : bool getUint64(uint64_t &Result);
268 :
269 : /// Convert the hexadecimal literal in the current token into an unsigned
270 : /// APInt with a minimum bitwidth required to represent the value.
271 : ///
272 : /// Return true if the literal does not represent an integer value.
273 : bool getHexUint(APInt &Result);
274 :
275 : /// If the current token is of the given kind, consume it and return false.
276 : /// Otherwise report an error and return true.
277 : bool expectAndConsume(MIToken::TokenKind TokenKind);
278 :
279 : /// If the current token is of the given kind, consume it and return true.
280 : /// Otherwise return false.
281 : bool consumeIfPresent(MIToken::TokenKind TokenKind);
282 :
283 : void initNames2InstrOpCodes();
284 :
285 : /// Try to convert an instruction name to an opcode. Return true if the
286 : /// instruction name is invalid.
287 : bool parseInstrName(StringRef InstrName, unsigned &OpCode);
288 :
289 : bool parseInstruction(unsigned &OpCode, unsigned &Flags);
290 :
291 : bool assignRegisterTies(MachineInstr &MI,
292 : ArrayRef<ParsedMachineOperand> Operands);
293 :
294 : bool verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
295 : const MCInstrDesc &MCID);
296 :
297 : void initNames2Regs();
298 :
299 : /// Try to convert a register name to a register number. Return true if the
300 : /// register name is invalid.
301 : bool getRegisterByName(StringRef RegName, unsigned &Reg);
302 :
303 : void initNames2RegMasks();
304 :
305 : /// Check if the given identifier is a name of a register mask.
306 : ///
307 : /// Return null if the identifier isn't a register mask.
308 : const uint32_t *getRegMask(StringRef Identifier);
309 :
310 : void initNames2SubRegIndices();
311 :
312 : /// Check if the given identifier is a name of a subregister index.
313 : ///
314 : /// Return 0 if the name isn't a subregister index class.
315 : unsigned getSubRegIndex(StringRef Name);
316 :
317 : const BasicBlock *getIRBlock(unsigned Slot);
318 : const BasicBlock *getIRBlock(unsigned Slot, const Function &F);
319 :
320 : const Value *getIRValue(unsigned Slot);
321 :
322 : void initNames2TargetIndices();
323 :
324 : /// Try to convert a name of target index to the corresponding target index.
325 : ///
326 : /// Return true if the name isn't a name of a target index.
327 : bool getTargetIndex(StringRef Name, int &Index);
328 :
329 : void initNames2DirectTargetFlags();
330 :
331 : /// Try to convert a name of a direct target flag to the corresponding
332 : /// target flag.
333 : ///
334 : /// Return true if the name isn't a name of a direct flag.
335 : bool getDirectTargetFlag(StringRef Name, unsigned &Flag);
336 :
337 : void initNames2BitmaskTargetFlags();
338 :
339 : /// Try to convert a name of a bitmask target flag to the corresponding
340 : /// target flag.
341 : ///
342 : /// Return true if the name isn't a name of a bitmask target flag.
343 : bool getBitmaskTargetFlag(StringRef Name, unsigned &Flag);
344 :
345 : void initNames2MMOTargetFlags();
346 :
347 : /// Try to convert a name of a MachineMemOperand target flag to the
348 : /// corresponding target flag.
349 : ///
350 : /// Return true if the name isn't a name of a target MMO flag.
351 : bool getMMOTargetFlag(StringRef Name, MachineMemOperand::Flags &Flag);
352 :
353 : /// Get or create an MCSymbol for a given name.
354 : MCSymbol *getOrCreateMCSymbol(StringRef Name);
355 :
356 : /// parseStringConstant
357 : /// ::= StringConstant
358 : bool parseStringConstant(std::string &Result);
359 : };
360 :
361 : } // end anonymous namespace
362 :
363 12978 : MIParser::MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
364 12978 : StringRef Source)
365 38934 : : MF(PFS.MF), Error(Error), Source(Source), CurrentSource(Source), PFS(PFS)
366 12978 : {}
367 :
368 922786 : void MIParser::lex(unsigned SkipChar) {
369 : CurrentSource = lexMIToken(
370 922786 : CurrentSource.data() + SkipChar, Token,
371 2768362 : [this](StringRef::iterator Loc, const Twine &Msg) { error(Loc, Msg); });
372 922786 : }
373 :
374 84 : bool MIParser::error(const Twine &Msg) { return error(Token.location(), Msg); }
375 :
376 104 : bool MIParser::error(StringRef::iterator Loc, const Twine &Msg) {
377 104 : const SourceMgr &SM = *PFS.SM;
378 : assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()));
379 : const MemoryBuffer &Buffer = *SM.getMemoryBuffer(SM.getMainFileID());
380 104 : if (Loc >= Buffer.getBufferStart() && Loc <= Buffer.getBufferEnd()) {
381 : // Create an ordinary diagnostic when the source manager's buffer is the
382 : // source string.
383 98 : Error = SM.GetMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
384 98 : return true;
385 : }
386 : // Create a diagnostic for a YAML string literal.
387 6 : Error = SMDiagnostic(SM, SMLoc(), Buffer.getBufferIdentifier(), 1,
388 6 : Loc - Source.data(), SourceMgr::DK_Error, Msg.str(),
389 6 : Source, None, None);
390 6 : return true;
391 : }
392 :
393 : static const char *toString(MIToken::TokenKind TokenKind) {
394 2 : switch (TokenKind) {
395 : case MIToken::comma:
396 : return "','";
397 0 : case MIToken::equal:
398 : return "'='";
399 1 : case MIToken::colon:
400 : return "':'";
401 0 : case MIToken::lparen:
402 : return "'('";
403 0 : case MIToken::rparen:
404 : return "')'";
405 0 : default:
406 : return "<unknown token>";
407 : }
408 : }
409 :
410 61566 : bool MIParser::expectAndConsume(MIToken::TokenKind TokenKind) {
411 61566 : if (Token.isNot(TokenKind))
412 2 : return error(Twine("expected ") + toString(TokenKind));
413 61564 : lex();
414 61564 : return false;
415 : }
416 :
417 : bool MIParser::consumeIfPresent(MIToken::TokenKind TokenKind) {
418 619607 : if (Token.isNot(TokenKind))
419 : return false;
420 151209 : lex();
421 : return true;
422 : }
423 :
424 6450 : bool MIParser::parseBasicBlockDefinition(
425 : DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
426 : assert(Token.is(MIToken::MachineBasicBlockLabel));
427 6450 : unsigned ID = 0;
428 6450 : if (getUnsigned(ID))
429 : return true;
430 : auto Loc = Token.location();
431 6450 : auto Name = Token.stringValue();
432 6450 : lex();
433 : bool HasAddressTaken = false;
434 : bool IsLandingPad = false;
435 6450 : unsigned Alignment = 0;
436 6450 : BasicBlock *BB = nullptr;
437 : if (consumeIfPresent(MIToken::lparen)) {
438 : do {
439 : // TODO: Report an error when multiple same attributes are specified.
440 1149 : switch (Token.kind()) {
441 20 : case MIToken::kw_address_taken:
442 : HasAddressTaken = true;
443 20 : lex();
444 20 : break;
445 18 : case MIToken::kw_landing_pad:
446 : IsLandingPad = true;
447 18 : lex();
448 18 : break;
449 5 : case MIToken::kw_align:
450 5 : if (parseAlignment(Alignment))
451 : return true;
452 : break;
453 1100 : case MIToken::IRBlock:
454 : // TODO: Report an error when both name and ir block are specified.
455 1100 : if (parseIRBlock(BB, MF.getFunction()))
456 : return true;
457 1099 : lex();
458 1099 : break;
459 : default:
460 : break;
461 : }
462 : } while (consumeIfPresent(MIToken::comma));
463 1146 : if (expectAndConsume(MIToken::rparen))
464 : return true;
465 : }
466 6449 : if (expectAndConsume(MIToken::colon))
467 : return true;
468 :
469 6448 : if (!Name.empty()) {
470 2117 : BB = dyn_cast_or_null<BasicBlock>(
471 2117 : MF.getFunction().getValueSymbolTable()->lookup(Name));
472 2117 : if (!BB)
473 1 : return error(Loc, Twine("basic block '") + Name +
474 2 : "' is not defined in the function '" +
475 2 : MF.getName() + "'");
476 : }
477 6447 : auto *MBB = MF.CreateMachineBasicBlock(BB);
478 6447 : MF.insert(MF.end(), MBB);
479 6447 : bool WasInserted = MBBSlots.insert(std::make_pair(ID, MBB)).second;
480 6447 : if (!WasInserted)
481 1 : return error(Loc, Twine("redefinition of machine basic block with id #") +
482 2 : Twine(ID));
483 6446 : if (Alignment)
484 : MBB->setAlignment(Alignment);
485 6446 : if (HasAddressTaken)
486 : MBB->setHasAddressTaken();
487 : MBB->setIsEHPad(IsLandingPad);
488 6446 : return false;
489 : }
490 :
491 4570 : bool MIParser::parseBasicBlockDefinitions(
492 : DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
493 4570 : lex();
494 : // Skip until the first machine basic block.
495 12419 : while (Token.is(MIToken::Newline))
496 7849 : lex();
497 4570 : if (Token.isErrorOrEOF())
498 13 : return Token.isError();
499 4557 : if (Token.isNot(MIToken::MachineBasicBlockLabel))
500 1 : return error("expected a basic block definition before instructions");
501 : unsigned BraceDepth = 0;
502 : do {
503 6450 : if (parseBasicBlockDefinition(MBBSlots))
504 : return true;
505 : bool IsAfterNewline = false;
506 : // Skip until the next machine basic block.
507 : while (true) {
508 436820 : if ((Token.is(MIToken::MachineBasicBlockLabel) && IsAfterNewline) ||
509 : Token.isErrorOrEOF())
510 : break;
511 430376 : else if (Token.is(MIToken::MachineBasicBlockLabel))
512 1 : return error("basic block definition should be located at the start of "
513 : "the line");
514 : else if (consumeIfPresent(MIToken::Newline)) {
515 : IsAfterNewline = true;
516 80109 : continue;
517 : }
518 : IsAfterNewline = false;
519 350266 : if (Token.is(MIToken::lbrace))
520 24 : ++BraceDepth;
521 350266 : if (Token.is(MIToken::rbrace)) {
522 24 : if (!BraceDepth)
523 1 : return error("extraneous closing brace ('}')");
524 23 : --BraceDepth;
525 : }
526 350265 : lex();
527 : }
528 : // Verify that we closed all of the '{' at the end of a file or a block.
529 6444 : if (!Token.isError() && BraceDepth)
530 1 : return error("expected '}'"); // FIXME: Report a note that shows '{'.
531 6443 : } while (!Token.isErrorOrEOF());
532 : return Token.isError();
533 : }
534 :
535 3783 : bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
536 : assert(Token.is(MIToken::kw_liveins));
537 3783 : lex();
538 3783 : if (expectAndConsume(MIToken::colon))
539 : return true;
540 7566 : if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
541 : return false;
542 : do {
543 7397 : if (Token.isNot(MIToken::NamedRegister))
544 1 : return error("expected a named register");
545 7396 : unsigned Reg = 0;
546 7396 : if (parseNamedRegister(Reg))
547 : return true;
548 7396 : lex();
549 : LaneBitmask Mask = LaneBitmask::getAll();
550 : if (consumeIfPresent(MIToken::colon)) {
551 : // Parse lane mask.
552 46 : if (Token.isNot(MIToken::IntegerLiteral) &&
553 : Token.isNot(MIToken::HexLiteral))
554 0 : return error("expected a lane mask");
555 : static_assert(sizeof(LaneBitmask::Type) == sizeof(unsigned),
556 : "Use correct get-function for lane mask");
557 : LaneBitmask::Type V;
558 46 : if (getUnsigned(V))
559 0 : return error("invalid lane mask value");
560 46 : Mask = LaneBitmask(V);
561 46 : lex();
562 : }
563 7396 : MBB.addLiveIn(Reg, Mask);
564 : } while (consumeIfPresent(MIToken::comma));
565 : return false;
566 : }
567 :
568 1020 : bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
569 : assert(Token.is(MIToken::kw_successors));
570 1020 : lex();
571 1020 : if (expectAndConsume(MIToken::colon))
572 : return true;
573 2040 : if (Token.isNewlineOrEOF()) // Allow an empty list of successors.
574 : return false;
575 : do {
576 1598 : if (Token.isNot(MIToken::MachineBasicBlock))
577 1 : return error("expected a machine basic block reference");
578 1597 : MachineBasicBlock *SuccMBB = nullptr;
579 1597 : if (parseMBBReference(SuccMBB))
580 : return true;
581 1597 : lex();
582 1597 : unsigned Weight = 0;
583 : if (consumeIfPresent(MIToken::lparen)) {
584 1076 : if (Token.isNot(MIToken::IntegerLiteral) &&
585 : Token.isNot(MIToken::HexLiteral))
586 1 : return error("expected an integer literal after '('");
587 1075 : if (getUnsigned(Weight))
588 : return true;
589 1075 : lex();
590 1075 : if (expectAndConsume(MIToken::rparen))
591 : return true;
592 : }
593 1596 : MBB.addSuccessor(SuccMBB, BranchProbability::getRaw(Weight));
594 : } while (consumeIfPresent(MIToken::comma));
595 : MBB.normalizeSuccProbs();
596 998 : return false;
597 : }
598 :
599 6389 : bool MIParser::parseBasicBlock(MachineBasicBlock &MBB,
600 : MachineBasicBlock *&AddFalthroughFrom) {
601 : // Skip the definition.
602 : assert(Token.is(MIToken::MachineBasicBlockLabel));
603 6389 : lex();
604 : if (consumeIfPresent(MIToken::lparen)) {
605 2285 : while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
606 1144 : lex();
607 : consumeIfPresent(MIToken::rparen);
608 : }
609 : consumeIfPresent(MIToken::colon);
610 :
611 : // Parse the liveins and successors.
612 : // N.B: Multiple lists of successors and liveins are allowed and they're
613 : // merged into one.
614 : // Example:
615 : // liveins: %edi
616 : // liveins: %esi
617 : //
618 : // is equivalent to
619 : // liveins: %edi, %esi
620 : bool ExplicitSuccessors = false;
621 : while (true) {
622 39374 : if (Token.is(MIToken::kw_successors)) {
623 1020 : if (parseBasicBlockSuccessors(MBB))
624 : return true;
625 : ExplicitSuccessors = true;
626 38354 : } else if (Token.is(MIToken::kw_liveins)) {
627 3783 : if (parseBasicBlockLiveins(MBB))
628 : return true;
629 : } else if (consumeIfPresent(MIToken::Newline)) {
630 28186 : continue;
631 : } else
632 : break;
633 9600 : if (!Token.isNewlineOrEOF())
634 1 : return error("expected line break at the end of a list");
635 4799 : lex();
636 : }
637 :
638 : // Parse the instructions.
639 : bool IsInBundle = false;
640 : MachineInstr *PrevMI = nullptr;
641 53008 : while (!Token.is(MIToken::MachineBasicBlockLabel) &&
642 : !Token.is(MIToken::Eof)) {
643 : if (consumeIfPresent(MIToken::Newline))
644 12042 : continue;
645 : if (consumeIfPresent(MIToken::rbrace)) {
646 : // The first parsing pass should verify that all closing '}' have an
647 : // opening '{'.
648 : assert(IsInBundle);
649 : IsInBundle = false;
650 21 : continue;
651 : }
652 34661 : MachineInstr *MI = nullptr;
653 34661 : if (parse(MI))
654 79 : return true;
655 34583 : MBB.insert(MBB.end(), MI);
656 34583 : if (IsInBundle) {
657 : PrevMI->setFlag(MachineInstr::BundledSucc);
658 30 : MI->setFlag(MachineInstr::BundledPred);
659 : }
660 34583 : PrevMI = MI;
661 34583 : if (Token.is(MIToken::lbrace)) {
662 23 : if (IsInBundle)
663 1 : return error("nested instruction bundles are not allowed");
664 22 : lex();
665 : // This instruction is the start of the bundle.
666 22 : MI->setFlag(MachineInstr::BundledSucc);
667 : IsInBundle = true;
668 22 : if (!Token.is(MIToken::Newline))
669 : // The next instruction can be on the same line.
670 : continue;
671 : }
672 : assert(Token.isNewlineOrEOF() && "MI is not fully parsed");
673 34581 : lex();
674 : }
675 :
676 : // Construct successor list by searching for basic block machine operands.
677 6306 : if (!ExplicitSuccessors) {
678 : SmallVector<MachineBasicBlock*,4> Successors;
679 : bool IsFallthrough;
680 5298 : guessSuccessors(MBB, Successors, IsFallthrough);
681 5798 : for (MachineBasicBlock *Succ : Successors)
682 500 : MBB.addSuccessor(Succ);
683 :
684 5298 : if (IsFallthrough) {
685 1576 : AddFalthroughFrom = &MBB;
686 : } else {
687 : MBB.normalizeSuccProbs();
688 : }
689 : }
690 :
691 : return false;
692 : }
693 :
694 4550 : bool MIParser::parseBasicBlocks() {
695 4550 : lex();
696 : // Skip until the first machine basic block.
697 12394 : while (Token.is(MIToken::Newline))
698 7844 : lex();
699 4550 : if (Token.isErrorOrEOF())
700 13 : return Token.isError();
701 : // The first parsing pass should have verified that this token is a MBB label
702 : // in the 'parseBasicBlockDefinitions' method.
703 : assert(Token.is(MIToken::MachineBasicBlockLabel));
704 4537 : MachineBasicBlock *AddFalthroughFrom = nullptr;
705 : do {
706 6389 : MachineBasicBlock *MBB = nullptr;
707 6389 : if (parseMBBReference(MBB))
708 83 : return true;
709 6389 : if (AddFalthroughFrom) {
710 386 : if (!AddFalthroughFrom->isSuccessor(MBB))
711 376 : AddFalthroughFrom->addSuccessor(MBB);
712 386 : AddFalthroughFrom->normalizeSuccProbs();
713 386 : AddFalthroughFrom = nullptr;
714 : }
715 6389 : if (parseBasicBlock(*MBB, AddFalthroughFrom))
716 : return true;
717 : // The method 'parseBasicBlock' should parse the whole block until the next
718 : // block or the end of file.
719 : assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof));
720 6306 : } while (Token.isNot(MIToken::Eof));
721 : return false;
722 : }
723 :
724 34661 : bool MIParser::parse(MachineInstr *&MI) {
725 : // Parse any register operands before '='
726 : MachineOperand MO = MachineOperand::CreateImm(0);
727 : SmallVector<ParsedMachineOperand, 8> Operands;
728 34951 : while (Token.isRegister() || Token.isRegisterFlag()) {
729 : auto Loc = Token.location();
730 : Optional<unsigned> TiedDefIdx;
731 26312 : if (parseRegisterOperand(MO, TiedDefIdx, /*IsDef=*/true))
732 : return true;
733 26302 : Operands.push_back(
734 26302 : ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
735 26302 : if (Token.isNot(MIToken::comma))
736 : break;
737 290 : lex();
738 : }
739 34651 : if (!Operands.empty() && expectAndConsume(MIToken::equal))
740 : return true;
741 :
742 34651 : unsigned OpCode, Flags = 0;
743 34651 : if (Token.isError() || parseInstruction(OpCode, Flags))
744 1 : return true;
745 :
746 : // Parse the remaining machine operands.
747 76904 : while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_pre_instr_symbol) &&
748 75307 : Token.isNot(MIToken::kw_post_instr_symbol) &&
749 74721 : Token.isNot(MIToken::kw_debug_location) &&
750 151624 : Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
751 : auto Loc = Token.location();
752 : Optional<unsigned> TiedDefIdx;
753 74719 : if (parseMachineOperandAndTargetFlags(MO, TiedDefIdx))
754 : return true;
755 74675 : Operands.push_back(
756 74675 : ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
757 149350 : if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
758 : Token.is(MIToken::lbrace))
759 : break;
760 42255 : if (Token.isNot(MIToken::comma))
761 1 : return error("expected ',' before the next machine operand");
762 42254 : lex();
763 : }
764 :
765 34605 : MCSymbol *PreInstrSymbol = nullptr;
766 34605 : if (Token.is(MIToken::kw_pre_instr_symbol))
767 4 : if (parsePreOrPostInstrSymbol(PreInstrSymbol))
768 : return true;
769 34605 : MCSymbol *PostInstrSymbol = nullptr;
770 34605 : if (Token.is(MIToken::kw_post_instr_symbol))
771 4 : if (parsePreOrPostInstrSymbol(PostInstrSymbol))
772 : return true;
773 :
774 34605 : DebugLoc DebugLocation;
775 34605 : if (Token.is(MIToken::kw_debug_location)) {
776 587 : lex();
777 587 : if (Token.isNot(MIToken::exclaim))
778 1 : return error("expected a metadata node after 'debug-location'");
779 586 : MDNode *Node = nullptr;
780 586 : if (parseMDNode(Node))
781 : return true;
782 1172 : if (!isa<DILocation>(Node))
783 1 : return error("referenced metadata is not a DILocation");
784 1170 : DebugLocation = DebugLoc(Node);
785 : }
786 :
787 : // Parse the machine memory operands.
788 : SmallVector<MachineMemOperand *, 2> MemOperands;
789 34603 : if (Token.is(MIToken::coloncolon)) {
790 2407 : lex();
791 4834 : while (!Token.isNewlineOrEOF()) {
792 2427 : MachineMemOperand *MemOp = nullptr;
793 2427 : if (parseMachineMemoryOperand(MemOp))
794 14 : return true;
795 2414 : MemOperands.push_back(MemOp);
796 4828 : if (Token.isNewlineOrEOF())
797 : break;
798 21 : if (Token.isNot(MIToken::comma))
799 1 : return error("expected ',' before the next machine memory operand");
800 20 : lex();
801 : }
802 : }
803 :
804 34589 : const auto &MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
805 69178 : if (!MCID.isVariadic()) {
806 : // FIXME: Move the implicit operand verification to the machine verifier.
807 31809 : if (verifyImplicitOperands(Operands, MCID))
808 : return true;
809 : }
810 :
811 : // TODO: Check for extraneous machine operands.
812 34586 : MI = MF.CreateMachineInstr(MCID, DebugLocation, /*NoImplicit=*/true);
813 34586 : MI->setFlags(Flags);
814 135381 : for (const auto &Operand : Operands)
815 100795 : MI->addOperand(MF, Operand.Operand);
816 34586 : if (assignRegisterTies(*MI, Operands))
817 : return true;
818 34583 : if (PreInstrSymbol)
819 4 : MI->setPreInstrSymbol(MF, PreInstrSymbol);
820 34583 : if (PostInstrSymbol)
821 4 : MI->setPostInstrSymbol(MF, PostInstrSymbol);
822 34583 : if (!MemOperands.empty())
823 4786 : MI->setMemRefs(MF, MemOperands);
824 : return false;
825 : }
826 :
827 92 : bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
828 92 : lex();
829 92 : if (Token.isNot(MIToken::MachineBasicBlock))
830 0 : return error("expected a machine basic block reference");
831 92 : if (parseMBBReference(MBB))
832 : return true;
833 92 : lex();
834 92 : if (Token.isNot(MIToken::Eof))
835 0 : return error(
836 : "expected end of string after the machine basic block reference");
837 : return false;
838 : }
839 :
840 2609 : bool MIParser::parseStandaloneNamedRegister(unsigned &Reg) {
841 2609 : lex();
842 2609 : if (Token.isNot(MIToken::NamedRegister))
843 2 : return error("expected a named register");
844 2607 : if (parseNamedRegister(Reg))
845 : return true;
846 2606 : lex();
847 2606 : if (Token.isNot(MIToken::Eof))
848 0 : return error("expected end of string after the register reference");
849 : return false;
850 : }
851 :
852 1133 : bool MIParser::parseStandaloneVirtualRegister(VRegInfo *&Info) {
853 1133 : lex();
854 1133 : if (Token.isNot(MIToken::VirtualRegister))
855 1 : return error("expected a virtual register");
856 1132 : if (parseVirtualRegister(Info))
857 : return true;
858 1132 : lex();
859 1132 : if (Token.isNot(MIToken::Eof))
860 0 : return error("expected end of string after the register reference");
861 : return false;
862 : }
863 :
864 12 : bool MIParser::parseStandaloneRegister(unsigned &Reg) {
865 12 : lex();
866 12 : if (Token.isNot(MIToken::NamedRegister) &&
867 : Token.isNot(MIToken::VirtualRegister))
868 0 : return error("expected either a named or virtual register");
869 :
870 : VRegInfo *Info;
871 12 : if (parseRegister(Reg, Info))
872 : return true;
873 :
874 12 : lex();
875 12 : if (Token.isNot(MIToken::Eof))
876 0 : return error("expected end of string after the register reference");
877 : return false;
878 : }
879 :
880 2 : bool MIParser::parseStandaloneStackObject(int &FI) {
881 2 : lex();
882 2 : if (Token.isNot(MIToken::StackObject))
883 1 : return error("expected a stack object");
884 1 : if (parseStackFrameIndex(FI))
885 : return true;
886 1 : if (Token.isNot(MIToken::Eof))
887 0 : return error("expected end of string after the stack object reference");
888 : return false;
889 : }
890 :
891 10 : bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
892 10 : lex();
893 10 : if (Token.is(MIToken::exclaim)) {
894 7 : if (parseMDNode(Node))
895 : return true;
896 3 : } else if (Token.is(MIToken::md_diexpr)) {
897 2 : if (parseDIExpression(Node))
898 : return true;
899 : } else
900 1 : return error("expected a metadata node");
901 9 : if (Token.isNot(MIToken::Eof))
902 0 : return error("expected end of string after the metadata node");
903 : return false;
904 : }
905 :
906 : static const char *printImplicitRegisterFlag(const MachineOperand &MO) {
907 : assert(MO.isImplicit());
908 3 : return MO.isDef() ? "implicit-def" : "implicit";
909 : }
910 :
911 3 : static std::string getRegisterName(const TargetRegisterInfo *TRI,
912 : unsigned Reg) {
913 : assert(TargetRegisterInfo::isPhysicalRegister(Reg) && "expected phys reg");
914 3 : return StringRef(TRI->getName(Reg)).lower();
915 : }
916 :
917 : /// Return true if the parsed machine operands contain a given machine operand.
918 : static bool isImplicitOperandIn(const MachineOperand &ImplicitOperand,
919 : ArrayRef<ParsedMachineOperand> Operands) {
920 28950 : for (const auto &I : Operands) {
921 28947 : if (ImplicitOperand.isIdenticalTo(I.Operand))
922 : return true;
923 : }
924 : return false;
925 : }
926 :
927 31809 : bool MIParser::verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
928 : const MCInstrDesc &MCID) {
929 63618 : if (MCID.isCall())
930 : // We can't verify call instructions as they can contain arbitrary implicit
931 : // register and register mask operands.
932 : return false;
933 :
934 : // Gather all the expected implicit operands.
935 : SmallVector<MachineOperand, 4> ImplicitOperands;
936 31574 : if (MCID.ImplicitDefs)
937 3897 : for (const MCPhysReg *ImpDefs = MCID.getImplicitDefs(); *ImpDefs; ++ImpDefs)
938 2076 : ImplicitOperands.push_back(
939 2076 : MachineOperand::CreateReg(*ImpDefs, true, true));
940 31574 : if (MCID.ImplicitUses)
941 8028 : for (const MCPhysReg *ImpUses = MCID.getImplicitUses(); *ImpUses; ++ImpUses)
942 4484 : ImplicitOperands.push_back(
943 4484 : MachineOperand::CreateReg(*ImpUses, false, true));
944 :
945 31574 : const auto *TRI = MF.getSubtarget().getRegisterInfo();
946 : assert(TRI && "Expected target register info");
947 38131 : for (const auto &I : ImplicitOperands) {
948 6560 : if (isImplicitOperandIn(I, Operands))
949 : continue;
950 3 : return error(Operands.empty() ? Token.location() : Operands.back().End,
951 3 : Twine("missing implicit register operand '") +
952 6 : printImplicitRegisterFlag(I) + " $" +
953 6 : getRegisterName(TRI, I.getReg()) + "'");
954 : }
955 : return false;
956 : }
957 :
958 34651 : bool MIParser::parseInstruction(unsigned &OpCode, unsigned &Flags) {
959 : // Allow frame and fast math flags for OPCODE
960 34937 : while (Token.is(MIToken::kw_frame_setup) ||
961 34689 : Token.is(MIToken::kw_frame_destroy) ||
962 34684 : Token.is(MIToken::kw_nnan) ||
963 34683 : Token.is(MIToken::kw_ninf) ||
964 34677 : Token.is(MIToken::kw_nsz) ||
965 34671 : Token.is(MIToken::kw_arcp) ||
966 34664 : Token.is(MIToken::kw_contract) ||
967 34661 : Token.is(MIToken::kw_afn) ||
968 34654 : Token.is(MIToken::kw_reassoc) ||
969 34653 : Token.is(MIToken::kw_nuw) ||
970 69534 : Token.is(MIToken::kw_nsw) ||
971 : Token.is(MIToken::kw_exact)) {
972 : // Mine frame and fast math flags
973 231 : if (Token.is(MIToken::kw_frame_setup))
974 176 : Flags |= MachineInstr::FrameSetup;
975 231 : if (Token.is(MIToken::kw_frame_destroy))
976 17 : Flags |= MachineInstr::FrameDestroy;
977 231 : if (Token.is(MIToken::kw_nnan))
978 5 : Flags |= MachineInstr::FmNoNans;
979 231 : if (Token.is(MIToken::kw_ninf))
980 1 : Flags |= MachineInstr::FmNoInfs;
981 231 : if (Token.is(MIToken::kw_nsz))
982 6 : Flags |= MachineInstr::FmNsz;
983 231 : if (Token.is(MIToken::kw_arcp))
984 6 : Flags |= MachineInstr::FmArcp;
985 231 : if (Token.is(MIToken::kw_contract))
986 7 : Flags |= MachineInstr::FmContract;
987 231 : if (Token.is(MIToken::kw_afn))
988 3 : Flags |= MachineInstr::FmAfn;
989 231 : if (Token.is(MIToken::kw_reassoc))
990 7 : Flags |= MachineInstr::FmReassoc;
991 231 : if (Token.is(MIToken::kw_nuw))
992 1 : Flags |= MachineInstr::NoUWrap;
993 231 : if (Token.is(MIToken::kw_nsw))
994 1 : Flags |= MachineInstr::NoSWrap;
995 231 : if (Token.is(MIToken::kw_exact))
996 1 : Flags |= MachineInstr::IsExact;
997 :
998 231 : lex();
999 : }
1000 34651 : if (Token.isNot(MIToken::Identifier))
1001 0 : return error("expected a machine instruction");
1002 34651 : StringRef InstrName = Token.stringValue();
1003 34651 : if (parseInstrName(InstrName, OpCode))
1004 1 : return error(Twine("unknown machine instruction name '") + InstrName + "'");
1005 34650 : lex();
1006 34650 : return false;
1007 : }
1008 :
1009 54321 : bool MIParser::parseNamedRegister(unsigned &Reg) {
1010 : assert(Token.is(MIToken::NamedRegister) && "Needs NamedRegister token");
1011 54321 : StringRef Name = Token.stringValue();
1012 54321 : if (getRegisterByName(Name, Reg))
1013 2 : return error(Twine("unknown register name '") + Name + "'");
1014 : return false;
1015 : }
1016 :
1017 : bool MIParser::parseNamedVirtualRegister(VRegInfo *&Info) {
1018 : assert(Token.is(MIToken::NamedVirtualRegister) && "Expected NamedVReg token");
1019 44 : StringRef Name = Token.stringValue();
1020 : // TODO: Check that the VReg name is not the same as a physical register name.
1021 : // If it is, then print a warning (when warnings are implemented).
1022 44 : Info = &PFS.getVRegInfoNamed(Name);
1023 : return false;
1024 : }
1025 :
1026 34942 : bool MIParser::parseVirtualRegister(VRegInfo *&Info) {
1027 34942 : if (Token.is(MIToken::NamedVirtualRegister))
1028 44 : return parseNamedVirtualRegister(Info);
1029 : assert(Token.is(MIToken::VirtualRegister) && "Needs VirtualRegister token");
1030 : unsigned ID;
1031 34898 : if (getUnsigned(ID))
1032 : return true;
1033 34898 : Info = &PFS.getVRegInfo(ID);
1034 34898 : return false;
1035 : }
1036 :
1037 78598 : bool MIParser::parseRegister(unsigned &Reg, VRegInfo *&Info) {
1038 78598 : switch (Token.kind()) {
1039 675 : case MIToken::underscore:
1040 675 : Reg = 0;
1041 675 : return false;
1042 44113 : case MIToken::NamedRegister:
1043 44113 : return parseNamedRegister(Reg);
1044 33810 : case MIToken::NamedVirtualRegister:
1045 : case MIToken::VirtualRegister:
1046 33810 : if (parseVirtualRegister(Info))
1047 : return true;
1048 33810 : Reg = Info->VReg;
1049 33810 : return false;
1050 : // TODO: Parse other register kinds.
1051 0 : default:
1052 0 : llvm_unreachable("The current token should be a register");
1053 : }
1054 : }
1055 :
1056 7110 : bool MIParser::parseRegisterClassOrBank(VRegInfo &RegInfo) {
1057 7110 : if (Token.isNot(MIToken::Identifier) && Token.isNot(MIToken::underscore))
1058 0 : return error("expected '_', register class, or register bank name");
1059 : StringRef::iterator Loc = Token.location();
1060 : StringRef Name = Token.stringValue();
1061 :
1062 : // Was it a register class?
1063 7110 : auto RCNameI = PFS.Names2RegClasses.find(Name);
1064 14220 : if (RCNameI != PFS.Names2RegClasses.end()) {
1065 2395 : lex();
1066 2395 : const TargetRegisterClass &RC = *RCNameI->getValue();
1067 :
1068 2395 : switch (RegInfo.Kind) {
1069 2395 : case VRegInfo::UNKNOWN:
1070 : case VRegInfo::NORMAL:
1071 2395 : RegInfo.Kind = VRegInfo::NORMAL;
1072 2395 : if (RegInfo.Explicit && RegInfo.D.RC != &RC) {
1073 1 : const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
1074 1 : return error(Loc, Twine("conflicting register classes, previously: ") +
1075 2 : Twine(TRI.getRegClassName(RegInfo.D.RC)));
1076 : }
1077 2394 : RegInfo.D.RC = &RC;
1078 2394 : RegInfo.Explicit = true;
1079 2394 : return false;
1080 :
1081 : case VRegInfo::GENERIC:
1082 : case VRegInfo::REGBANK:
1083 0 : return error(Loc, "register class specification on generic register");
1084 : }
1085 0 : llvm_unreachable("Unexpected register kind");
1086 : }
1087 :
1088 : // Should be a register bank or a generic register.
1089 : const RegisterBank *RegBank = nullptr;
1090 : if (Name != "_") {
1091 1939 : auto RBNameI = PFS.Names2RegBanks.find(Name);
1092 3878 : if (RBNameI == PFS.Names2RegBanks.end())
1093 0 : return error(Loc, "expected '_', register class, or register bank name");
1094 1939 : RegBank = RBNameI->getValue();
1095 : }
1096 :
1097 4715 : lex();
1098 :
1099 4715 : switch (RegInfo.Kind) {
1100 4715 : case VRegInfo::UNKNOWN:
1101 : case VRegInfo::GENERIC:
1102 : case VRegInfo::REGBANK:
1103 4715 : RegInfo.Kind = RegBank ? VRegInfo::REGBANK : VRegInfo::GENERIC;
1104 4715 : if (RegInfo.Explicit && RegInfo.D.RegBank != RegBank)
1105 0 : return error(Loc, "conflicting generic register banks");
1106 4715 : RegInfo.D.RegBank = RegBank;
1107 4715 : RegInfo.Explicit = true;
1108 4715 : return false;
1109 :
1110 : case VRegInfo::NORMAL:
1111 0 : return error(Loc, "register bank specification on normal register");
1112 : }
1113 0 : llvm_unreachable("Unexpected register kind");
1114 : }
1115 :
1116 22086 : bool MIParser::parseRegisterFlag(unsigned &Flags) {
1117 22086 : const unsigned OldFlags = Flags;
1118 22086 : switch (Token.kind()) {
1119 8253 : case MIToken::kw_implicit:
1120 8253 : Flags |= RegState::Implicit;
1121 8253 : break;
1122 3563 : case MIToken::kw_implicit_define:
1123 3563 : Flags |= RegState::ImplicitDefine;
1124 3563 : break;
1125 133 : case MIToken::kw_def:
1126 133 : Flags |= RegState::Define;
1127 133 : break;
1128 1744 : case MIToken::kw_dead:
1129 1744 : Flags |= RegState::Dead;
1130 1744 : break;
1131 5194 : case MIToken::kw_killed:
1132 5194 : Flags |= RegState::Kill;
1133 5194 : break;
1134 937 : case MIToken::kw_undef:
1135 937 : Flags |= RegState::Undef;
1136 937 : break;
1137 6 : case MIToken::kw_internal:
1138 6 : Flags |= RegState::InternalRead;
1139 6 : break;
1140 188 : case MIToken::kw_early_clobber:
1141 188 : Flags |= RegState::EarlyClobber;
1142 188 : break;
1143 406 : case MIToken::kw_debug_use:
1144 406 : Flags |= RegState::Debug;
1145 406 : break;
1146 1662 : case MIToken::kw_renamable:
1147 1662 : Flags |= RegState::Renamable;
1148 1662 : break;
1149 0 : default:
1150 0 : llvm_unreachable("The current token should be a register flag");
1151 : }
1152 22086 : if (OldFlags == Flags)
1153 : // We know that the same flag is specified more than once when the flags
1154 : // weren't modified.
1155 2 : return error("duplicate '" + Token.stringValue() + "' register flag");
1156 22085 : lex();
1157 22085 : return false;
1158 : }
1159 :
1160 1042 : bool MIParser::parseSubRegisterIndex(unsigned &SubReg) {
1161 : assert(Token.is(MIToken::dot));
1162 1042 : lex();
1163 1042 : if (Token.isNot(MIToken::Identifier))
1164 1 : return error("expected a subregister index after '.'");
1165 1041 : auto Name = Token.stringValue();
1166 1041 : SubReg = getSubRegIndex(Name);
1167 1041 : if (!SubReg)
1168 1 : return error(Twine("use of unknown subregister index '") + Name + "'");
1169 1040 : lex();
1170 1040 : return false;
1171 : }
1172 :
1173 5159 : bool MIParser::parseRegisterTiedDefIndex(unsigned &TiedDefIdx) {
1174 : if (!consumeIfPresent(MIToken::kw_tied_def))
1175 : return true;
1176 24 : if (Token.isNot(MIToken::IntegerLiteral))
1177 1 : return error("expected an integer literal after 'tied-def'");
1178 23 : if (getUnsigned(TiedDefIdx))
1179 : return true;
1180 23 : lex();
1181 23 : if (expectAndConsume(MIToken::rparen))
1182 0 : return true;
1183 : return false;
1184 : }
1185 :
1186 34586 : bool MIParser::assignRegisterTies(MachineInstr &MI,
1187 : ArrayRef<ParsedMachineOperand> Operands) {
1188 : SmallVector<std::pair<unsigned, unsigned>, 4> TiedRegisterPairs;
1189 135378 : for (unsigned I = 0, E = Operands.size(); I != E; ++I) {
1190 201590 : if (!Operands[I].TiedDefIdx)
1191 : continue;
1192 : // The parser ensures that this operand is a register use, so we just have
1193 : // to check the tied-def operand.
1194 23 : unsigned DefIdx = Operands[I].TiedDefIdx.getValue();
1195 23 : if (DefIdx >= E)
1196 1 : return error(Operands[I].Begin,
1197 1 : Twine("use of invalid tied-def operand index '" +
1198 2 : Twine(DefIdx) + "'; instruction has only ") +
1199 1 : Twine(E) + " operands");
1200 22 : const auto &DefOperand = Operands[DefIdx].Operand;
1201 22 : if (!DefOperand.isReg() || !DefOperand.isDef())
1202 : // FIXME: add note with the def operand.
1203 1 : return error(Operands[I].Begin,
1204 1 : Twine("use of invalid tied-def operand index '") +
1205 2 : Twine(DefIdx) + "'; the operand #" + Twine(DefIdx) +
1206 1 : " isn't a defined register");
1207 : // Check that the tied-def operand wasn't tied elsewhere.
1208 23 : for (const auto &TiedPair : TiedRegisterPairs) {
1209 3 : if (TiedPair.first == DefIdx)
1210 1 : return error(Operands[I].Begin,
1211 1 : Twine("the tied-def operand #") + Twine(DefIdx) +
1212 1 : " is already tied with another register operand");
1213 : }
1214 20 : TiedRegisterPairs.push_back(std::make_pair(DefIdx, I));
1215 : }
1216 : // FIXME: Verify that for non INLINEASM instructions, the def and use tied
1217 : // indices must be less than tied max.
1218 34602 : for (const auto &TiedPair : TiedRegisterPairs)
1219 19 : MI.tieOperands(TiedPair.first, TiedPair.second);
1220 : return false;
1221 : }
1222 :
1223 78588 : bool MIParser::parseRegisterOperand(MachineOperand &Dest,
1224 : Optional<unsigned> &TiedDefIdx,
1225 : bool IsDef) {
1226 130864 : unsigned Flags = IsDef ? RegState::Define : 0;
1227 100673 : while (Token.isRegisterFlag()) {
1228 22086 : if (parseRegisterFlag(Flags))
1229 : return true;
1230 : }
1231 : if (!Token.isRegister())
1232 1 : return error("expected a register after register flags");
1233 : unsigned Reg;
1234 : VRegInfo *RegInfo;
1235 78586 : if (parseRegister(Reg, RegInfo))
1236 : return true;
1237 78585 : lex();
1238 78585 : unsigned SubReg = 0;
1239 78585 : if (Token.is(MIToken::dot)) {
1240 1042 : if (parseSubRegisterIndex(SubReg))
1241 : return true;
1242 2080 : if (!TargetRegisterInfo::isVirtualRegister(Reg))
1243 1 : return error("subregister index expects a virtual register");
1244 : }
1245 78582 : if (Token.is(MIToken::colon)) {
1246 14222 : if (!TargetRegisterInfo::isVirtualRegister(Reg))
1247 1 : return error("register class specification expects a virtual register");
1248 7110 : lex();
1249 7110 : if (parseRegisterClassOrBank(*RegInfo))
1250 : return true;
1251 : }
1252 78580 : MachineRegisterInfo &MRI = MF.getRegInfo();
1253 78580 : if ((Flags & RegState::Define) == 0) {
1254 : if (consumeIfPresent(MIToken::lparen)) {
1255 : unsigned Idx;
1256 5159 : if (!parseRegisterTiedDefIndex(Idx))
1257 23 : TiedDefIdx = Idx;
1258 : else {
1259 : // Try a redundant low-level type.
1260 : LLT Ty;
1261 5136 : if (parseLowLevelType(Token.location(), Ty))
1262 2 : return error("expected tied-def or low-level type after '('");
1263 :
1264 5134 : if (expectAndConsume(MIToken::rparen))
1265 : return true;
1266 :
1267 15401 : if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1268 0 : return error("inconsistent type for generic virtual register");
1269 :
1270 5134 : MRI.setType(Reg, Ty);
1271 : }
1272 : }
1273 : } else if (consumeIfPresent(MIToken::lparen)) {
1274 : // Virtual registers may have a tpe with GlobalISel.
1275 19544 : if (!TargetRegisterInfo::isVirtualRegister(Reg))
1276 1 : return error("unexpected type on physical register");
1277 :
1278 : LLT Ty;
1279 9771 : if (parseLowLevelType(Token.location(), Ty))
1280 : return true;
1281 :
1282 9767 : if (expectAndConsume(MIToken::rparen))
1283 : return true;
1284 :
1285 19535 : if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1286 0 : return error("inconsistent type for generic virtual register");
1287 :
1288 9767 : MRI.setType(Reg, Ty);
1289 40464 : } else if (TargetRegisterInfo::isVirtualRegister(Reg)) {
1290 : // Generic virtual registers must have a type.
1291 : // If we end up here this means the type hasn't been specified and
1292 : // this is bad!
1293 6634 : if (RegInfo->Kind == VRegInfo::GENERIC ||
1294 : RegInfo->Kind == VRegInfo::REGBANK)
1295 2 : return error("generic virtual registers must have a type");
1296 : }
1297 : Dest = MachineOperand::CreateReg(
1298 157142 : Reg, Flags & RegState::Define, Flags & RegState::Implicit,
1299 157142 : Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
1300 157142 : Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug,
1301 78571 : Flags & RegState::InternalRead, Flags & RegState::Renamable);
1302 :
1303 78571 : return false;
1304 : }
1305 :
1306 17282 : bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
1307 : assert(Token.is(MIToken::IntegerLiteral));
1308 : const APSInt &Int = Token.integerValue();
1309 17282 : if (Int.getMinSignedBits() > 64)
1310 1 : return error("integer literal is too large to be an immediate operand");
1311 17281 : Dest = MachineOperand::CreateImm(Int.getExtValue());
1312 17281 : lex();
1313 17281 : return false;
1314 : }
1315 :
1316 1001 : bool MIParser::parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
1317 : const Constant *&C) {
1318 1001 : auto Source = StringValue.str(); // The source has to be null terminated.
1319 1001 : SMDiagnostic Err;
1320 1001 : C = parseConstantValue(Source, Err, *MF.getFunction().getParent(),
1321 1001 : &PFS.IRSlots);
1322 1001 : if (!C)
1323 2 : return error(Loc + Err.getColumnNo(), Err.getMessage());
1324 : return false;
1325 : }
1326 :
1327 504 : bool MIParser::parseIRConstant(StringRef::iterator Loc, const Constant *&C) {
1328 1008 : if (parseIRConstant(Loc, StringRef(Loc, Token.range().end() - Loc), C))
1329 : return true;
1330 503 : lex();
1331 503 : return false;
1332 : }
1333 :
1334 14907 : bool MIParser::parseLowLevelType(StringRef::iterator Loc, LLT &Ty) {
1335 14907 : if (Token.range().front() == 's' || Token.range().front() == 'p') {
1336 13179 : StringRef SizeStr = Token.range().drop_front();
1337 26357 : if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
1338 1 : return error("expected integers after 's'/'p' type character");
1339 : }
1340 :
1341 14906 : if (Token.range().front() == 's') {
1342 47440 : Ty = LLT::scalar(APSInt(Token.range().drop_front()).getZExtValue());
1343 11860 : lex();
1344 11860 : return false;
1345 3046 : } else if (Token.range().front() == 'p') {
1346 1318 : const DataLayout &DL = MF.getDataLayout();
1347 3954 : unsigned AS = APSInt(Token.range().drop_front()).getZExtValue();
1348 1318 : Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
1349 1318 : lex();
1350 1318 : return false;
1351 : }
1352 :
1353 : // Now we're looking for a vector.
1354 1728 : if (Token.isNot(MIToken::less))
1355 3 : return error(Loc,
1356 : "expected sN, pA, <M x sN>, or <M x pA> for GlobalISel type");
1357 1725 : lex();
1358 :
1359 1725 : if (Token.isNot(MIToken::IntegerLiteral))
1360 0 : return error(Loc, "expected <M x sN> or <M x pA> for vector type");
1361 : uint64_t NumElements = Token.integerValue().getZExtValue();
1362 1725 : lex();
1363 :
1364 1725 : if (Token.isNot(MIToken::Identifier) || Token.stringValue() != "x")
1365 0 : return error(Loc, "expected <M x sN> or <M x pA> for vector type");
1366 1725 : lex();
1367 :
1368 1725 : if (Token.range().front() != 's' && Token.range().front() != 'p')
1369 1 : return error(Loc, "expected <M x sN> or <M x pA> for vector type");
1370 1724 : StringRef SizeStr = Token.range().drop_front();
1371 3447 : if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
1372 1 : return error("expected integers after 's'/'p' type character");
1373 :
1374 1723 : if (Token.range().front() == 's')
1375 6884 : Ty = LLT::scalar(APSInt(Token.range().drop_front()).getZExtValue());
1376 2 : else if (Token.range().front() == 'p') {
1377 2 : const DataLayout &DL = MF.getDataLayout();
1378 6 : unsigned AS = APSInt(Token.range().drop_front()).getZExtValue();
1379 2 : Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
1380 : } else
1381 0 : return error(Loc, "expected <M x sN> or <M x pA> for vector type");
1382 1723 : lex();
1383 :
1384 1723 : if (Token.isNot(MIToken::greater))
1385 0 : return error(Loc, "expected <M x sN> or <M x pA> for vector type");
1386 1723 : lex();
1387 :
1388 1723 : Ty = LLT::vector(NumElements, Ty);
1389 1723 : return false;
1390 : }
1391 :
1392 453 : bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
1393 : assert(Token.is(MIToken::Identifier));
1394 : StringRef TypeStr = Token.range();
1395 453 : if (TypeStr.front() != 'i' && TypeStr.front() != 's' &&
1396 : TypeStr.front() != 'p')
1397 1 : return error(
1398 : "a typed immediate operand should start with one of 'i', 's', or 'p'");
1399 452 : StringRef SizeStr = Token.range().drop_front();
1400 903 : if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
1401 1 : return error("expected integers after 'i'/'s'/'p' type character");
1402 :
1403 : auto Loc = Token.location();
1404 451 : lex();
1405 451 : if (Token.isNot(MIToken::IntegerLiteral)) {
1406 4 : if (Token.isNot(MIToken::Identifier) ||
1407 : !(Token.range() == "true" || Token.range() == "false"))
1408 0 : return error("expected an integer literal");
1409 : }
1410 451 : const Constant *C = nullptr;
1411 451 : if (parseIRConstant(Loc, C))
1412 : return true;
1413 451 : Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
1414 451 : return false;
1415 : }
1416 :
1417 54 : bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
1418 : auto Loc = Token.location();
1419 54 : lex();
1420 54 : if (Token.isNot(MIToken::FloatingPointLiteral) &&
1421 : Token.isNot(MIToken::HexLiteral))
1422 1 : return error("expected a floating point literal");
1423 53 : const Constant *C = nullptr;
1424 53 : if (parseIRConstant(Loc, C))
1425 : return true;
1426 52 : Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
1427 52 : return false;
1428 : }
1429 :
1430 55830 : bool MIParser::getUnsigned(unsigned &Result) {
1431 55830 : if (Token.hasIntegerValue()) {
1432 : const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
1433 54737 : uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
1434 54736 : if (Val64 == Limit)
1435 1 : return error("expected 32-bit integer (too large)");
1436 54736 : Result = Val64;
1437 54736 : return false;
1438 : }
1439 1093 : if (Token.is(MIToken::HexLiteral)) {
1440 : APInt A;
1441 1093 : if (getHexUint(A))
1442 : return true;
1443 1093 : if (A.getBitWidth() > 32)
1444 0 : return error("expected 32-bit integer (too large)");
1445 1093 : Result = A.getZExtValue();
1446 1093 : return false;
1447 : }
1448 : return true;
1449 : }
1450 :
1451 9714 : bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
1452 : assert(Token.is(MIToken::MachineBasicBlock) ||
1453 : Token.is(MIToken::MachineBasicBlockLabel));
1454 : unsigned Number;
1455 9714 : if (getUnsigned(Number))
1456 : return true;
1457 9713 : auto MBBInfo = PFS.MBBSlots.find(Number);
1458 19426 : if (MBBInfo == PFS.MBBSlots.end())
1459 1 : return error(Twine("use of undefined machine basic block #") +
1460 2 : Twine(Number));
1461 9712 : MBB = MBBInfo->second;
1462 : // TODO: Only parse the name if it's a MachineBasicBlockLabel. Deprecate once
1463 : // we drop the <irname> from the bb.<id>.<irname> format.
1464 9712 : if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
1465 1 : return error(Twine("the name of machine basic block #") + Twine(Number) +
1466 2 : " isn't '" + Token.stringValue() + "'");
1467 : return false;
1468 : }
1469 :
1470 1636 : bool MIParser::parseMBBOperand(MachineOperand &Dest) {
1471 : MachineBasicBlock *MBB;
1472 1636 : if (parseMBBReference(MBB))
1473 : return true;
1474 1633 : Dest = MachineOperand::CreateMBB(MBB);
1475 1633 : lex();
1476 1633 : return false;
1477 : }
1478 :
1479 435 : bool MIParser::parseStackFrameIndex(int &FI) {
1480 : assert(Token.is(MIToken::StackObject));
1481 : unsigned ID;
1482 435 : if (getUnsigned(ID))
1483 : return true;
1484 435 : auto ObjectInfo = PFS.StackObjectSlots.find(ID);
1485 870 : if (ObjectInfo == PFS.StackObjectSlots.end())
1486 1 : return error(Twine("use of undefined stack object '%stack.") + Twine(ID) +
1487 1 : "'");
1488 : StringRef Name;
1489 434 : if (const auto *Alloca =
1490 434 : MF.getFrameInfo().getObjectAllocation(ObjectInfo->second))
1491 203 : Name = Alloca->getName();
1492 434 : if (!Token.stringValue().empty() && Token.stringValue() != Name)
1493 1 : return error(Twine("the name of the stack object '%stack.") + Twine(ID) +
1494 2 : "' isn't '" + Token.stringValue() + "'");
1495 433 : lex();
1496 433 : FI = ObjectInfo->second;
1497 433 : return false;
1498 : }
1499 :
1500 : bool MIParser::parseStackObjectOperand(MachineOperand &Dest) {
1501 : int FI;
1502 272 : if (parseStackFrameIndex(FI))
1503 : return true;
1504 270 : Dest = MachineOperand::CreateFI(FI);
1505 : return false;
1506 : }
1507 :
1508 157 : bool MIParser::parseFixedStackFrameIndex(int &FI) {
1509 : assert(Token.is(MIToken::FixedStackObject));
1510 : unsigned ID;
1511 157 : if (getUnsigned(ID))
1512 : return true;
1513 157 : auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
1514 314 : if (ObjectInfo == PFS.FixedStackObjectSlots.end())
1515 1 : return error(Twine("use of undefined fixed stack object '%fixed-stack.") +
1516 2 : Twine(ID) + "'");
1517 156 : lex();
1518 156 : FI = ObjectInfo->second;
1519 156 : return false;
1520 : }
1521 :
1522 : bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
1523 : int FI;
1524 73 : if (parseFixedStackFrameIndex(FI))
1525 : return true;
1526 72 : Dest = MachineOperand::CreateFI(FI);
1527 : return false;
1528 : }
1529 :
1530 969 : bool MIParser::parseGlobalValue(GlobalValue *&GV) {
1531 969 : switch (Token.kind()) {
1532 963 : case MIToken::NamedGlobalValue: {
1533 963 : const Module *M = MF.getFunction().getParent();
1534 963 : GV = M->getNamedValue(Token.stringValue());
1535 963 : if (!GV)
1536 1 : return error(Twine("use of undefined global value '") + Token.range() +
1537 1 : "'");
1538 : break;
1539 : }
1540 6 : case MIToken::GlobalValue: {
1541 : unsigned GVIdx;
1542 6 : if (getUnsigned(GVIdx))
1543 1 : return true;
1544 12 : if (GVIdx >= PFS.IRSlots.GlobalValues.size())
1545 1 : return error(Twine("use of undefined global value '@") + Twine(GVIdx) +
1546 1 : "'");
1547 5 : GV = PFS.IRSlots.GlobalValues[GVIdx];
1548 5 : break;
1549 : }
1550 0 : default:
1551 0 : llvm_unreachable("The current token should be a global value");
1552 : }
1553 : return false;
1554 : }
1555 :
1556 807 : bool MIParser::parseGlobalAddressOperand(MachineOperand &Dest) {
1557 807 : GlobalValue *GV = nullptr;
1558 807 : if (parseGlobalValue(GV))
1559 : return true;
1560 805 : lex();
1561 805 : Dest = MachineOperand::CreateGA(GV, /*Offset=*/0);
1562 : if (parseOperandsOffset(Dest))
1563 2 : return true;
1564 : return false;
1565 : }
1566 :
1567 45 : bool MIParser::parseConstantPoolIndexOperand(MachineOperand &Dest) {
1568 : assert(Token.is(MIToken::ConstantPoolItem));
1569 : unsigned ID;
1570 45 : if (getUnsigned(ID))
1571 : return true;
1572 45 : auto ConstantInfo = PFS.ConstantPoolSlots.find(ID);
1573 90 : if (ConstantInfo == PFS.ConstantPoolSlots.end())
1574 2 : return error("use of undefined constant '%const." + Twine(ID) + "'");
1575 44 : lex();
1576 44 : Dest = MachineOperand::CreateCPI(ID, /*Offset=*/0);
1577 : if (parseOperandsOffset(Dest))
1578 0 : return true;
1579 : return false;
1580 : }
1581 :
1582 14 : bool MIParser::parseJumpTableIndexOperand(MachineOperand &Dest) {
1583 : assert(Token.is(MIToken::JumpTableIndex));
1584 : unsigned ID;
1585 14 : if (getUnsigned(ID))
1586 : return true;
1587 14 : auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
1588 28 : if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
1589 2 : return error("use of undefined jump table '%jump-table." + Twine(ID) + "'");
1590 13 : lex();
1591 13 : Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
1592 13 : return false;
1593 : }
1594 :
1595 227 : bool MIParser::parseExternalSymbolOperand(MachineOperand &Dest) {
1596 : assert(Token.is(MIToken::ExternalSymbol));
1597 227 : const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
1598 227 : lex();
1599 227 : Dest = MachineOperand::CreateES(Symbol);
1600 : if (parseOperandsOffset(Dest))
1601 0 : return true;
1602 : return false;
1603 : }
1604 :
1605 8 : bool MIParser::parseMCSymbolOperand(MachineOperand &Dest) {
1606 : assert(Token.is(MIToken::MCSymbol));
1607 16 : MCSymbol *Symbol = getOrCreateMCSymbol(Token.stringValue());
1608 8 : lex();
1609 8 : Dest = MachineOperand::CreateMCSymbol(Symbol);
1610 : if (parseOperandsOffset(Dest))
1611 0 : return true;
1612 : return false;
1613 : }
1614 :
1615 139 : bool MIParser::parseSubRegisterIndexOperand(MachineOperand &Dest) {
1616 : assert(Token.is(MIToken::SubRegisterIndex));
1617 139 : StringRef Name = Token.stringValue();
1618 139 : unsigned SubRegIndex = getSubRegIndex(Token.stringValue());
1619 139 : if (SubRegIndex == 0)
1620 1 : return error(Twine("unknown subregister index '") + Name + "'");
1621 138 : lex();
1622 138 : Dest = MachineOperand::CreateImm(SubRegIndex);
1623 138 : return false;
1624 : }
1625 :
1626 1179 : bool MIParser::parseMDNode(MDNode *&Node) {
1627 : assert(Token.is(MIToken::exclaim));
1628 :
1629 : auto Loc = Token.location();
1630 1179 : lex();
1631 1179 : if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1632 1 : return error("expected metadata id after '!'");
1633 : unsigned ID;
1634 1178 : if (getUnsigned(ID))
1635 : return true;
1636 1178 : auto NodeInfo = PFS.IRSlots.MetadataNodes.find(ID);
1637 1178 : if (NodeInfo == PFS.IRSlots.MetadataNodes.end())
1638 2 : return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
1639 1177 : lex();
1640 1177 : Node = NodeInfo->second.get();
1641 1177 : return false;
1642 : }
1643 :
1644 69 : bool MIParser::parseDIExpression(MDNode *&Expr) {
1645 : assert(Token.is(MIToken::md_diexpr));
1646 69 : lex();
1647 :
1648 : // FIXME: Share this parsing with the IL parser.
1649 : SmallVector<uint64_t, 8> Elements;
1650 :
1651 69 : if (expectAndConsume(MIToken::lparen))
1652 : return true;
1653 :
1654 69 : if (Token.isNot(MIToken::rparen)) {
1655 : do {
1656 12 : if (Token.is(MIToken::Identifier)) {
1657 8 : if (unsigned Op = dwarf::getOperationEncoding(Token.stringValue())) {
1658 8 : lex();
1659 8 : Elements.push_back(Op);
1660 8 : continue;
1661 : }
1662 0 : return error(Twine("invalid DWARF op '") + Token.stringValue() + "'");
1663 : }
1664 :
1665 4 : if (Token.isNot(MIToken::IntegerLiteral) ||
1666 4 : Token.integerValue().isSigned())
1667 0 : return error("expected unsigned integer");
1668 :
1669 : auto &U = Token.integerValue();
1670 4 : if (U.ugt(UINT64_MAX))
1671 0 : return error("element too large, limit is " + Twine(UINT64_MAX));
1672 4 : Elements.push_back(U.getZExtValue());
1673 4 : lex();
1674 :
1675 : } while (consumeIfPresent(MIToken::comma));
1676 : }
1677 :
1678 69 : if (expectAndConsume(MIToken::rparen))
1679 : return true;
1680 :
1681 69 : Expr = DIExpression::get(MF.getFunction().getContext(), Elements);
1682 69 : return false;
1683 : }
1684 :
1685 486 : bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
1686 486 : MDNode *Node = nullptr;
1687 486 : if (Token.is(MIToken::exclaim)) {
1688 419 : if (parseMDNode(Node))
1689 : return true;
1690 67 : } else if (Token.is(MIToken::md_diexpr)) {
1691 67 : if (parseDIExpression(Node))
1692 : return true;
1693 : }
1694 484 : Dest = MachineOperand::CreateMetadata(Node);
1695 484 : return false;
1696 : }
1697 :
1698 191 : bool MIParser::parseCFIOffset(int &Offset) {
1699 191 : if (Token.isNot(MIToken::IntegerLiteral))
1700 1 : return error("expected a cfi offset");
1701 190 : if (Token.integerValue().getMinSignedBits() > 32)
1702 1 : return error("expected a 32 bit integer (the cfi offset is too large)");
1703 189 : Offset = (int)Token.integerValue().getExtValue();
1704 189 : lex();
1705 189 : return false;
1706 : }
1707 :
1708 140 : bool MIParser::parseCFIRegister(unsigned &Reg) {
1709 140 : if (Token.isNot(MIToken::NamedRegister))
1710 1 : return error("expected a cfi register");
1711 : unsigned LLVMReg;
1712 139 : if (parseNamedRegister(LLVMReg))
1713 : return true;
1714 139 : const auto *TRI = MF.getSubtarget().getRegisterInfo();
1715 : assert(TRI && "Expected target register info");
1716 139 : int DwarfReg = TRI->getDwarfRegNum(LLVMReg, true);
1717 139 : if (DwarfReg < 0)
1718 0 : return error("invalid DWARF register");
1719 139 : Reg = (unsigned)DwarfReg;
1720 139 : lex();
1721 139 : return false;
1722 : }
1723 :
1724 1 : bool MIParser::parseCFIEscapeValues(std::string &Values) {
1725 : do {
1726 3 : if (Token.isNot(MIToken::HexLiteral))
1727 0 : return error("expected a hexadecimal literal");
1728 : unsigned Value;
1729 3 : if (getUnsigned(Value))
1730 : return true;
1731 3 : if (Value > UINT8_MAX)
1732 0 : return error("expected a 8-bit integer (too large)");
1733 3 : Values.push_back(static_cast<uint8_t>(Value));
1734 3 : lex();
1735 : } while (consumeIfPresent(MIToken::comma));
1736 : return false;
1737 : }
1738 :
1739 218 : bool MIParser::parseCFIOperand(MachineOperand &Dest) {
1740 218 : auto Kind = Token.kind();
1741 218 : lex();
1742 : int Offset;
1743 : unsigned Reg;
1744 : unsigned CFIIndex;
1745 218 : switch (Kind) {
1746 3 : case MIToken::kw_cfi_same_value:
1747 3 : if (parseCFIRegister(Reg))
1748 : return true;
1749 3 : CFIIndex = MF.addFrameInst(MCCFIInstruction::createSameValue(nullptr, Reg));
1750 3 : break;
1751 114 : case MIToken::kw_cfi_offset:
1752 226 : if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1753 112 : parseCFIOffset(Offset))
1754 2 : return true;
1755 : CFIIndex =
1756 112 : MF.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
1757 112 : break;
1758 1 : case MIToken::kw_cfi_rel_offset:
1759 2 : if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1760 1 : parseCFIOffset(Offset))
1761 0 : return true;
1762 1 : CFIIndex = MF.addFrameInst(
1763 1 : MCCFIInstruction::createRelOffset(nullptr, Reg, Offset));
1764 1 : break;
1765 13 : case MIToken::kw_cfi_def_cfa_register:
1766 13 : if (parseCFIRegister(Reg))
1767 : return true;
1768 : CFIIndex =
1769 13 : MF.addFrameInst(MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
1770 13 : break;
1771 73 : case MIToken::kw_cfi_def_cfa_offset:
1772 73 : if (parseCFIOffset(Offset))
1773 : return true;
1774 : // NB: MCCFIInstruction::createDefCfaOffset negates the offset.
1775 71 : CFIIndex = MF.addFrameInst(
1776 71 : MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
1777 71 : break;
1778 2 : case MIToken::kw_cfi_adjust_cfa_offset:
1779 2 : if (parseCFIOffset(Offset))
1780 : return true;
1781 2 : CFIIndex = MF.addFrameInst(
1782 2 : MCCFIInstruction::createAdjustCfaOffset(nullptr, Offset));
1783 2 : break;
1784 3 : case MIToken::kw_cfi_def_cfa:
1785 6 : if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1786 3 : parseCFIOffset(Offset))
1787 0 : return true;
1788 : // NB: MCCFIInstruction::createDefCfa negates the offset.
1789 : CFIIndex =
1790 3 : MF.addFrameInst(MCCFIInstruction::createDefCfa(nullptr, Reg, -Offset));
1791 3 : break;
1792 1 : case MIToken::kw_cfi_remember_state:
1793 1 : CFIIndex = MF.addFrameInst(MCCFIInstruction::createRememberState(nullptr));
1794 1 : break;
1795 3 : case MIToken::kw_cfi_restore:
1796 3 : if (parseCFIRegister(Reg))
1797 : return true;
1798 3 : CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestore(nullptr, Reg));
1799 3 : break;
1800 1 : case MIToken::kw_cfi_restore_state:
1801 1 : CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestoreState(nullptr));
1802 1 : break;
1803 1 : case MIToken::kw_cfi_undefined:
1804 1 : if (parseCFIRegister(Reg))
1805 : return true;
1806 1 : CFIIndex = MF.addFrameInst(MCCFIInstruction::createUndefined(nullptr, Reg));
1807 1 : break;
1808 1 : case MIToken::kw_cfi_register: {
1809 : unsigned Reg2;
1810 2 : if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1811 1 : parseCFIRegister(Reg2))
1812 0 : return true;
1813 :
1814 : CFIIndex =
1815 1 : MF.addFrameInst(MCCFIInstruction::createRegister(nullptr, Reg, Reg2));
1816 1 : break;
1817 : }
1818 1 : case MIToken::kw_cfi_window_save:
1819 1 : CFIIndex = MF.addFrameInst(MCCFIInstruction::createWindowSave(nullptr));
1820 1 : break;
1821 : case MIToken::kw_cfi_escape: {
1822 : std::string Values;
1823 1 : if (parseCFIEscapeValues(Values))
1824 : return true;
1825 2 : CFIIndex = MF.addFrameInst(MCCFIInstruction::createEscape(nullptr, Values));
1826 : break;
1827 : }
1828 0 : default:
1829 : // TODO: Parse the other CFI operands.
1830 0 : llvm_unreachable("The current token should be a cfi operand");
1831 : }
1832 214 : Dest = MachineOperand::CreateCFIIndex(CFIIndex);
1833 214 : return false;
1834 : }
1835 :
1836 1118 : bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
1837 1118 : switch (Token.kind()) {
1838 : case MIToken::NamedIRBlock: {
1839 15 : BB = dyn_cast_or_null<BasicBlock>(
1840 : F.getValueSymbolTable()->lookup(Token.stringValue()));
1841 15 : if (!BB)
1842 2 : return error(Twine("use of undefined IR block '") + Token.range() + "'");
1843 : break;
1844 : }
1845 1103 : case MIToken::IRBlock: {
1846 1103 : unsigned SlotNumber = 0;
1847 1103 : if (getUnsigned(SlotNumber))
1848 2 : return true;
1849 1103 : BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
1850 1103 : if (!BB)
1851 2 : return error(Twine("use of undefined IR block '%ir-block.") +
1852 4 : Twine(SlotNumber) + "'");
1853 1101 : break;
1854 : }
1855 0 : default:
1856 0 : llvm_unreachable("The current token should be an IR block reference");
1857 : }
1858 : return false;
1859 : }
1860 :
1861 21 : bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
1862 : assert(Token.is(MIToken::kw_blockaddress));
1863 21 : lex();
1864 21 : if (expectAndConsume(MIToken::lparen))
1865 : return true;
1866 21 : if (Token.isNot(MIToken::GlobalValue) &&
1867 : Token.isNot(MIToken::NamedGlobalValue))
1868 1 : return error("expected a global value");
1869 20 : GlobalValue *GV = nullptr;
1870 20 : if (parseGlobalValue(GV))
1871 : return true;
1872 20 : auto *F = dyn_cast<Function>(GV);
1873 : if (!F)
1874 1 : return error("expected an IR function reference");
1875 19 : lex();
1876 19 : if (expectAndConsume(MIToken::comma))
1877 : return true;
1878 19 : BasicBlock *BB = nullptr;
1879 19 : if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
1880 1 : return error("expected an IR block reference");
1881 18 : if (parseIRBlock(BB, *F))
1882 : return true;
1883 16 : lex();
1884 16 : if (expectAndConsume(MIToken::rparen))
1885 : return true;
1886 16 : Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
1887 : if (parseOperandsOffset(Dest))
1888 0 : return true;
1889 : return false;
1890 : }
1891 :
1892 70 : bool MIParser::parseIntrinsicOperand(MachineOperand &Dest) {
1893 : assert(Token.is(MIToken::kw_intrinsic));
1894 70 : lex();
1895 70 : if (expectAndConsume(MIToken::lparen))
1896 0 : return error("expected syntax intrinsic(@llvm.whatever)");
1897 :
1898 70 : if (Token.isNot(MIToken::NamedGlobalValue))
1899 0 : return error("expected syntax intrinsic(@llvm.whatever)");
1900 :
1901 : std::string Name = Token.stringValue();
1902 70 : lex();
1903 :
1904 70 : if (expectAndConsume(MIToken::rparen))
1905 0 : return error("expected ')' to terminate intrinsic name");
1906 :
1907 : // Find out what intrinsic we're dealing with, first try the global namespace
1908 : // and then the target's private intrinsics if that fails.
1909 70 : const TargetIntrinsicInfo *TII = MF.getTarget().getIntrinsicInfo();
1910 70 : Intrinsic::ID ID = Function::lookupIntrinsicID(Name);
1911 70 : if (ID == Intrinsic::not_intrinsic && TII)
1912 : ID = static_cast<Intrinsic::ID>(TII->lookupName(Name));
1913 :
1914 70 : if (ID == Intrinsic::not_intrinsic)
1915 0 : return error("unknown intrinsic name");
1916 70 : Dest = MachineOperand::CreateIntrinsicID(ID);
1917 :
1918 70 : return false;
1919 : }
1920 :
1921 408 : bool MIParser::parsePredicateOperand(MachineOperand &Dest) {
1922 : assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred));
1923 408 : bool IsFloat = Token.is(MIToken::kw_floatpred);
1924 408 : lex();
1925 :
1926 408 : if (expectAndConsume(MIToken::lparen))
1927 0 : return error("expected syntax intpred(whatever) or floatpred(whatever");
1928 :
1929 408 : if (Token.isNot(MIToken::Identifier))
1930 0 : return error("whatever");
1931 :
1932 : CmpInst::Predicate Pred;
1933 408 : if (IsFloat) {
1934 0 : Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1935 : .Case("false", CmpInst::FCMP_FALSE)
1936 : .Case("oeq", CmpInst::FCMP_OEQ)
1937 : .Case("ogt", CmpInst::FCMP_OGT)
1938 : .Case("oge", CmpInst::FCMP_OGE)
1939 : .Case("olt", CmpInst::FCMP_OLT)
1940 : .Case("ole", CmpInst::FCMP_OLE)
1941 : .Case("one", CmpInst::FCMP_ONE)
1942 : .Case("ord", CmpInst::FCMP_ORD)
1943 : .Case("uno", CmpInst::FCMP_UNO)
1944 : .Case("ueq", CmpInst::FCMP_UEQ)
1945 : .Case("ugt", CmpInst::FCMP_UGT)
1946 : .Case("uge", CmpInst::FCMP_UGE)
1947 : .Case("ult", CmpInst::FCMP_ULT)
1948 : .Case("ule", CmpInst::FCMP_ULE)
1949 : .Case("une", CmpInst::FCMP_UNE)
1950 : .Case("true", CmpInst::FCMP_TRUE)
1951 : .Default(CmpInst::BAD_FCMP_PREDICATE);
1952 261 : if (!CmpInst::isFPPredicate(Pred))
1953 0 : return error("invalid floating-point predicate");
1954 : } else {
1955 147 : Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1956 : .Case("eq", CmpInst::ICMP_EQ)
1957 : .Case("ne", CmpInst::ICMP_NE)
1958 : .Case("sgt", CmpInst::ICMP_SGT)
1959 : .Case("sge", CmpInst::ICMP_SGE)
1960 : .Case("slt", CmpInst::ICMP_SLT)
1961 : .Case("sle", CmpInst::ICMP_SLE)
1962 : .Case("ugt", CmpInst::ICMP_UGT)
1963 : .Case("uge", CmpInst::ICMP_UGE)
1964 : .Case("ult", CmpInst::ICMP_ULT)
1965 : .Case("ule", CmpInst::ICMP_ULE)
1966 : .Default(CmpInst::BAD_ICMP_PREDICATE);
1967 147 : if (!CmpInst::isIntPredicate(Pred))
1968 0 : return error("invalid integer predicate");
1969 : }
1970 :
1971 408 : lex();
1972 408 : Dest = MachineOperand::CreatePredicate(Pred);
1973 408 : if (expectAndConsume(MIToken::rparen))
1974 0 : return error("predicate should be terminated by ')'.");
1975 :
1976 : return false;
1977 : }
1978 :
1979 4 : bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
1980 : assert(Token.is(MIToken::kw_target_index));
1981 4 : lex();
1982 4 : if (expectAndConsume(MIToken::lparen))
1983 : return true;
1984 4 : if (Token.isNot(MIToken::Identifier))
1985 1 : return error("expected the name of the target index");
1986 3 : int Index = 0;
1987 3 : if (getTargetIndex(Token.stringValue(), Index))
1988 2 : return error("use of undefined target index '" + Token.stringValue() + "'");
1989 2 : lex();
1990 2 : if (expectAndConsume(MIToken::rparen))
1991 : return true;
1992 2 : Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
1993 : if (parseOperandsOffset(Dest))
1994 0 : return true;
1995 : return false;
1996 : }
1997 :
1998 1 : bool MIParser::parseCustomRegisterMaskOperand(MachineOperand &Dest) {
1999 : assert(Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask");
2000 1 : lex();
2001 1 : if (expectAndConsume(MIToken::lparen))
2002 : return true;
2003 :
2004 1 : uint32_t *Mask = MF.allocateRegMask();
2005 : while (true) {
2006 62 : if (Token.isNot(MIToken::NamedRegister))
2007 0 : return error("expected a named register");
2008 : unsigned Reg;
2009 62 : if (parseNamedRegister(Reg))
2010 : return true;
2011 62 : lex();
2012 62 : Mask[Reg / 32] |= 1U << (Reg % 32);
2013 : // TODO: Report an error if the same register is used more than once.
2014 62 : if (Token.isNot(MIToken::comma))
2015 : break;
2016 61 : lex();
2017 61 : }
2018 :
2019 1 : if (expectAndConsume(MIToken::rparen))
2020 : return true;
2021 1 : Dest = MachineOperand::CreateRegMask(Mask);
2022 1 : return false;
2023 : }
2024 :
2025 1 : bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
2026 : assert(Token.is(MIToken::kw_liveout));
2027 1 : uint32_t *Mask = MF.allocateRegMask();
2028 1 : lex();
2029 1 : if (expectAndConsume(MIToken::lparen))
2030 : return true;
2031 : while (true) {
2032 4 : if (Token.isNot(MIToken::NamedRegister))
2033 0 : return error("expected a named register");
2034 : unsigned Reg;
2035 4 : if (parseNamedRegister(Reg))
2036 : return true;
2037 4 : lex();
2038 4 : Mask[Reg / 32] |= 1U << (Reg % 32);
2039 : // TODO: Report an error if the same register is used more than once.
2040 4 : if (Token.isNot(MIToken::comma))
2041 : break;
2042 3 : lex();
2043 3 : }
2044 1 : if (expectAndConsume(MIToken::rparen))
2045 : return true;
2046 1 : Dest = MachineOperand::CreateRegLiveOut(Mask);
2047 1 : return false;
2048 : }
2049 :
2050 74715 : bool MIParser::parseMachineOperand(MachineOperand &Dest,
2051 : Optional<unsigned> &TiedDefIdx) {
2052 74715 : switch (Token.kind()) {
2053 52276 : case MIToken::kw_implicit:
2054 : case MIToken::kw_implicit_define:
2055 : case MIToken::kw_def:
2056 : case MIToken::kw_dead:
2057 : case MIToken::kw_killed:
2058 : case MIToken::kw_undef:
2059 : case MIToken::kw_internal:
2060 : case MIToken::kw_early_clobber:
2061 : case MIToken::kw_debug_use:
2062 : case MIToken::kw_renamable:
2063 : case MIToken::underscore:
2064 : case MIToken::NamedRegister:
2065 : case MIToken::VirtualRegister:
2066 : case MIToken::NamedVirtualRegister:
2067 52276 : return parseRegisterOperand(Dest, TiedDefIdx);
2068 17282 : case MIToken::IntegerLiteral:
2069 17282 : return parseImmediateOperand(Dest);
2070 54 : case MIToken::kw_half:
2071 : case MIToken::kw_float:
2072 : case MIToken::kw_double:
2073 : case MIToken::kw_x86_fp80:
2074 : case MIToken::kw_fp128:
2075 : case MIToken::kw_ppc_fp128:
2076 54 : return parseFPImmediateOperand(Dest);
2077 1636 : case MIToken::MachineBasicBlock:
2078 1636 : return parseMBBOperand(Dest);
2079 : case MIToken::StackObject:
2080 272 : return parseStackObjectOperand(Dest);
2081 : case MIToken::FixedStackObject:
2082 73 : return parseFixedStackObjectOperand(Dest);
2083 807 : case MIToken::GlobalValue:
2084 : case MIToken::NamedGlobalValue:
2085 807 : return parseGlobalAddressOperand(Dest);
2086 45 : case MIToken::ConstantPoolItem:
2087 45 : return parseConstantPoolIndexOperand(Dest);
2088 14 : case MIToken::JumpTableIndex:
2089 14 : return parseJumpTableIndexOperand(Dest);
2090 227 : case MIToken::ExternalSymbol:
2091 227 : return parseExternalSymbolOperand(Dest);
2092 8 : case MIToken::MCSymbol:
2093 8 : return parseMCSymbolOperand(Dest);
2094 139 : case MIToken::SubRegisterIndex:
2095 139 : return parseSubRegisterIndexOperand(Dest);
2096 486 : case MIToken::md_diexpr:
2097 : case MIToken::exclaim:
2098 486 : return parseMetadataOperand(Dest);
2099 218 : case MIToken::kw_cfi_same_value:
2100 : case MIToken::kw_cfi_offset:
2101 : case MIToken::kw_cfi_rel_offset:
2102 : case MIToken::kw_cfi_def_cfa_register:
2103 : case MIToken::kw_cfi_def_cfa_offset:
2104 : case MIToken::kw_cfi_adjust_cfa_offset:
2105 : case MIToken::kw_cfi_escape:
2106 : case MIToken::kw_cfi_def_cfa:
2107 : case MIToken::kw_cfi_register:
2108 : case MIToken::kw_cfi_remember_state:
2109 : case MIToken::kw_cfi_restore:
2110 : case MIToken::kw_cfi_restore_state:
2111 : case MIToken::kw_cfi_undefined:
2112 : case MIToken::kw_cfi_window_save:
2113 218 : return parseCFIOperand(Dest);
2114 21 : case MIToken::kw_blockaddress:
2115 21 : return parseBlockAddressOperand(Dest);
2116 70 : case MIToken::kw_intrinsic:
2117 70 : return parseIntrinsicOperand(Dest);
2118 4 : case MIToken::kw_target_index:
2119 4 : return parseTargetIndexOperand(Dest);
2120 1 : case MIToken::kw_liveout:
2121 1 : return parseLiveoutRegisterMaskOperand(Dest);
2122 408 : case MIToken::kw_floatpred:
2123 : case MIToken::kw_intpred:
2124 408 : return parsePredicateOperand(Dest);
2125 : case MIToken::Error:
2126 : return true;
2127 673 : case MIToken::Identifier:
2128 673 : if (const auto *RegMask = getRegMask(Token.stringValue())) {
2129 219 : Dest = MachineOperand::CreateRegMask(RegMask);
2130 219 : lex();
2131 : break;
2132 : } else if (Token.stringValue() == "CustomRegMask") {
2133 1 : return parseCustomRegisterMaskOperand(Dest);
2134 : } else
2135 453 : return parseTypedImmediateOperand(Dest);
2136 : default:
2137 : // FIXME: Parse the MCSymbol machine operand.
2138 1 : return error("expected a machine operand");
2139 : }
2140 219 : return false;
2141 : }
2142 :
2143 74719 : bool MIParser::parseMachineOperandAndTargetFlags(
2144 : MachineOperand &Dest, Optional<unsigned> &TiedDefIdx) {
2145 74719 : unsigned TF = 0;
2146 : bool HasTargetFlags = false;
2147 74719 : if (Token.is(MIToken::kw_target_flags)) {
2148 : HasTargetFlags = true;
2149 436 : lex();
2150 436 : if (expectAndConsume(MIToken::lparen))
2151 : return true;
2152 436 : if (Token.isNot(MIToken::Identifier))
2153 1 : return error("expected the name of the target flag");
2154 435 : if (getDirectTargetFlag(Token.stringValue(), TF)) {
2155 4 : if (getBitmaskTargetFlag(Token.stringValue(), TF))
2156 1 : return error("use of undefined target flag '" + Token.stringValue() +
2157 1 : "'");
2158 : }
2159 434 : lex();
2160 464 : while (Token.is(MIToken::comma)) {
2161 32 : lex();
2162 32 : if (Token.isNot(MIToken::Identifier))
2163 1 : return error("expected the name of the target flag");
2164 31 : unsigned BitFlag = 0;
2165 31 : if (getBitmaskTargetFlag(Token.stringValue(), BitFlag))
2166 1 : return error("use of undefined target flag '" + Token.stringValue() +
2167 1 : "'");
2168 : // TODO: Report an error when using a duplicate bit target flag.
2169 30 : TF |= BitFlag;
2170 30 : lex();
2171 : }
2172 432 : if (expectAndConsume(MIToken::rparen))
2173 : return true;
2174 : }
2175 : auto Loc = Token.location();
2176 74715 : if (parseMachineOperand(Dest, TiedDefIdx))
2177 : return true;
2178 74676 : if (!HasTargetFlags)
2179 : return false;
2180 432 : if (Dest.isReg())
2181 1 : return error(Loc, "register operands can't have target flags");
2182 431 : Dest.setTargetFlags(TF);
2183 431 : return false;
2184 : }
2185 :
2186 3076 : bool MIParser::parseOffset(int64_t &Offset) {
2187 3076 : if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
2188 : return false;
2189 86 : StringRef Sign = Token.range();
2190 : bool IsNegative = Token.is(MIToken::minus);
2191 86 : lex();
2192 86 : if (Token.isNot(MIToken::IntegerLiteral))
2193 1 : return error("expected an integer literal after '" + Sign + "'");
2194 85 : if (Token.integerValue().getMinSignedBits() > 64)
2195 1 : return error("expected 64-bit integer (too large)");
2196 84 : Offset = Token.integerValue().getExtValue();
2197 84 : if (IsNegative)
2198 4 : Offset = -Offset;
2199 84 : lex();
2200 84 : return false;
2201 : }
2202 :
2203 347 : bool MIParser::parseAlignment(unsigned &Alignment) {
2204 : assert(Token.is(MIToken::kw_align));
2205 347 : lex();
2206 347 : if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
2207 2 : return error("expected an integer literal after 'align'");
2208 345 : if (getUnsigned(Alignment))
2209 : return true;
2210 345 : lex();
2211 345 : return false;
2212 : }
2213 :
2214 233 : bool MIParser::parseAddrspace(unsigned &Addrspace) {
2215 : assert(Token.is(MIToken::kw_addrspace));
2216 233 : lex();
2217 233 : if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
2218 0 : return error("expected an integer literal after 'addrspace'");
2219 233 : if (getUnsigned(Addrspace))
2220 : return true;
2221 233 : lex();
2222 233 : return false;
2223 : }
2224 :
2225 : bool MIParser::parseOperandsOffset(MachineOperand &Op) {
2226 1102 : int64_t Offset = 0;
2227 1102 : if (parseOffset(Offset))
2228 : return true;
2229 1100 : Op.setOffset(Offset);
2230 : return false;
2231 : }
2232 :
2233 1659 : bool MIParser::parseIRValue(const Value *&V) {
2234 1659 : switch (Token.kind()) {
2235 924 : case MIToken::NamedIRValue: {
2236 924 : V = MF.getFunction().getValueSymbolTable()->lookup(Token.stringValue());
2237 924 : break;
2238 : }
2239 105 : case MIToken::IRValue: {
2240 105 : unsigned SlotNumber = 0;
2241 105 : if (getUnsigned(SlotNumber))
2242 0 : return true;
2243 105 : V = getIRValue(SlotNumber);
2244 105 : break;
2245 : }
2246 133 : case MIToken::NamedGlobalValue:
2247 : case MIToken::GlobalValue: {
2248 133 : GlobalValue *GV = nullptr;
2249 133 : if (parseGlobalValue(GV))
2250 0 : return true;
2251 133 : V = GV;
2252 133 : break;
2253 : }
2254 497 : case MIToken::QuotedIRValue: {
2255 497 : const Constant *C = nullptr;
2256 497 : if (parseIRConstant(Token.location(), Token.stringValue(), C))
2257 0 : return true;
2258 497 : V = C;
2259 497 : break;
2260 : }
2261 0 : default:
2262 0 : llvm_unreachable("The current token should be an IR block reference");
2263 : }
2264 1659 : if (!V)
2265 2 : return error(Twine("use of undefined IR value '") + Token.range() + "'");
2266 : return false;
2267 : }
2268 :
2269 2420 : bool MIParser::getUint64(uint64_t &Result) {
2270 2420 : if (Token.hasIntegerValue()) {
2271 4840 : if (Token.integerValue().getActiveBits() > 64)
2272 1 : return error("expected 64-bit integer (too large)");
2273 2419 : Result = Token.integerValue().getZExtValue();
2274 2419 : return false;
2275 : }
2276 0 : if (Token.is(MIToken::HexLiteral)) {
2277 : APInt A;
2278 0 : if (getHexUint(A))
2279 : return true;
2280 0 : if (A.getBitWidth() > 64)
2281 0 : return error("expected 64-bit integer (too large)");
2282 0 : Result = A.getZExtValue();
2283 0 : return false;
2284 : }
2285 : return true;
2286 : }
2287 :
2288 1093 : bool MIParser::getHexUint(APInt &Result) {
2289 : assert(Token.is(MIToken::HexLiteral));
2290 1093 : StringRef S = Token.range();
2291 : assert(S[0] == '0' && tolower(S[1]) == 'x');
2292 : // This could be a floating point literal with a special prefix.
2293 1093 : if (!isxdigit(S[2]))
2294 : return true;
2295 1093 : StringRef V = S.substr(2);
2296 1093 : APInt A(V.size()*4, V, 16);
2297 :
2298 : // If A is 0, then A.getActiveBits() is 0. This isn't a valid bitwidth. Make
2299 : // sure it isn't the case before constructing result.
2300 1093 : unsigned NumBits = (A == 0) ? 32 : A.getActiveBits();
2301 2186 : Result = APInt(NumBits, ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
2302 : return false;
2303 : }
2304 :
2305 1121 : bool MIParser::parseMemoryOperandFlag(MachineMemOperand::Flags &Flags) {
2306 1121 : const auto OldFlags = Flags;
2307 1121 : switch (Token.kind()) {
2308 : case MIToken::kw_volatile:
2309 : Flags |= MachineMemOperand::MOVolatile;
2310 : break;
2311 : case MIToken::kw_non_temporal:
2312 : Flags |= MachineMemOperand::MONonTemporal;
2313 : break;
2314 : case MIToken::kw_dereferenceable:
2315 : Flags |= MachineMemOperand::MODereferenceable;
2316 : break;
2317 : case MIToken::kw_invariant:
2318 : Flags |= MachineMemOperand::MOInvariant;
2319 : break;
2320 24 : case MIToken::StringConstant: {
2321 : MachineMemOperand::Flags TF;
2322 24 : if (getMMOTargetFlag(Token.stringValue(), TF))
2323 1 : return error("use of undefined target MMO flag '" + Token.stringValue() +
2324 1 : "'");
2325 23 : Flags |= TF;
2326 23 : break;
2327 : }
2328 0 : default:
2329 0 : llvm_unreachable("The current token should be a memory operand flag");
2330 : }
2331 1120 : if (OldFlags == Flags)
2332 : // We know that the same flag is specified more than once when the flags
2333 : // weren't modified.
2334 2 : return error("duplicate '" + Token.stringValue() + "' memory operand flag");
2335 1119 : lex();
2336 1119 : return false;
2337 : }
2338 :
2339 318 : bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
2340 318 : switch (Token.kind()) {
2341 11 : case MIToken::kw_stack:
2342 22 : PSV = MF.getPSVManager().getStack();
2343 11 : break;
2344 13 : case MIToken::kw_got:
2345 26 : PSV = MF.getPSVManager().getGOT();
2346 13 : break;
2347 5 : case MIToken::kw_jump_table:
2348 10 : PSV = MF.getPSVManager().getJumpTable();
2349 5 : break;
2350 27 : case MIToken::kw_constant_pool:
2351 54 : PSV = MF.getPSVManager().getConstantPool();
2352 27 : break;
2353 84 : case MIToken::FixedStackObject: {
2354 : int FI;
2355 84 : if (parseFixedStackFrameIndex(FI))
2356 : return true;
2357 168 : PSV = MF.getPSVManager().getFixedStack(FI);
2358 : // The token was already consumed, so use return here instead of break.
2359 84 : return false;
2360 : }
2361 162 : case MIToken::StackObject: {
2362 : int FI;
2363 162 : if (parseStackFrameIndex(FI))
2364 : return true;
2365 324 : PSV = MF.getPSVManager().getFixedStack(FI);
2366 : // The token was already consumed, so use return here instead of break.
2367 162 : return false;
2368 : }
2369 16 : case MIToken::kw_call_entry:
2370 16 : lex();
2371 16 : switch (Token.kind()) {
2372 9 : case MIToken::GlobalValue:
2373 : case MIToken::NamedGlobalValue: {
2374 9 : GlobalValue *GV = nullptr;
2375 9 : if (parseGlobalValue(GV))
2376 0 : return true;
2377 18 : PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
2378 9 : break;
2379 : }
2380 6 : case MIToken::ExternalSymbol:
2381 12 : PSV = MF.getPSVManager().getExternalSymbolCallEntry(
2382 : MF.createExternalSymbolName(Token.stringValue()));
2383 6 : break;
2384 : default:
2385 1 : return error(
2386 : "expected a global value or an external symbol after 'call-entry'");
2387 : }
2388 : break;
2389 0 : default:
2390 0 : llvm_unreachable("The current token should be pseudo source value");
2391 : }
2392 71 : lex();
2393 71 : return false;
2394 : }
2395 :
2396 1978 : bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
2397 1951 : if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
2398 1927 : Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
2399 3816 : Token.is(MIToken::FixedStackObject) || Token.is(MIToken::StackObject) ||
2400 : Token.is(MIToken::kw_call_entry)) {
2401 318 : const PseudoSourceValue *PSV = nullptr;
2402 318 : if (parseMemoryPseudoSourceValue(PSV))
2403 : return true;
2404 317 : int64_t Offset = 0;
2405 317 : if (parseOffset(Offset))
2406 : return true;
2407 317 : Dest = MachinePointerInfo(PSV, Offset);
2408 317 : return false;
2409 : }
2410 736 : if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue) &&
2411 630 : Token.isNot(MIToken::GlobalValue) &&
2412 2158 : Token.isNot(MIToken::NamedGlobalValue) &&
2413 : Token.isNot(MIToken::QuotedIRValue))
2414 1 : return error("expected an IR value reference");
2415 1659 : const Value *V = nullptr;
2416 1659 : if (parseIRValue(V))
2417 : return true;
2418 3316 : if (!V->getType()->isPointerTy())
2419 1 : return error("expected a pointer IR value");
2420 1657 : lex();
2421 1657 : int64_t Offset = 0;
2422 1657 : if (parseOffset(Offset))
2423 : return true;
2424 1657 : Dest = MachinePointerInfo(V, Offset);
2425 1657 : return false;
2426 : }
2427 :
2428 2424 : bool MIParser::parseOptionalScope(LLVMContext &Context,
2429 : SyncScope::ID &SSID) {
2430 2424 : SSID = SyncScope::System;
2431 2424 : if (Token.is(MIToken::Identifier) && Token.stringValue() == "syncscope") {
2432 85 : lex();
2433 85 : if (expectAndConsume(MIToken::lparen))
2434 0 : return error("expected '(' in syncscope");
2435 :
2436 : std::string SSN;
2437 85 : if (parseStringConstant(SSN))
2438 : return true;
2439 :
2440 85 : SSID = Context.getOrInsertSyncScopeID(SSN);
2441 85 : if (expectAndConsume(MIToken::rparen))
2442 0 : return error("expected ')' in syncscope");
2443 : }
2444 :
2445 : return false;
2446 : }
2447 :
2448 4847 : bool MIParser::parseOptionalAtomicOrdering(AtomicOrdering &Order) {
2449 4847 : Order = AtomicOrdering::NotAtomic;
2450 4847 : if (Token.isNot(MIToken::Identifier))
2451 : return false;
2452 :
2453 135 : Order = StringSwitch<AtomicOrdering>(Token.stringValue())
2454 : .Case("unordered", AtomicOrdering::Unordered)
2455 : .Case("monotonic", AtomicOrdering::Monotonic)
2456 : .Case("acquire", AtomicOrdering::Acquire)
2457 : .Case("release", AtomicOrdering::Release)
2458 : .Case("acq_rel", AtomicOrdering::AcquireRelease)
2459 : .Case("seq_cst", AtomicOrdering::SequentiallyConsistent)
2460 : .Default(AtomicOrdering::NotAtomic);
2461 :
2462 135 : if (Order != AtomicOrdering::NotAtomic) {
2463 134 : lex();
2464 134 : return false;
2465 : }
2466 :
2467 1 : return error("expected an atomic scope, ordering or a size specification");
2468 : }
2469 :
2470 2427 : bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
2471 2427 : if (expectAndConsume(MIToken::lparen))
2472 : return true;
2473 2427 : MachineMemOperand::Flags Flags = MachineMemOperand::MONone;
2474 3546 : while (Token.isMemoryOperandFlag()) {
2475 1121 : if (parseMemoryOperandFlag(Flags))
2476 : return true;
2477 : }
2478 2425 : if (Token.isNot(MIToken::Identifier) ||
2479 : (Token.stringValue() != "load" && Token.stringValue() != "store"))
2480 1 : return error("expected 'load' or 'store' memory operation");
2481 : if (Token.stringValue() == "load")
2482 : Flags |= MachineMemOperand::MOLoad;
2483 : else
2484 : Flags |= MachineMemOperand::MOStore;
2485 2424 : lex();
2486 :
2487 : // Optional 'store' for operands that both load and store.
2488 2424 : if (Token.is(MIToken::Identifier) && Token.stringValue() == "store") {
2489 : Flags |= MachineMemOperand::MOStore;
2490 26 : lex();
2491 : }
2492 :
2493 : // Optional synchronization scope.
2494 : SyncScope::ID SSID;
2495 2424 : if (parseOptionalScope(MF.getFunction().getContext(), SSID))
2496 : return true;
2497 :
2498 : // Up to two atomic orderings (cmpxchg provides guarantees on failure).
2499 : AtomicOrdering Order, FailureOrder;
2500 2424 : if (parseOptionalAtomicOrdering(Order))
2501 : return true;
2502 :
2503 2423 : if (parseOptionalAtomicOrdering(FailureOrder))
2504 : return true;
2505 :
2506 2423 : if (Token.isNot(MIToken::IntegerLiteral) &&
2507 : Token.isNot(MIToken::kw_unknown_size))
2508 1 : return error("expected the size integer literal or 'unknown-size' after "
2509 : "memory operation");
2510 : uint64_t Size;
2511 2422 : if (Token.is(MIToken::IntegerLiteral)) {
2512 2420 : if (getUint64(Size))
2513 : return true;
2514 2 : } else if (Token.is(MIToken::kw_unknown_size)) {
2515 2 : Size = MemoryLocation::UnknownSize;
2516 : }
2517 2421 : lex();
2518 :
2519 : MachinePointerInfo Ptr = MachinePointerInfo();
2520 2421 : if (Token.is(MIToken::Identifier)) {
2521 : const char *Word =
2522 1978 : ((Flags & MachineMemOperand::MOLoad) &&
2523 : (Flags & MachineMemOperand::MOStore))
2524 3147 : ? "on"
2525 : : Flags & MachineMemOperand::MOLoad ? "from" : "into";
2526 : if (Token.stringValue() != Word)
2527 0 : return error(Twine("expected '") + Word + "'");
2528 1978 : lex();
2529 :
2530 1978 : if (parseMachinePointerInfo(Ptr))
2531 : return true;
2532 : }
2533 2417 : unsigned BaseAlignment = (Size != MemoryLocation::UnknownSize ? Size : 1);
2534 : AAMDNodes AAInfo;
2535 2417 : MDNode *Range = nullptr;
2536 : while (consumeIfPresent(MIToken::comma)) {
2537 743 : switch (Token.kind()) {
2538 342 : case MIToken::kw_align:
2539 342 : if (parseAlignment(BaseAlignment))
2540 : return true;
2541 : break;
2542 233 : case MIToken::kw_addrspace:
2543 233 : if (parseAddrspace(Ptr.AddrSpace))
2544 : return true;
2545 : break;
2546 164 : case MIToken::md_tbaa:
2547 164 : lex();
2548 164 : if (parseMDNode(AAInfo.TBAA))
2549 : return true;
2550 : break;
2551 1 : case MIToken::md_alias_scope:
2552 1 : lex();
2553 1 : if (parseMDNode(AAInfo.Scope))
2554 : return true;
2555 : break;
2556 1 : case MIToken::md_noalias:
2557 1 : lex();
2558 1 : if (parseMDNode(AAInfo.NoAlias))
2559 : return true;
2560 : break;
2561 1 : case MIToken::md_range:
2562 1 : lex();
2563 1 : if (parseMDNode(Range))
2564 : return true;
2565 : break;
2566 : // TODO: Report an error on duplicate metadata nodes.
2567 : default:
2568 1 : return error("expected 'align' or '!tbaa' or '!alias.scope' or "
2569 : "'!noalias' or '!range'");
2570 : }
2571 : }
2572 2414 : if (expectAndConsume(MIToken::rparen))
2573 : return true;
2574 2414 : Dest = MF.getMachineMemOperand(Ptr, Flags, Size, BaseAlignment, AAInfo, Range,
2575 : SSID, Order, FailureOrder);
2576 2414 : return false;
2577 : }
2578 :
2579 8 : bool MIParser::parsePreOrPostInstrSymbol(MCSymbol *&Symbol) {
2580 : assert((Token.is(MIToken::kw_pre_instr_symbol) ||
2581 : Token.is(MIToken::kw_post_instr_symbol)) &&
2582 : "Invalid token for a pre- post-instruction symbol!");
2583 8 : lex();
2584 8 : if (Token.isNot(MIToken::MCSymbol))
2585 0 : return error("expected a symbol after 'pre-instr-symbol'");
2586 16 : Symbol = getOrCreateMCSymbol(Token.stringValue());
2587 8 : lex();
2588 16 : if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
2589 : Token.is(MIToken::lbrace))
2590 : return false;
2591 3 : if (Token.isNot(MIToken::comma))
2592 0 : return error("expected ',' before the next machine operand");
2593 3 : lex();
2594 3 : return false;
2595 : }
2596 :
2597 34651 : void MIParser::initNames2InstrOpCodes() {
2598 34651 : if (!Names2InstrOpCodes.empty())
2599 : return;
2600 4505 : const auto *TII = MF.getSubtarget().getInstrInfo();
2601 : assert(TII && "Expected target instruction info");
2602 37741423 : for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
2603 75473836 : Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
2604 : }
2605 :
2606 34651 : bool MIParser::parseInstrName(StringRef InstrName, unsigned &OpCode) {
2607 34651 : initNames2InstrOpCodes();
2608 34651 : auto InstrInfo = Names2InstrOpCodes.find(InstrName);
2609 69302 : if (InstrInfo == Names2InstrOpCodes.end())
2610 : return true;
2611 34650 : OpCode = InstrInfo->getValue();
2612 34650 : return false;
2613 : }
2614 :
2615 54321 : void MIParser::initNames2Regs() {
2616 54321 : if (!Names2Regs.empty())
2617 : return;
2618 : // The '%noreg' register is the register 0.
2619 6997 : Names2Regs.insert(std::make_pair("noreg", 0));
2620 6997 : const auto *TRI = MF.getSubtarget().getRegisterInfo();
2621 : assert(TRI && "Expected target register info");
2622 4240648 : for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
2623 : bool WasInserted =
2624 9663849 : Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
2625 : .second;
2626 : (void)WasInserted;
2627 : assert(WasInserted && "Expected registers to be unique case-insensitively");
2628 : }
2629 : }
2630 :
2631 54321 : bool MIParser::getRegisterByName(StringRef RegName, unsigned &Reg) {
2632 54321 : initNames2Regs();
2633 54321 : auto RegInfo = Names2Regs.find(RegName);
2634 108642 : if (RegInfo == Names2Regs.end())
2635 : return true;
2636 54319 : Reg = RegInfo->getValue();
2637 54319 : return false;
2638 : }
2639 :
2640 673 : void MIParser::initNames2RegMasks() {
2641 673 : if (!Names2RegMasks.empty())
2642 258 : return;
2643 415 : const auto *TRI = MF.getSubtarget().getRegisterInfo();
2644 : assert(TRI && "Expected target register info");
2645 415 : ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
2646 415 : ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
2647 : assert(RegMasks.size() == RegMaskNames.size());
2648 9558 : for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
2649 : Names2RegMasks.insert(
2650 52352 : std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
2651 : }
2652 :
2653 673 : const uint32_t *MIParser::getRegMask(StringRef Identifier) {
2654 673 : initNames2RegMasks();
2655 673 : auto RegMaskInfo = Names2RegMasks.find(Identifier);
2656 1346 : if (RegMaskInfo == Names2RegMasks.end())
2657 : return nullptr;
2658 219 : return RegMaskInfo->getValue();
2659 : }
2660 :
2661 1180 : void MIParser::initNames2SubRegIndices() {
2662 1180 : if (!Names2SubRegIndices.empty())
2663 : return;
2664 336 : const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
2665 9157 : for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
2666 : Names2SubRegIndices.insert(
2667 29370 : std::make_pair(StringRef(TRI->getSubRegIndexName(I)).lower(), I));
2668 : }
2669 :
2670 1180 : unsigned MIParser::getSubRegIndex(StringRef Name) {
2671 1180 : initNames2SubRegIndices();
2672 1180 : auto SubRegInfo = Names2SubRegIndices.find(Name);
2673 2360 : if (SubRegInfo == Names2SubRegIndices.end())
2674 : return 0;
2675 1178 : return SubRegInfo->getValue();
2676 : }
2677 :
2678 1098 : static void initSlots2BasicBlocks(
2679 : const Function &F,
2680 : DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2681 2196 : ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2682 1098 : MST.incorporateFunction(F);
2683 2494 : for (auto &BB : F) {
2684 1396 : if (BB.hasName())
2685 : continue;
2686 1105 : int Slot = MST.getLocalSlot(&BB);
2687 1105 : if (Slot == -1)
2688 : continue;
2689 1105 : Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
2690 : }
2691 1098 : }
2692 :
2693 : static const BasicBlock *getIRBlockFromSlot(
2694 : unsigned Slot,
2695 : const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2696 1103 : auto BlockInfo = Slots2BasicBlocks.find(Slot);
2697 1103 : if (BlockInfo == Slots2BasicBlocks.end())
2698 : return nullptr;
2699 1101 : return BlockInfo->second;
2700 : }
2701 :
2702 1102 : const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
2703 1102 : if (Slots2BasicBlocks.empty())
2704 1097 : initSlots2BasicBlocks(MF.getFunction(), Slots2BasicBlocks);
2705 1102 : return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
2706 : }
2707 :
2708 1103 : const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
2709 1103 : if (&F == &MF.getFunction())
2710 1102 : return getIRBlock(Slot);
2711 : DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
2712 1 : initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
2713 1 : return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
2714 : }
2715 :
2716 688 : static void mapValueToSlot(const Value *V, ModuleSlotTracker &MST,
2717 : DenseMap<unsigned, const Value *> &Slots2Values) {
2718 688 : int Slot = MST.getLocalSlot(V);
2719 688 : if (Slot == -1)
2720 : return;
2721 217 : Slots2Values.insert(std::make_pair(unsigned(Slot), V));
2722 : }
2723 :
2724 : /// Creates the mapping from slot numbers to function's unnamed IR values.
2725 23 : static void initSlots2Values(const Function &F,
2726 : DenseMap<unsigned, const Value *> &Slots2Values) {
2727 46 : ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2728 23 : MST.incorporateFunction(F);
2729 75 : for (const auto &Arg : F.args())
2730 52 : mapValueToSlot(&Arg, MST, Slots2Values);
2731 60 : for (const auto &BB : F) {
2732 37 : mapValueToSlot(&BB, MST, Slots2Values);
2733 636 : for (const auto &I : BB)
2734 599 : mapValueToSlot(&I, MST, Slots2Values);
2735 : }
2736 23 : }
2737 :
2738 105 : const Value *MIParser::getIRValue(unsigned Slot) {
2739 105 : if (Slots2Values.empty())
2740 23 : initSlots2Values(MF.getFunction(), Slots2Values);
2741 105 : auto ValueInfo = Slots2Values.find(Slot);
2742 105 : if (ValueInfo == Slots2Values.end())
2743 : return nullptr;
2744 105 : return ValueInfo->second;
2745 : }
2746 :
2747 3 : void MIParser::initNames2TargetIndices() {
2748 3 : if (!Names2TargetIndices.empty())
2749 0 : return;
2750 3 : const auto *TII = MF.getSubtarget().getInstrInfo();
2751 : assert(TII && "Expected target instruction info");
2752 3 : auto Indices = TII->getSerializableTargetIndices();
2753 18 : for (const auto &I : Indices)
2754 30 : Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
2755 : }
2756 :
2757 3 : bool MIParser::getTargetIndex(StringRef Name, int &Index) {
2758 3 : initNames2TargetIndices();
2759 3 : auto IndexInfo = Names2TargetIndices.find(Name);
2760 6 : if (IndexInfo == Names2TargetIndices.end())
2761 : return true;
2762 2 : Index = IndexInfo->second;
2763 2 : return false;
2764 : }
2765 :
2766 435 : void MIParser::initNames2DirectTargetFlags() {
2767 435 : if (!Names2DirectTargetFlags.empty())
2768 389 : return;
2769 46 : const auto *TII = MF.getSubtarget().getInstrInfo();
2770 : assert(TII && "Expected target instruction info");
2771 46 : auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
2772 527 : for (const auto &I : Flags)
2773 : Names2DirectTargetFlags.insert(
2774 962 : std::make_pair(StringRef(I.second), I.first));
2775 : }
2776 :
2777 435 : bool MIParser::getDirectTargetFlag(StringRef Name, unsigned &Flag) {
2778 435 : initNames2DirectTargetFlags();
2779 435 : auto FlagInfo = Names2DirectTargetFlags.find(Name);
2780 870 : if (FlagInfo == Names2DirectTargetFlags.end())
2781 : return true;
2782 431 : Flag = FlagInfo->second;
2783 431 : return false;
2784 : }
2785 :
2786 35 : void MIParser::initNames2BitmaskTargetFlags() {
2787 35 : if (!Names2BitmaskTargetFlags.empty())
2788 21 : return;
2789 14 : const auto *TII = MF.getSubtarget().getInstrInfo();
2790 : assert(TII && "Expected target instruction info");
2791 14 : auto Flags = TII->getSerializableBitmaskMachineOperandTargetFlags();
2792 75 : for (const auto &I : Flags)
2793 : Names2BitmaskTargetFlags.insert(
2794 122 : std::make_pair(StringRef(I.second), I.first));
2795 : }
2796 :
2797 35 : bool MIParser::getBitmaskTargetFlag(StringRef Name, unsigned &Flag) {
2798 35 : initNames2BitmaskTargetFlags();
2799 35 : auto FlagInfo = Names2BitmaskTargetFlags.find(Name);
2800 70 : if (FlagInfo == Names2BitmaskTargetFlags.end())
2801 : return true;
2802 33 : Flag = FlagInfo->second;
2803 33 : return false;
2804 : }
2805 :
2806 24 : void MIParser::initNames2MMOTargetFlags() {
2807 24 : if (!Names2MMOTargetFlags.empty())
2808 5 : return;
2809 19 : const auto *TII = MF.getSubtarget().getInstrInfo();
2810 : assert(TII && "Expected target instruction info");
2811 19 : auto Flags = TII->getSerializableMachineMemOperandTargetFlags();
2812 57 : for (const auto &I : Flags)
2813 : Names2MMOTargetFlags.insert(
2814 76 : std::make_pair(StringRef(I.second), I.first));
2815 : }
2816 :
2817 24 : bool MIParser::getMMOTargetFlag(StringRef Name,
2818 : MachineMemOperand::Flags &Flag) {
2819 24 : initNames2MMOTargetFlags();
2820 24 : auto FlagInfo = Names2MMOTargetFlags.find(Name);
2821 48 : if (FlagInfo == Names2MMOTargetFlags.end())
2822 : return true;
2823 23 : Flag = FlagInfo->second;
2824 23 : return false;
2825 : }
2826 :
2827 0 : MCSymbol *MIParser::getOrCreateMCSymbol(StringRef Name) {
2828 : // FIXME: Currently we can't recognize temporary or local symbols and call all
2829 : // of the appropriate forms to create them. However, this handles basic cases
2830 : // well as most of the special aspects are recognized by a prefix on their
2831 : // name, and the input names should already be unique. For test cases, keeping
2832 : // the symbol name out of the symbol table isn't terribly important.
2833 32 : return MF.getContext().getOrCreateSymbol(Name);
2834 : }
2835 :
2836 85 : bool MIParser::parseStringConstant(std::string &Result) {
2837 85 : if (Token.isNot(MIToken::StringConstant))
2838 0 : return error("expected string constant");
2839 85 : Result = Token.stringValue();
2840 85 : lex();
2841 85 : return false;
2842 : }
2843 :
2844 4570 : bool llvm::parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS,
2845 : StringRef Src,
2846 : SMDiagnostic &Error) {
2847 4570 : return MIParser(PFS, Error, Src).parseBasicBlockDefinitions(PFS.MBBSlots);
2848 : }
2849 :
2850 4550 : bool llvm::parseMachineInstructions(PerFunctionMIParsingState &PFS,
2851 : StringRef Src, SMDiagnostic &Error) {
2852 4550 : return MIParser(PFS, Error, Src).parseBasicBlocks();
2853 : }
2854 :
2855 92 : bool llvm::parseMBBReference(PerFunctionMIParsingState &PFS,
2856 : MachineBasicBlock *&MBB, StringRef Src,
2857 : SMDiagnostic &Error) {
2858 92 : return MIParser(PFS, Error, Src).parseStandaloneMBB(MBB);
2859 : }
2860 :
2861 12 : bool llvm::parseRegisterReference(PerFunctionMIParsingState &PFS,
2862 : unsigned &Reg, StringRef Src,
2863 : SMDiagnostic &Error) {
2864 12 : return MIParser(PFS, Error, Src).parseStandaloneRegister(Reg);
2865 : }
2866 :
2867 2609 : bool llvm::parseNamedRegisterReference(PerFunctionMIParsingState &PFS,
2868 : unsigned &Reg, StringRef Src,
2869 : SMDiagnostic &Error) {
2870 2609 : return MIParser(PFS, Error, Src).parseStandaloneNamedRegister(Reg);
2871 : }
2872 :
2873 1133 : bool llvm::parseVirtualRegisterReference(PerFunctionMIParsingState &PFS,
2874 : VRegInfo *&Info, StringRef Src,
2875 : SMDiagnostic &Error) {
2876 1133 : return MIParser(PFS, Error, Src).parseStandaloneVirtualRegister(Info);
2877 : }
2878 :
2879 2 : bool llvm::parseStackObjectReference(PerFunctionMIParsingState &PFS,
2880 : int &FI, StringRef Src,
2881 : SMDiagnostic &Error) {
2882 2 : return MIParser(PFS, Error, Src).parseStandaloneStackObject(FI);
2883 : }
2884 :
2885 10 : bool llvm::parseMDNode(PerFunctionMIParsingState &PFS,
2886 : MDNode *&Node, StringRef Src, SMDiagnostic &Error) {
2887 10 : return MIParser(PFS, Error, Src).parseStandaloneMDNode(Node);
2888 : }
|
