Bug Summary

File:lib/CodeGen/MIRParser/MIParser.cpp
Warning:line 1433, column 15
The left operand of '>=' is a garbage value

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