Bug Summary

File:lib/CodeGen/MIRParser/MIParser.cpp
Warning:line 1427, 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 "MILexer.h"
15#include "MIParser.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/StringSwitch.h"
25#include "llvm/ADT/StringRef.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/MachineModuleInfo.h"
37#include "llvm/CodeGen/MachineOperand.h"
38#include "llvm/CodeGen/MachineRegisterInfo.h"
39#include "llvm/IR/BasicBlock.h"
40#include "llvm/IR/Constants.h"
41#include "llvm/IR/DataLayout.h"
42#include "llvm/IR/DebugInfoMetadata.h"
43#include "llvm/IR/DebugLoc.h"
44#include "llvm/IR/Function.h"
45#include "llvm/IR/InstrTypes.h"
46#include "llvm/IR/Instructions.h"
47#include "llvm/IR/Intrinsics.h"
48#include "llvm/IR/Metadata.h"
49#include "llvm/IR/Module.h"
50#include "llvm/IR/ModuleSlotTracker.h"
51#include "llvm/IR/Type.h"
52#include "llvm/IR/Value.h"
53#include "llvm/IR/ValueSymbolTable.h"
54#include "llvm/MC/LaneBitmask.h"
55#include "llvm/MC/MCDwarf.h"
56#include "llvm/MC/MCInstrDesc.h"
57#include "llvm/MC/MCRegisterInfo.h"
58#include "llvm/Support/AtomicOrdering.h"
59#include "llvm/Support/BranchProbability.h"
60#include "llvm/Support/Casting.h"
61#include "llvm/Support/ErrorHandling.h"
62#include "llvm/Support/LowLevelTypeImpl.h"
63#include "llvm/Support/MemoryBuffer.h"
64#include "llvm/Support/SMLoc.h"
65#include "llvm/Support/SourceMgr.h"
66#include "llvm/Support/raw_ostream.h"
67#include "llvm/Target/TargetInstrInfo.h"
68#include "llvm/Target/TargetIntrinsicInfo.h"
69#include "llvm/Target/TargetMachine.h"
70#include "llvm/Target/TargetRegisterInfo.h"
71#include "llvm/Target/TargetSubtargetInfo.h"
72#include <algorithm>
73#include <cassert>
74#include <cctype>
75#include <cstddef>
76#include <cstdint>
77#include <limits>
78#include <string>
79#include <utility>
80
81using namespace llvm;
82
83PerFunctionMIParsingState::PerFunctionMIParsingState(MachineFunction &MF,
84 SourceMgr &SM, const SlotMapping &IRSlots,
85 const Name2RegClassMap &Names2RegClasses,
86 const Name2RegBankMap &Names2RegBanks)
87 : MF(MF), SM(&SM), IRSlots(IRSlots), Names2RegClasses(Names2RegClasses),
88 Names2RegBanks(Names2RegBanks) {
89}
90
91VRegInfo &PerFunctionMIParsingState::getVRegInfo(unsigned Num) {
92 auto I = VRegInfos.insert(std::make_pair(Num, nullptr));
93 if (I.second) {
94 MachineRegisterInfo &MRI = MF.getRegInfo();
95 VRegInfo *Info = new (Allocator) VRegInfo;
96 Info->VReg = MRI.createIncompleteVirtualRegister();
97 I.first->second = Info;
98 }
99 return *I.first->second;
100}
101
102namespace {
103
104/// A wrapper struct around the 'MachineOperand' struct that includes a source
105/// range and other attributes.
106struct ParsedMachineOperand {
107 MachineOperand Operand;
108 StringRef::iterator Begin;
109 StringRef::iterator End;
110 Optional<unsigned> TiedDefIdx;
111
112 ParsedMachineOperand(const MachineOperand &Operand, StringRef::iterator Begin,
113 StringRef::iterator End, Optional<unsigned> &TiedDefIdx)
114 : Operand(Operand), Begin(Begin), End(End), TiedDefIdx(TiedDefIdx) {
115 if (TiedDefIdx)
116 assert(Operand.isReg() && Operand.isUse() &&((Operand.isReg() && Operand.isUse() && "Only used register operands can be tied"
) ? static_cast<void> (0) : __assert_fail ("Operand.isReg() && Operand.isUse() && \"Only used register operands can be tied\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 117, __PRETTY_FUNCTION__))
117 "Only used register operands can be tied")((Operand.isReg() && Operand.isUse() && "Only used register operands can be tied"
) ? static_cast<void> (0) : __assert_fail ("Operand.isReg() && Operand.isUse() && \"Only used register operands can be tied\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 117, __PRETTY_FUNCTION__))
;
118 }
119};
120
121class MIParser {
122 MachineFunction &MF;
123 SMDiagnostic &Error;
124 StringRef Source, CurrentSource;
125 MIToken Token;
126 PerFunctionMIParsingState &PFS;
127 /// Maps from instruction names to op codes.
128 StringMap<unsigned> Names2InstrOpCodes;
129 /// Maps from register names to registers.
130 StringMap<unsigned> Names2Regs;
131 /// Maps from register mask names to register masks.
132 StringMap<const uint32_t *> Names2RegMasks;
133 /// Maps from subregister names to subregister indices.
134 StringMap<unsigned> Names2SubRegIndices;
135 /// Maps from slot numbers to function's unnamed basic blocks.
136 DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
137 /// Maps from slot numbers to function's unnamed values.
138 DenseMap<unsigned, const Value *> Slots2Values;
139 /// Maps from target index names to target indices.
140 StringMap<int> Names2TargetIndices;
141 /// Maps from direct target flag names to the direct target flag values.
142 StringMap<unsigned> Names2DirectTargetFlags;
143 /// Maps from direct target flag names to the bitmask target flag values.
144 StringMap<unsigned> Names2BitmaskTargetFlags;
145 /// Maps from MMO target flag names to MMO target flag values.
146 StringMap<MachineMemOperand::Flags> Names2MMOTargetFlags;
147
148public:
149 MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
150 StringRef Source);
151
152 /// \p SkipChar gives the number of characters to skip before looking
153 /// for the next token.
154 void lex(unsigned SkipChar = 0);
155
156 /// Report an error at the current location with the given message.
157 ///
158 /// This function always return true.
159 bool error(const Twine &Msg);
160
161 /// Report an error at the given location with the given message.
162 ///
163 /// This function always return true.
164 bool error(StringRef::iterator Loc, const Twine &Msg);
165
166 bool
167 parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
168 bool parseBasicBlocks();
169 bool parse(MachineInstr *&MI);
170 bool parseStandaloneMBB(MachineBasicBlock *&MBB);
171 bool parseStandaloneNamedRegister(unsigned &Reg);
172 bool parseStandaloneVirtualRegister(VRegInfo *&Info);
173 bool parseStandaloneRegister(unsigned &Reg);
174 bool parseStandaloneStackObject(int &FI);
175 bool parseStandaloneMDNode(MDNode *&Node);
176
177 bool
178 parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
179 bool parseBasicBlock(MachineBasicBlock &MBB,
180 MachineBasicBlock *&AddFalthroughFrom);
181 bool parseBasicBlockLiveins(MachineBasicBlock &MBB);
182 bool parseBasicBlockSuccessors(MachineBasicBlock &MBB);
183
184 bool parseNamedRegister(unsigned &Reg);
185 bool parseVirtualRegister(VRegInfo *&Info);
186 bool parseRegister(unsigned &Reg, VRegInfo *&VRegInfo);
187 bool parseRegisterFlag(unsigned &Flags);
188 bool parseRegisterClassOrBank(VRegInfo &RegInfo);
189 bool parseSubRegisterIndex(unsigned &SubReg);
190 bool parseRegisterTiedDefIndex(unsigned &TiedDefIdx);
191 bool parseRegisterOperand(MachineOperand &Dest,
192 Optional<unsigned> &TiedDefIdx, bool IsDef = false);
193 bool parseImmediateOperand(MachineOperand &Dest);
194 bool parseIRConstant(StringRef::iterator Loc, StringRef Source,
195 const Constant *&C);
196 bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
197 bool parseLowLevelType(StringRef::iterator Loc, LLT &Ty);
198 bool parseTypedImmediateOperand(MachineOperand &Dest);
199 bool parseFPImmediateOperand(MachineOperand &Dest);
200 bool parseMBBReference(MachineBasicBlock *&MBB);
201 bool parseMBBOperand(MachineOperand &Dest);
202 bool parseStackFrameIndex(int &FI);
203 bool parseStackObjectOperand(MachineOperand &Dest);
204 bool parseFixedStackFrameIndex(int &FI);
205 bool parseFixedStackObjectOperand(MachineOperand &Dest);
206 bool parseGlobalValue(GlobalValue *&GV);
207 bool parseGlobalAddressOperand(MachineOperand &Dest);
208 bool parseConstantPoolIndexOperand(MachineOperand &Dest);
209 bool parseSubRegisterIndexOperand(MachineOperand &Dest);
210 bool parseJumpTableIndexOperand(MachineOperand &Dest);
211 bool parseExternalSymbolOperand(MachineOperand &Dest);
212 bool parseMDNode(MDNode *&Node);
213 bool parseDIExpression(MDNode *&Node);
214 bool parseMetadataOperand(MachineOperand &Dest);
215 bool parseCFIOffset(int &Offset);
216 bool parseCFIRegister(unsigned &Reg);
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()))((Loc >= Source.data() && Loc <= (Source.data()
+ Source.size())) ? static_cast<void> (0) : __assert_fail
("Loc >= Source.data() && Loc <= (Source.data() + Source.size())"
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 357, __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))((Token.is(MIToken::MachineBasicBlockLabel)) ? static_cast<
void> (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 405, __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))((Token.is(MIToken::kw_liveins)) ? static_cast<void> (0
) : __assert_fail ("Token.is(MIToken::kw_liveins)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 515, __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))((Token.is(MIToken::kw_successors)) ? static_cast<void>
(0) : __assert_fail ("Token.is(MIToken::kw_successors)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 548, __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))((Token.is(MIToken::MachineBasicBlockLabel)) ? static_cast<
void> (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 581, __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)((IsInBundle) ? static_cast<void> (0) : __assert_fail (
"IsInBundle", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 627, __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")((Token.isNewlineOrEOF() && "MI is not fully parsed")
? static_cast<void> (0) : __assert_fail ("Token.isNewlineOrEOF() && \"MI is not fully parsed\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 651, __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))((Token.is(MIToken::MachineBasicBlockLabel)) ? static_cast<
void> (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 682, __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))((Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken
::Eof)) ? static_cast<void> (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof)"
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 698, __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())((MO.isImplicit()) ? static_cast<void> (0) : __assert_fail
("MO.isImplicit()", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 873, __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")((TargetRegisterInfo::isPhysicalRegister(Reg) && "expected phys reg"
) ? static_cast<void> (0) : __assert_fail ("TargetRegisterInfo::isPhysicalRegister(Reg) && \"expected phys reg\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 879, __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")((TRI && "Expected target register info") ? static_cast
<void> (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 912, __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")((Token.is(MIToken::NamedRegister) && "Needs NamedRegister token"
) ? static_cast<void> (0) : __assert_fail ("Token.is(MIToken::NamedRegister) && \"Needs NamedRegister token\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 939, __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")((Token.is(MIToken::VirtualRegister) && "Needs VirtualRegister token"
) ? static_cast<void> (0) : __assert_fail ("Token.is(MIToken::VirtualRegister) && \"Needs VirtualRegister token\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 947, __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~svn316068/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~svn316068/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~svn316068/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 default:
1064 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~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1064)
;
1065 }
1066 if (OldFlags == Flags)
1067 // We know that the same flag is specified more than once when the flags
1068 // weren't modified.
1069 return error("duplicate '" + Token.stringValue() + "' register flag");
1070 lex();
1071 return false;
1072}
1073
1074bool MIParser::parseSubRegisterIndex(unsigned &SubReg) {
1075 assert(Token.is(MIToken::dot))((Token.is(MIToken::dot)) ? static_cast<void> (0) : __assert_fail
("Token.is(MIToken::dot)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1075, __PRETTY_FUNCTION__))
;
1076 lex();
1077 if (Token.isNot(MIToken::Identifier))
1078 return error("expected a subregister index after '.'");
1079 auto Name = Token.stringValue();
1080 SubReg = getSubRegIndex(Name);
1081 if (!SubReg)
1082 return error(Twine("use of unknown subregister index '") + Name + "'");
1083 lex();
1084 return false;
1085}
1086
1087bool MIParser::parseRegisterTiedDefIndex(unsigned &TiedDefIdx) {
1088 if (!consumeIfPresent(MIToken::kw_tied_def))
1089 return true;
1090 if (Token.isNot(MIToken::IntegerLiteral))
1091 return error("expected an integer literal after 'tied-def'");
1092 if (getUnsigned(TiedDefIdx))
1093 return true;
1094 lex();
1095 if (expectAndConsume(MIToken::rparen))
1096 return true;
1097 return false;
1098}
1099
1100bool MIParser::assignRegisterTies(MachineInstr &MI,
1101 ArrayRef<ParsedMachineOperand> Operands) {
1102 SmallVector<std::pair<unsigned, unsigned>, 4> TiedRegisterPairs;
1103 for (unsigned I = 0, E = Operands.size(); I != E; ++I) {
1104 if (!Operands[I].TiedDefIdx)
1105 continue;
1106 // The parser ensures that this operand is a register use, so we just have
1107 // to check the tied-def operand.
1108 unsigned DefIdx = Operands[I].TiedDefIdx.getValue();
1109 if (DefIdx >= E)
1110 return error(Operands[I].Begin,
1111 Twine("use of invalid tied-def operand index '" +
1112 Twine(DefIdx) + "'; instruction has only ") +
1113 Twine(E) + " operands");
1114 const auto &DefOperand = Operands[DefIdx].Operand;
1115 if (!DefOperand.isReg() || !DefOperand.isDef())
1116 // FIXME: add note with the def operand.
1117 return error(Operands[I].Begin,
1118 Twine("use of invalid tied-def operand index '") +
1119 Twine(DefIdx) + "'; the operand #" + Twine(DefIdx) +
1120 " isn't a defined register");
1121 // Check that the tied-def operand wasn't tied elsewhere.
1122 for (const auto &TiedPair : TiedRegisterPairs) {
1123 if (TiedPair.first == DefIdx)
1124 return error(Operands[I].Begin,
1125 Twine("the tied-def operand #") + Twine(DefIdx) +
1126 " is already tied with another register operand");
1127 }
1128 TiedRegisterPairs.push_back(std::make_pair(DefIdx, I));
1129 }
1130 // FIXME: Verify that for non INLINEASM instructions, the def and use tied
1131 // indices must be less than tied max.
1132 for (const auto &TiedPair : TiedRegisterPairs)
1133 MI.tieOperands(TiedPair.first, TiedPair.second);
1134 return false;
1135}
1136
1137bool MIParser::parseRegisterOperand(MachineOperand &Dest,
1138 Optional<unsigned> &TiedDefIdx,
1139 bool IsDef) {
1140 unsigned Flags = IsDef ? RegState::Define : 0;
1141 while (Token.isRegisterFlag()) {
1142 if (parseRegisterFlag(Flags))
1143 return true;
1144 }
1145 if (!Token.isRegister())
1146 return error("expected a register after register flags");
1147 unsigned Reg;
1148 VRegInfo *RegInfo;
1149 if (parseRegister(Reg, RegInfo))
1150 return true;
1151 lex();
1152 unsigned SubReg = 0;
1153 if (Token.is(MIToken::dot)) {
1154 if (parseSubRegisterIndex(SubReg))
1155 return true;
1156 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1157 return error("subregister index expects a virtual register");
1158 }
1159 if (Token.is(MIToken::colon)) {
1160 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1161 return error("register class specification expects a virtual register");
1162 lex();
1163 if (parseRegisterClassOrBank(*RegInfo))
1164 return true;
1165 }
1166 MachineRegisterInfo &MRI = MF.getRegInfo();
1167 if ((Flags & RegState::Define) == 0) {
1168 if (consumeIfPresent(MIToken::lparen)) {
1169 unsigned Idx;
1170 if (!parseRegisterTiedDefIndex(Idx))
1171 TiedDefIdx = Idx;
1172 else {
1173 // Try a redundant low-level type.
1174 LLT Ty;
1175 if (parseLowLevelType(Token.location(), Ty))
1176 return error("expected tied-def or low-level type after '('");
1177
1178 if (expectAndConsume(MIToken::rparen))
1179 return true;
1180
1181 if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1182 return error("inconsistent type for generic virtual register");
1183
1184 MRI.setType(Reg, Ty);
1185 }
1186 }
1187 } else if (consumeIfPresent(MIToken::lparen)) {
1188 // Virtual registers may have a tpe with GlobalISel.
1189 if (!TargetRegisterInfo::isVirtualRegister(Reg))
1190 return error("unexpected type on physical register");
1191
1192 LLT Ty;
1193 if (parseLowLevelType(Token.location(), Ty))
1194 return true;
1195
1196 if (expectAndConsume(MIToken::rparen))
1197 return true;
1198
1199 if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
1200 return error("inconsistent type for generic virtual register");
1201
1202 MRI.setType(Reg, Ty);
1203 } else if (TargetRegisterInfo::isVirtualRegister(Reg)) {
1204 // Generic virtual registers must have a type.
1205 // If we end up here this means the type hasn't been specified and
1206 // this is bad!
1207 if (RegInfo->Kind == VRegInfo::GENERIC ||
1208 RegInfo->Kind == VRegInfo::REGBANK)
1209 return error("generic virtual registers must have a type");
1210 }
1211 Dest = MachineOperand::CreateReg(
1212 Reg, Flags & RegState::Define, Flags & RegState::Implicit,
1213 Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
1214 Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug,
1215 Flags & RegState::InternalRead);
1216 return false;
1217}
1218
1219bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
1220 assert(Token.is(MIToken::IntegerLiteral))((Token.is(MIToken::IntegerLiteral)) ? static_cast<void>
(0) : __assert_fail ("Token.is(MIToken::IntegerLiteral)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1220, __PRETTY_FUNCTION__))
;
1221 const APSInt &Int = Token.integerValue();
1222 if (Int.getMinSignedBits() > 64)
1223 return error("integer literal is too large to be an immediate operand");
1224 Dest = MachineOperand::CreateImm(Int.getExtValue());
1225 lex();
1226 return false;
1227}
1228
1229bool MIParser::parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
1230 const Constant *&C) {
1231 auto Source = StringValue.str(); // The source has to be null terminated.
1232 SMDiagnostic Err;
1233 C = parseConstantValue(Source, Err, *MF.getFunction()->getParent(),
1234 &PFS.IRSlots);
1235 if (!C)
1236 return error(Loc + Err.getColumnNo(), Err.getMessage());
1237 return false;
1238}
1239
1240bool MIParser::parseIRConstant(StringRef::iterator Loc, const Constant *&C) {
1241 if (parseIRConstant(Loc, StringRef(Loc, Token.range().end() - Loc), C))
1242 return true;
1243 lex();
1244 return false;
1245}
1246
1247bool MIParser::parseLowLevelType(StringRef::iterator Loc, LLT &Ty) {
1248 if (Token.is(MIToken::ScalarType)) {
1249 Ty = LLT::scalar(APSInt(Token.range().drop_front()).getZExtValue());
1250 lex();
1251 return false;
1252 } else if (Token.is(MIToken::PointerType)) {
1253 const DataLayout &DL = MF.getFunction()->getParent()->getDataLayout();
1254 unsigned AS = APSInt(Token.range().drop_front()).getZExtValue();
1255 Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
1256 lex();
1257 return false;
1258 }
1259
1260 // Now we're looking for a vector.
1261 if (Token.isNot(MIToken::less))
1262 return error(Loc,
1263 "expected unsized, pN, sN or <N x sM> for GlobalISel type");
1264
1265 lex();
1266
1267 if (Token.isNot(MIToken::IntegerLiteral))
1268 return error(Loc, "expected <N x sM> for vctor type");
1269 uint64_t NumElements = Token.integerValue().getZExtValue();
1270 lex();
1271
1272 if (Token.isNot(MIToken::Identifier) || Token.stringValue() != "x")
1273 return error(Loc, "expected '<N x sM>' for vector type");
1274 lex();
1275
1276 if (Token.isNot(MIToken::ScalarType))
1277 return error(Loc, "expected '<N x sM>' for vector type");
1278 uint64_t ScalarSize = APSInt(Token.range().drop_front()).getZExtValue();
1279 lex();
1280
1281 if (Token.isNot(MIToken::greater))
1282 return error(Loc, "expected '<N x sM>' for vector type");
1283 lex();
1284
1285 Ty = LLT::vector(NumElements, ScalarSize);
1286 return false;
1287}
1288
1289bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
1290 assert(Token.is(MIToken::IntegerType))((Token.is(MIToken::IntegerType)) ? static_cast<void> (
0) : __assert_fail ("Token.is(MIToken::IntegerType)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1290, __PRETTY_FUNCTION__))
;
1291 auto Loc = Token.location();
1292 lex();
1293 if (Token.isNot(MIToken::IntegerLiteral))
1294 return error("expected an integer literal");
1295 const Constant *C = nullptr;
1296 if (parseIRConstant(Loc, C))
1297 return true;
1298 Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
1299 return false;
1300}
1301
1302bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
1303 auto Loc = Token.location();
1304 lex();
1305 if (Token.isNot(MIToken::FloatingPointLiteral) &&
1306 Token.isNot(MIToken::HexLiteral))
1307 return error("expected a floating point literal");
1308 const Constant *C = nullptr;
1309 if (parseIRConstant(Loc, C))
1310 return true;
1311 Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
1312 return false;
1313}
1314
1315bool MIParser::getUnsigned(unsigned &Result) {
1316 if (Token.hasIntegerValue()) {
10
Assuming the condition is true
11
Taking true branch
1317 const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
12
Calling 'numeric_limits::max'
13
Returning from 'numeric_limits::max'
1318 uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
14
Calling 'MIToken::integerValue'
15
Returning from 'MIToken::integerValue'
1319 if (Val64 == Limit)
16
Assuming 'Val64' is equal to 'Limit'
17
Taking true branch
1320 return error("expected 32-bit integer (too large)");
18
Calling 'MIParser::error'
21
Returning from 'MIParser::error'
1321 Result = Val64;
1322 return false;
1323 }
1324 if (Token.is(MIToken::HexLiteral)) {
1325 APInt A;
1326 if (getHexUint(A))
1327 return true;
1328 if (A.getBitWidth() > 32)
1329 return error("expected 32-bit integer (too large)");
1330 Result = A.getZExtValue();
1331 return false;
1332 }
1333 return true;
1334}
1335
1336bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
1337 assert(Token.is(MIToken::MachineBasicBlock) ||((Token.is(MIToken::MachineBasicBlock) || Token.is(MIToken::MachineBasicBlockLabel
)) ? static_cast<void> (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlock) || Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1338, __PRETTY_FUNCTION__))
1338 Token.is(MIToken::MachineBasicBlockLabel))((Token.is(MIToken::MachineBasicBlock) || Token.is(MIToken::MachineBasicBlockLabel
)) ? static_cast<void> (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlock) || Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1338, __PRETTY_FUNCTION__))
;
1339 unsigned Number;
1340 if (getUnsigned(Number))
1341 return true;
1342 auto MBBInfo = PFS.MBBSlots.find(Number);
1343 if (MBBInfo == PFS.MBBSlots.end())
1344 return error(Twine("use of undefined machine basic block #") +
1345 Twine(Number));
1346 MBB = MBBInfo->second;
1347 if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
1348 return error(Twine("the name of machine basic block #") + Twine(Number) +
1349 " isn't '" + Token.stringValue() + "'");
1350 return false;
1351}
1352
1353bool MIParser::parseMBBOperand(MachineOperand &Dest) {
1354 MachineBasicBlock *MBB;
1355 if (parseMBBReference(MBB))
1356 return true;
1357 Dest = MachineOperand::CreateMBB(MBB);
1358 lex();
1359 return false;
1360}
1361
1362bool MIParser::parseStackFrameIndex(int &FI) {
1363 assert(Token.is(MIToken::StackObject))((Token.is(MIToken::StackObject)) ? static_cast<void> (
0) : __assert_fail ("Token.is(MIToken::StackObject)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1363, __PRETTY_FUNCTION__))
;
1364 unsigned ID;
1365 if (getUnsigned(ID))
1366 return true;
1367 auto ObjectInfo = PFS.StackObjectSlots.find(ID);
1368 if (ObjectInfo == PFS.StackObjectSlots.end())
1369 return error(Twine("use of undefined stack object '%stack.") + Twine(ID) +
1370 "'");
1371 StringRef Name;
1372 if (const auto *Alloca =
1373 MF.getFrameInfo().getObjectAllocation(ObjectInfo->second))
1374 Name = Alloca->getName();
1375 if (!Token.stringValue().empty() && Token.stringValue() != Name)
1376 return error(Twine("the name of the stack object '%stack.") + Twine(ID) +
1377 "' isn't '" + Token.stringValue() + "'");
1378 lex();
1379 FI = ObjectInfo->second;
1380 return false;
1381}
1382
1383bool MIParser::parseStackObjectOperand(MachineOperand &Dest) {
1384 int FI;
1385 if (parseStackFrameIndex(FI))
1386 return true;
1387 Dest = MachineOperand::CreateFI(FI);
1388 return false;
1389}
1390
1391bool MIParser::parseFixedStackFrameIndex(int &FI) {
1392 assert(Token.is(MIToken::FixedStackObject))((Token.is(MIToken::FixedStackObject)) ? static_cast<void>
(0) : __assert_fail ("Token.is(MIToken::FixedStackObject)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1392, __PRETTY_FUNCTION__))
;
1393 unsigned ID;
1394 if (getUnsigned(ID))
1395 return true;
1396 auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
1397 if (ObjectInfo == PFS.FixedStackObjectSlots.end())
1398 return error(Twine("use of undefined fixed stack object '%fixed-stack.") +
1399 Twine(ID) + "'");
1400 lex();
1401 FI = ObjectInfo->second;
1402 return false;
1403}
1404
1405bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
1406 int FI;
1407 if (parseFixedStackFrameIndex(FI))
1408 return true;
1409 Dest = MachineOperand::CreateFI(FI);
1410 return false;
1411}
1412
1413bool MIParser::parseGlobalValue(GlobalValue *&GV) {
1414 switch (Token.kind()) {
7
Control jumps to 'case GlobalValue:' at line 1423
1415 case MIToken::NamedGlobalValue: {
1416 const Module *M = MF.getFunction()->getParent();
1417 GV = M->getNamedValue(Token.stringValue());
1418 if (!GV)
1419 return error(Twine("use of undefined global value '") + Token.range() +
1420 "'");
1421 break;
1422 }
1423 case MIToken::GlobalValue: {
1424 unsigned GVIdx;
8
'GVIdx' declared without an initial value
1425 if (getUnsigned(GVIdx))
9
Calling 'MIParser::getUnsigned'
22
Returning from 'MIParser::getUnsigned'
23
Assuming the condition is false
24
Taking false branch
1426 return true;
1427 if (GVIdx >= PFS.IRSlots.GlobalValues.size())
25
The left operand of '>=' is a garbage value
1428 return error(Twine("use of undefined global value '@") + Twine(GVIdx) +
1429 "'");
1430 GV = PFS.IRSlots.GlobalValues[GVIdx];
1431 break;
1432 }
1433 default:
1434 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~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1434)
;
1435 }
1436 return false;
1437}
1438
1439bool MIParser::parseGlobalAddressOperand(MachineOperand &Dest) {
1440 GlobalValue *GV = nullptr;
1441 if (parseGlobalValue(GV))
1442 return true;
1443 lex();
1444 Dest = MachineOperand::CreateGA(GV, /*Offset=*/0);
1445 if (parseOperandsOffset(Dest))
1446 return true;
1447 return false;
1448}
1449
1450bool MIParser::parseConstantPoolIndexOperand(MachineOperand &Dest) {
1451 assert(Token.is(MIToken::ConstantPoolItem))((Token.is(MIToken::ConstantPoolItem)) ? static_cast<void>
(0) : __assert_fail ("Token.is(MIToken::ConstantPoolItem)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1451, __PRETTY_FUNCTION__))
;
1452 unsigned ID;
1453 if (getUnsigned(ID))
1454 return true;
1455 auto ConstantInfo = PFS.ConstantPoolSlots.find(ID);
1456 if (ConstantInfo == PFS.ConstantPoolSlots.end())
1457 return error("use of undefined constant '%const." + Twine(ID) + "'");
1458 lex();
1459 Dest = MachineOperand::CreateCPI(ID, /*Offset=*/0);
1460 if (parseOperandsOffset(Dest))
1461 return true;
1462 return false;
1463}
1464
1465bool MIParser::parseJumpTableIndexOperand(MachineOperand &Dest) {
1466 assert(Token.is(MIToken::JumpTableIndex))((Token.is(MIToken::JumpTableIndex)) ? static_cast<void>
(0) : __assert_fail ("Token.is(MIToken::JumpTableIndex)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1466, __PRETTY_FUNCTION__))
;
1467 unsigned ID;
1468 if (getUnsigned(ID))
1469 return true;
1470 auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
1471 if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
1472 return error("use of undefined jump table '%jump-table." + Twine(ID) + "'");
1473 lex();
1474 Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
1475 return false;
1476}
1477
1478bool MIParser::parseExternalSymbolOperand(MachineOperand &Dest) {
1479 assert(Token.is(MIToken::ExternalSymbol))((Token.is(MIToken::ExternalSymbol)) ? static_cast<void>
(0) : __assert_fail ("Token.is(MIToken::ExternalSymbol)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1479, __PRETTY_FUNCTION__))
;
1480 const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
1481 lex();
1482 Dest = MachineOperand::CreateES(Symbol);
1483 if (parseOperandsOffset(Dest))
1484 return true;
1485 return false;
1486}
1487
1488bool MIParser::parseSubRegisterIndexOperand(MachineOperand &Dest) {
1489 assert(Token.is(MIToken::SubRegisterIndex))((Token.is(MIToken::SubRegisterIndex)) ? static_cast<void>
(0) : __assert_fail ("Token.is(MIToken::SubRegisterIndex)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1489, __PRETTY_FUNCTION__))
;
1490 StringRef Name = Token.stringValue();
1491 unsigned SubRegIndex = getSubRegIndex(Token.stringValue());
1492 if (SubRegIndex == 0)
1493 return error(Twine("unknown subregister index '") + Name + "'");
1494 lex();
1495 Dest = MachineOperand::CreateImm(SubRegIndex);
1496 return false;
1497}
1498
1499bool MIParser::parseMDNode(MDNode *&Node) {
1500 assert(Token.is(MIToken::exclaim))((Token.is(MIToken::exclaim)) ? static_cast<void> (0) :
__assert_fail ("Token.is(MIToken::exclaim)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1500, __PRETTY_FUNCTION__))
;
1501
1502 auto Loc = Token.location();
1503 lex();
1504 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
1505 return error("expected metadata id after '!'");
1506 unsigned ID;
1507 if (getUnsigned(ID))
1508 return true;
1509 auto NodeInfo = PFS.IRSlots.MetadataNodes.find(ID);
1510 if (NodeInfo == PFS.IRSlots.MetadataNodes.end())
1511 return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
1512 lex();
1513 Node = NodeInfo->second.get();
1514 return false;
1515}
1516
1517bool MIParser::parseDIExpression(MDNode *&Expr) {
1518 assert(Token.is(MIToken::md_diexpr))((Token.is(MIToken::md_diexpr)) ? static_cast<void> (0)
: __assert_fail ("Token.is(MIToken::md_diexpr)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1518, __PRETTY_FUNCTION__))
;
1519 lex();
1520
1521 // FIXME: Share this parsing with the IL parser.
1522 SmallVector<uint64_t, 8> Elements;
1523
1524 if (expectAndConsume(MIToken::lparen))
1525 return true;
1526
1527 if (Token.isNot(MIToken::rparen)) {
1528 do {
1529 if (Token.is(MIToken::Identifier)) {
1530 if (unsigned Op = dwarf::getOperationEncoding(Token.stringValue())) {
1531 lex();
1532 Elements.push_back(Op);
1533 continue;
1534 }
1535 return error(Twine("invalid DWARF op '") + Token.stringValue() + "'");
1536 }
1537
1538 if (Token.isNot(MIToken::IntegerLiteral) ||
1539 Token.integerValue().isSigned())
1540 return error("expected unsigned integer");
1541
1542 auto &U = Token.integerValue();
1543 if (U.ugt(UINT64_MAX(18446744073709551615UL)))
1544 return error("element too large, limit is " + Twine(UINT64_MAX(18446744073709551615UL)));
1545 Elements.push_back(U.getZExtValue());
1546 lex();
1547
1548 } while (consumeIfPresent(MIToken::comma));
1549 }
1550
1551 if (expectAndConsume(MIToken::rparen))
1552 return true;
1553
1554 Expr = DIExpression::get(MF.getFunction()->getContext(), Elements);
1555 return false;
1556}
1557
1558bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
1559 MDNode *Node = nullptr;
1560 if (Token.is(MIToken::exclaim)) {
1561 if (parseMDNode(Node))
1562 return true;
1563 } else if (Token.is(MIToken::md_diexpr)) {
1564 if (parseDIExpression(Node))
1565 return true;
1566 }
1567 Dest = MachineOperand::CreateMetadata(Node);
1568 return false;
1569}
1570
1571bool MIParser::parseCFIOffset(int &Offset) {
1572 if (Token.isNot(MIToken::IntegerLiteral))
1573 return error("expected a cfi offset");
1574 if (Token.integerValue().getMinSignedBits() > 32)
1575 return error("expected a 32 bit integer (the cfi offset is too large)");
1576 Offset = (int)Token.integerValue().getExtValue();
1577 lex();
1578 return false;
1579}
1580
1581bool MIParser::parseCFIRegister(unsigned &Reg) {
1582 if (Token.isNot(MIToken::NamedRegister))
1583 return error("expected a cfi register");
1584 unsigned LLVMReg;
1585 if (parseNamedRegister(LLVMReg))
1586 return true;
1587 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1588 assert(TRI && "Expected target register info")((TRI && "Expected target register info") ? static_cast
<void> (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1588, __PRETTY_FUNCTION__))
;
1589 int DwarfReg = TRI->getDwarfRegNum(LLVMReg, true);
1590 if (DwarfReg < 0)
1591 return error("invalid DWARF register");
1592 Reg = (unsigned)DwarfReg;
1593 lex();
1594 return false;
1595}
1596
1597bool MIParser::parseCFIOperand(MachineOperand &Dest) {
1598 auto Kind = Token.kind();
1599 lex();
1600 int Offset;
1601 unsigned Reg;
1602 unsigned CFIIndex;
1603 switch (Kind) {
1604 case MIToken::kw_cfi_same_value:
1605 if (parseCFIRegister(Reg))
1606 return true;
1607 CFIIndex = MF.addFrameInst(MCCFIInstruction::createSameValue(nullptr, Reg));
1608 break;
1609 case MIToken::kw_cfi_offset:
1610 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1611 parseCFIOffset(Offset))
1612 return true;
1613 CFIIndex =
1614 MF.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
1615 break;
1616 case MIToken::kw_cfi_def_cfa_register:
1617 if (parseCFIRegister(Reg))
1618 return true;
1619 CFIIndex =
1620 MF.addFrameInst(MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
1621 break;
1622 case MIToken::kw_cfi_def_cfa_offset:
1623 if (parseCFIOffset(Offset))
1624 return true;
1625 // NB: MCCFIInstruction::createDefCfaOffset negates the offset.
1626 CFIIndex = MF.addFrameInst(
1627 MCCFIInstruction::createDefCfaOffset(nullptr, -Offset));
1628 break;
1629 case MIToken::kw_cfi_def_cfa:
1630 if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
1631 parseCFIOffset(Offset))
1632 return true;
1633 // NB: MCCFIInstruction::createDefCfa negates the offset.
1634 CFIIndex =
1635 MF.addFrameInst(MCCFIInstruction::createDefCfa(nullptr, Reg, -Offset));
1636 break;
1637 default:
1638 // TODO: Parse the other CFI operands.
1639 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~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1639)
;
1640 }
1641 Dest = MachineOperand::CreateCFIIndex(CFIIndex);
1642 return false;
1643}
1644
1645bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
1646 switch (Token.kind()) {
1647 case MIToken::NamedIRBlock: {
1648 BB = dyn_cast_or_null<BasicBlock>(
1649 F.getValueSymbolTable()->lookup(Token.stringValue()));
1650 if (!BB)
1651 return error(Twine("use of undefined IR block '") + Token.range() + "'");
1652 break;
1653 }
1654 case MIToken::IRBlock: {
1655 unsigned SlotNumber = 0;
1656 if (getUnsigned(SlotNumber))
1657 return true;
1658 BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
1659 if (!BB)
1660 return error(Twine("use of undefined IR block '%ir-block.") +
1661 Twine(SlotNumber) + "'");
1662 break;
1663 }
1664 default:
1665 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~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1665)
;
1666 }
1667 return false;
1668}
1669
1670bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
1671 assert(Token.is(MIToken::kw_blockaddress))((Token.is(MIToken::kw_blockaddress)) ? static_cast<void>
(0) : __assert_fail ("Token.is(MIToken::kw_blockaddress)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1671, __PRETTY_FUNCTION__))
;
1672 lex();
1673 if (expectAndConsume(MIToken::lparen))
5
Taking false branch
1674 return true;
1675 if (Token.isNot(MIToken::GlobalValue) &&
1676 Token.isNot(MIToken::NamedGlobalValue))
1677 return error("expected a global value");
1678 GlobalValue *GV = nullptr;
1679 if (parseGlobalValue(GV))
6
Calling 'MIParser::parseGlobalValue'
1680 return true;
1681 auto *F = dyn_cast<Function>(GV);
1682 if (!F)
1683 return error("expected an IR function reference");
1684 lex();
1685 if (expectAndConsume(MIToken::comma))
1686 return true;
1687 BasicBlock *BB = nullptr;
1688 if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
1689 return error("expected an IR block reference");
1690 if (parseIRBlock(BB, *F))
1691 return true;
1692 lex();
1693 if (expectAndConsume(MIToken::rparen))
1694 return true;
1695 Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
1696 if (parseOperandsOffset(Dest))
1697 return true;
1698 return false;
1699}
1700
1701bool MIParser::parseIntrinsicOperand(MachineOperand &Dest) {
1702 assert(Token.is(MIToken::kw_intrinsic))((Token.is(MIToken::kw_intrinsic)) ? static_cast<void> (
0) : __assert_fail ("Token.is(MIToken::kw_intrinsic)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1702, __PRETTY_FUNCTION__))
;
1703 lex();
1704 if (expectAndConsume(MIToken::lparen))
1705 return error("expected syntax intrinsic(@llvm.whatever)");
1706
1707 if (Token.isNot(MIToken::NamedGlobalValue))
1708 return error("expected syntax intrinsic(@llvm.whatever)");
1709
1710 std::string Name = Token.stringValue();
1711 lex();
1712
1713 if (expectAndConsume(MIToken::rparen))
1714 return error("expected ')' to terminate intrinsic name");
1715
1716 // Find out what intrinsic we're dealing with, first try the global namespace
1717 // and then the target's private intrinsics if that fails.
1718 const TargetIntrinsicInfo *TII = MF.getTarget().getIntrinsicInfo();
1719 Intrinsic::ID ID = Function::lookupIntrinsicID(Name);
1720 if (ID == Intrinsic::not_intrinsic && TII)
1721 ID = static_cast<Intrinsic::ID>(TII->lookupName(Name));
1722
1723 if (ID == Intrinsic::not_intrinsic)
1724 return error("unknown intrinsic name");
1725 Dest = MachineOperand::CreateIntrinsicID(ID);
1726
1727 return false;
1728}
1729
1730bool MIParser::parsePredicateOperand(MachineOperand &Dest) {
1731 assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred))((Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred
)) ? static_cast<void> (0) : __assert_fail ("Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred)"
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1731, __PRETTY_FUNCTION__))
;
1732 bool IsFloat = Token.is(MIToken::kw_floatpred);
1733 lex();
1734
1735 if (expectAndConsume(MIToken::lparen))
1736 return error("expected syntax intpred(whatever) or floatpred(whatever");
1737
1738 if (Token.isNot(MIToken::Identifier))
1739 return error("whatever");
1740
1741 CmpInst::Predicate Pred;
1742 if (IsFloat) {
1743 Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1744 .Case("false", CmpInst::FCMP_FALSE)
1745 .Case("oeq", CmpInst::FCMP_OEQ)
1746 .Case("ogt", CmpInst::FCMP_OGT)
1747 .Case("oge", CmpInst::FCMP_OGE)
1748 .Case("olt", CmpInst::FCMP_OLT)
1749 .Case("ole", CmpInst::FCMP_OLE)
1750 .Case("one", CmpInst::FCMP_ONE)
1751 .Case("ord", CmpInst::FCMP_ORD)
1752 .Case("uno", CmpInst::FCMP_UNO)
1753 .Case("ueq", CmpInst::FCMP_UEQ)
1754 .Case("ugt", CmpInst::FCMP_UGT)
1755 .Case("uge", CmpInst::FCMP_UGE)
1756 .Case("ult", CmpInst::FCMP_ULT)
1757 .Case("ule", CmpInst::FCMP_ULE)
1758 .Case("une", CmpInst::FCMP_UNE)
1759 .Case("true", CmpInst::FCMP_TRUE)
1760 .Default(CmpInst::BAD_FCMP_PREDICATE);
1761 if (!CmpInst::isFPPredicate(Pred))
1762 return error("invalid floating-point predicate");
1763 } else {
1764 Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1765 .Case("eq", CmpInst::ICMP_EQ)
1766 .Case("ne", CmpInst::ICMP_NE)
1767 .Case("sgt", CmpInst::ICMP_SGT)
1768 .Case("sge", CmpInst::ICMP_SGE)
1769 .Case("slt", CmpInst::ICMP_SLT)
1770 .Case("sle", CmpInst::ICMP_SLE)
1771 .Case("ugt", CmpInst::ICMP_UGT)
1772 .Case("uge", CmpInst::ICMP_UGE)
1773 .Case("ult", CmpInst::ICMP_ULT)
1774 .Case("ule", CmpInst::ICMP_ULE)
1775 .Default(CmpInst::BAD_ICMP_PREDICATE);
1776 if (!CmpInst::isIntPredicate(Pred))
1777 return error("invalid integer predicate");
1778 }
1779
1780 lex();
1781 Dest = MachineOperand::CreatePredicate(Pred);
1782 if (expectAndConsume(MIToken::rparen))
1783 return error("predicate should be terminated by ')'.");
1784
1785 return false;
1786}
1787
1788bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
1789 assert(Token.is(MIToken::kw_target_index))((Token.is(MIToken::kw_target_index)) ? static_cast<void>
(0) : __assert_fail ("Token.is(MIToken::kw_target_index)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1789, __PRETTY_FUNCTION__))
;
1790 lex();
1791 if (expectAndConsume(MIToken::lparen))
1792 return true;
1793 if (Token.isNot(MIToken::Identifier))
1794 return error("expected the name of the target index");
1795 int Index = 0;
1796 if (getTargetIndex(Token.stringValue(), Index))
1797 return error("use of undefined target index '" + Token.stringValue() + "'");
1798 lex();
1799 if (expectAndConsume(MIToken::rparen))
1800 return true;
1801 Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
1802 if (parseOperandsOffset(Dest))
1803 return true;
1804 return false;
1805}
1806
1807bool MIParser::parseCustomRegisterMaskOperand(MachineOperand &Dest) {
1808 assert(Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask")((Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask"
) ? static_cast<void> (0) : __assert_fail ("Token.stringValue() == \"CustomRegMask\" && \"Expected a custom RegMask\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1808, __PRETTY_FUNCTION__))
;
1809 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
1810 assert(TRI && "Expected target register info")((TRI && "Expected target register info") ? static_cast
<void> (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1810, __PRETTY_FUNCTION__))
;
1811 lex();
1812 if (expectAndConsume(MIToken::lparen))
1813 return true;
1814
1815 uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1816 while (true) {
1817 if (Token.isNot(MIToken::NamedRegister))
1818 return error("expected a named register");
1819 unsigned Reg;
1820 if (parseNamedRegister(Reg))
1821 return true;
1822 lex();
1823 Mask[Reg / 32] |= 1U << (Reg % 32);
1824 // TODO: Report an error if the same register is used more than once.
1825 if (Token.isNot(MIToken::comma))
1826 break;
1827 lex();
1828 }
1829
1830 if (expectAndConsume(MIToken::rparen))
1831 return true;
1832 Dest = MachineOperand::CreateRegMask(Mask);
1833 return false;
1834}
1835
1836bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
1837 assert(Token.is(MIToken::kw_liveout))((Token.is(MIToken::kw_liveout)) ? static_cast<void> (0
) : __assert_fail ("Token.is(MIToken::kw_liveout)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1837, __PRETTY_FUNCTION__))
;
1838 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1839 assert(TRI && "Expected target register info")((TRI && "Expected target register info") ? static_cast
<void> (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 1839, __PRETTY_FUNCTION__))
;
1840 uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1841 lex();
1842 if (expectAndConsume(MIToken::lparen))
1843 return true;
1844 while (true) {
1845 if (Token.isNot(MIToken::NamedRegister))
1846 return error("expected a named register");
1847 unsigned Reg;
1848 if (parseNamedRegister(Reg))
1849 return true;
1850 lex();
1851 Mask[Reg / 32] |= 1U << (Reg % 32);
1852 // TODO: Report an error if the same register is used more than once.
1853 if (Token.isNot(MIToken::comma))
1854 break;
1855 lex();
1856 }
1857 if (expectAndConsume(MIToken::rparen))
1858 return true;
1859 Dest = MachineOperand::CreateRegLiveOut(Mask);
1860 return false;
1861}
1862
1863bool MIParser::parseMachineOperand(MachineOperand &Dest,
1864 Optional<unsigned> &TiedDefIdx) {
1865 switch (Token.kind()) {
3
Control jumps to 'case kw_blockaddress:' at line 1916
1866 case MIToken::kw_implicit:
1867 case MIToken::kw_implicit_define:
1868 case MIToken::kw_def:
1869 case MIToken::kw_dead:
1870 case MIToken::kw_killed:
1871 case MIToken::kw_undef:
1872 case MIToken::kw_internal:
1873 case MIToken::kw_early_clobber:
1874 case MIToken::kw_debug_use:
1875 case MIToken::underscore:
1876 case MIToken::NamedRegister:
1877 case MIToken::VirtualRegister:
1878 return parseRegisterOperand(Dest, TiedDefIdx);
1879 case MIToken::IntegerLiteral:
1880 return parseImmediateOperand(Dest);
1881 case MIToken::IntegerType:
1882 return parseTypedImmediateOperand(Dest);
1883 case MIToken::kw_half:
1884 case MIToken::kw_float:
1885 case MIToken::kw_double:
1886 case MIToken::kw_x86_fp80:
1887 case MIToken::kw_fp128:
1888 case MIToken::kw_ppc_fp128:
1889 return parseFPImmediateOperand(Dest);
1890 case MIToken::MachineBasicBlock:
1891 return parseMBBOperand(Dest);
1892 case MIToken::StackObject:
1893 return parseStackObjectOperand(Dest);
1894 case MIToken::FixedStackObject:
1895 return parseFixedStackObjectOperand(Dest);
1896 case MIToken::GlobalValue:
1897 case MIToken::NamedGlobalValue:
1898 return parseGlobalAddressOperand(Dest);
1899 case MIToken::ConstantPoolItem:
1900 return parseConstantPoolIndexOperand(Dest);
1901 case MIToken::JumpTableIndex:
1902 return parseJumpTableIndexOperand(Dest);
1903 case MIToken::ExternalSymbol:
1904 return parseExternalSymbolOperand(Dest);
1905 case MIToken::SubRegisterIndex:
1906 return parseSubRegisterIndexOperand(Dest);
1907 case MIToken::md_diexpr:
1908 case MIToken::exclaim:
1909 return parseMetadataOperand(Dest);
1910 case MIToken::kw_cfi_same_value:
1911 case MIToken::kw_cfi_offset:
1912 case MIToken::kw_cfi_def_cfa_register:
1913 case MIToken::kw_cfi_def_cfa_offset:
1914 case MIToken::kw_cfi_def_cfa:
1915 return parseCFIOperand(Dest);
1916 case MIToken::kw_blockaddress:
1917 return parseBlockAddressOperand(Dest);
4
Calling 'MIParser::parseBlockAddressOperand'
1918 case MIToken::kw_intrinsic:
1919 return parseIntrinsicOperand(Dest);
1920 case MIToken::kw_target_index:
1921 return parseTargetIndexOperand(Dest);
1922 case MIToken::kw_liveout:
1923 return parseLiveoutRegisterMaskOperand(Dest);
1924 case MIToken::kw_floatpred:
1925 case MIToken::kw_intpred:
1926 return parsePredicateOperand(Dest);
1927 case MIToken::Error:
1928 return true;
1929 case MIToken::Identifier:
1930 if (const auto *RegMask = getRegMask(Token.stringValue())) {
1931 Dest = MachineOperand::CreateRegMask(RegMask);
1932 lex();
1933 break;
1934 } else
1935 return parseCustomRegisterMaskOperand(Dest);
1936 default:
1937 // FIXME: Parse the MCSymbol machine operand.
1938 return error("expected a machine operand");
1939 }
1940 return false;
1941}
1942
1943bool MIParser::parseMachineOperandAndTargetFlags(
1944 MachineOperand &Dest, Optional<unsigned> &TiedDefIdx) {
1945 unsigned TF = 0;
1946 bool HasTargetFlags = false;
1947 if (Token.is(MIToken::kw_target_flags)) {
1
Taking false branch
1948 HasTargetFlags = true;
1949 lex();
1950 if (expectAndConsume(MIToken::lparen))
1951 return true;
1952 if (Token.isNot(MIToken::Identifier))
1953 return error("expected the name of the target flag");
1954 if (getDirectTargetFlag(Token.stringValue(), TF)) {
1955 if (getBitmaskTargetFlag(Token.stringValue(), TF))
1956 return error("use of undefined target flag '" + Token.stringValue() +
1957 "'");
1958 }
1959 lex();
1960 while (Token.is(MIToken::comma)) {
1961 lex();
1962 if (Token.isNot(MIToken::Identifier))
1963 return error("expected the name of the target flag");
1964 unsigned BitFlag = 0;
1965 if (getBitmaskTargetFlag(Token.stringValue(), BitFlag))
1966 return error("use of undefined target flag '" + Token.stringValue() +
1967 "'");
1968 // TODO: Report an error when using a duplicate bit target flag.
1969 TF |= BitFlag;
1970 lex();
1971 }
1972 if (expectAndConsume(MIToken::rparen))
1973 return true;
1974 }
1975 auto Loc = Token.location();
1976 if (parseMachineOperand(Dest, TiedDefIdx))
2
Calling 'MIParser::parseMachineOperand'
1977 return true;
1978 if (!HasTargetFlags)
1979 return false;
1980 if (Dest.isReg())
1981 return error(Loc, "register operands can't have target flags");
1982 Dest.setTargetFlags(TF);
1983 return false;
1984}
1985
1986bool MIParser::parseOffset(int64_t &Offset) {
1987 if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
1988 return false;
1989 StringRef Sign = Token.range();
1990 bool IsNegative = Token.is(MIToken::minus);
1991 lex();
1992 if (Token.isNot(MIToken::IntegerLiteral))
1993 return error("expected an integer literal after '" + Sign + "'");
1994 if (Token.integerValue().getMinSignedBits() > 64)
1995 return error("expected 64-bit integer (too large)");
1996 Offset = Token.integerValue().getExtValue();
1997 if (IsNegative)
1998 Offset = -Offset;
1999 lex();
2000 return false;
2001}
2002
2003bool MIParser::parseAlignment(unsigned &Alignment) {
2004 assert(Token.is(MIToken::kw_align))((Token.is(MIToken::kw_align)) ? static_cast<void> (0) :
__assert_fail ("Token.is(MIToken::kw_align)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2004, __PRETTY_FUNCTION__))
;
2005 lex();
2006 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
2007 return error("expected an integer literal after 'align'");
2008 if (getUnsigned(Alignment))
2009 return true;
2010 lex();
2011 return false;
2012}
2013
2014bool MIParser::parseOperandsOffset(MachineOperand &Op) {
2015 int64_t Offset = 0;
2016 if (parseOffset(Offset))
2017 return true;
2018 Op.setOffset(Offset);
2019 return false;
2020}
2021
2022bool MIParser::parseIRValue(const Value *&V) {
2023 switch (Token.kind()) {
2024 case MIToken::NamedIRValue: {
2025 V = MF.getFunction()->getValueSymbolTable()->lookup(Token.stringValue());
2026 break;
2027 }
2028 case MIToken::IRValue: {
2029 unsigned SlotNumber = 0;
2030 if (getUnsigned(SlotNumber))
2031 return true;
2032 V = getIRValue(SlotNumber);
2033 break;
2034 }
2035 case MIToken::NamedGlobalValue:
2036 case MIToken::GlobalValue: {
2037 GlobalValue *GV = nullptr;
2038 if (parseGlobalValue(GV))
2039 return true;
2040 V = GV;
2041 break;
2042 }
2043 case MIToken::QuotedIRValue: {
2044 const Constant *C = nullptr;
2045 if (parseIRConstant(Token.location(), Token.stringValue(), C))
2046 return true;
2047 V = C;
2048 break;
2049 }
2050 default:
2051 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~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2051)
;
2052 }
2053 if (!V)
2054 return error(Twine("use of undefined IR value '") + Token.range() + "'");
2055 return false;
2056}
2057
2058bool MIParser::getUint64(uint64_t &Result) {
2059 if (Token.hasIntegerValue()) {
2060 if (Token.integerValue().getActiveBits() > 64)
2061 return error("expected 64-bit integer (too large)");
2062 Result = Token.integerValue().getZExtValue();
2063 return false;
2064 }
2065 if (Token.is(MIToken::HexLiteral)) {
2066 APInt A;
2067 if (getHexUint(A))
2068 return true;
2069 if (A.getBitWidth() > 64)
2070 return error("expected 64-bit integer (too large)");
2071 Result = A.getZExtValue();
2072 return false;
2073 }
2074 return true;
2075}
2076
2077bool MIParser::getHexUint(APInt &Result) {
2078 assert(Token.is(MIToken::HexLiteral))((Token.is(MIToken::HexLiteral)) ? static_cast<void> (0
) : __assert_fail ("Token.is(MIToken::HexLiteral)", "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2078, __PRETTY_FUNCTION__))
;
2079 StringRef S = Token.range();
2080 assert(S[0] == '0' && tolower(S[1]) == 'x')((S[0] == '0' && tolower(S[1]) == 'x') ? static_cast<
void> (0) : __assert_fail ("S[0] == '0' && tolower(S[1]) == 'x'"
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2080, __PRETTY_FUNCTION__))
;
2081 // This could be a floating point literal with a special prefix.
2082 if (!isxdigit(S[2]))
2083 return true;
2084 StringRef V = S.substr(2);
2085 APInt A(V.size()*4, V, 16);
2086
2087 // If A is 0, then A.getActiveBits() is 0. This isn't a valid bitwidth. Make
2088 // sure it isn't the case before constructing result.
2089 unsigned NumBits = (A == 0) ? 32 : A.getActiveBits();
2090 Result = APInt(NumBits, ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
2091 return false;
2092}
2093
2094bool MIParser::parseMemoryOperandFlag(MachineMemOperand::Flags &Flags) {
2095 const auto OldFlags = Flags;
2096 switch (Token.kind()) {
2097 case MIToken::kw_volatile:
2098 Flags |= MachineMemOperand::MOVolatile;
2099 break;
2100 case MIToken::kw_non_temporal:
2101 Flags |= MachineMemOperand::MONonTemporal;
2102 break;
2103 case MIToken::kw_dereferenceable:
2104 Flags |= MachineMemOperand::MODereferenceable;
2105 break;
2106 case MIToken::kw_invariant:
2107 Flags |= MachineMemOperand::MOInvariant;
2108 break;
2109 case MIToken::StringConstant: {
2110 MachineMemOperand::Flags TF;
2111 if (getMMOTargetFlag(Token.stringValue(), TF))
2112 return error("use of undefined target MMO flag '" + Token.stringValue() +
2113 "'");
2114 Flags |= TF;
2115 break;
2116 }
2117 default:
2118 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~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2118)
;
2119 }
2120 if (OldFlags == Flags)
2121 // We know that the same flag is specified more than once when the flags
2122 // weren't modified.
2123 return error("duplicate '" + Token.stringValue() + "' memory operand flag");
2124 lex();
2125 return false;
2126}
2127
2128bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
2129 switch (Token.kind()) {
2130 case MIToken::kw_stack:
2131 PSV = MF.getPSVManager().getStack();
2132 break;
2133 case MIToken::kw_got:
2134 PSV = MF.getPSVManager().getGOT();
2135 break;
2136 case MIToken::kw_jump_table:
2137 PSV = MF.getPSVManager().getJumpTable();
2138 break;
2139 case MIToken::kw_constant_pool:
2140 PSV = MF.getPSVManager().getConstantPool();
2141 break;
2142 case MIToken::FixedStackObject: {
2143 int FI;
2144 if (parseFixedStackFrameIndex(FI))
2145 return true;
2146 PSV = MF.getPSVManager().getFixedStack(FI);
2147 // The token was already consumed, so use return here instead of break.
2148 return false;
2149 }
2150 case MIToken::StackObject: {
2151 int FI;
2152 if (parseStackFrameIndex(FI))
2153 return true;
2154 PSV = MF.getPSVManager().getFixedStack(FI);
2155 // The token was already consumed, so use return here instead of break.
2156 return false;
2157 }
2158 case MIToken::kw_call_entry:
2159 lex();
2160 switch (Token.kind()) {
2161 case MIToken::GlobalValue:
2162 case MIToken::NamedGlobalValue: {
2163 GlobalValue *GV = nullptr;
2164 if (parseGlobalValue(GV))
2165 return true;
2166 PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
2167 break;
2168 }
2169 case MIToken::ExternalSymbol:
2170 PSV = MF.getPSVManager().getExternalSymbolCallEntry(
2171 MF.createExternalSymbolName(Token.stringValue()));
2172 break;
2173 default:
2174 return error(
2175 "expected a global value or an external symbol after 'call-entry'");
2176 }
2177 break;
2178 default:
2179 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~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2179)
;
2180 }
2181 lex();
2182 return false;
2183}
2184
2185bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
2186 if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
2187 Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
2188 Token.is(MIToken::FixedStackObject) || Token.is(MIToken::StackObject) ||
2189 Token.is(MIToken::kw_call_entry)) {
2190 const PseudoSourceValue *PSV = nullptr;
2191 if (parseMemoryPseudoSourceValue(PSV))
2192 return true;
2193 int64_t Offset = 0;
2194 if (parseOffset(Offset))
2195 return true;
2196 Dest = MachinePointerInfo(PSV, Offset);
2197 return false;
2198 }
2199 if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue) &&
2200 Token.isNot(MIToken::GlobalValue) &&
2201 Token.isNot(MIToken::NamedGlobalValue) &&
2202 Token.isNot(MIToken::QuotedIRValue))
2203 return error("expected an IR value reference");
2204 const Value *V = nullptr;
2205 if (parseIRValue(V))
2206 return true;
2207 if (!V->getType()->isPointerTy())
2208 return error("expected a pointer IR value");
2209 lex();
2210 int64_t Offset = 0;
2211 if (parseOffset(Offset))
2212 return true;
2213 Dest = MachinePointerInfo(V, Offset);
2214 return false;
2215}
2216
2217bool MIParser::parseOptionalScope(LLVMContext &Context,
2218 SyncScope::ID &SSID) {
2219 SSID = SyncScope::System;
2220 if (Token.is(MIToken::Identifier) && Token.stringValue() == "syncscope") {
2221 lex();
2222 if (expectAndConsume(MIToken::lparen))
2223 return error("expected '(' in syncscope");
2224
2225 std::string SSN;
2226 if (parseStringConstant(SSN))
2227 return true;
2228
2229 SSID = Context.getOrInsertSyncScopeID(SSN);
2230 if (expectAndConsume(MIToken::rparen))
2231 return error("expected ')' in syncscope");
2232 }
2233
2234 return false;
2235}
2236
2237bool MIParser::parseOptionalAtomicOrdering(AtomicOrdering &Order) {
2238 Order = AtomicOrdering::NotAtomic;
2239 if (Token.isNot(MIToken::Identifier))
2240 return false;
2241
2242 Order = StringSwitch<AtomicOrdering>(Token.stringValue())
2243 .Case("unordered", AtomicOrdering::Unordered)
2244 .Case("monotonic", AtomicOrdering::Monotonic)
2245 .Case("acquire", AtomicOrdering::Acquire)
2246 .Case("release", AtomicOrdering::Release)
2247 .Case("acq_rel", AtomicOrdering::AcquireRelease)
2248 .Case("seq_cst", AtomicOrdering::SequentiallyConsistent)
2249 .Default(AtomicOrdering::NotAtomic);
2250
2251 if (Order != AtomicOrdering::NotAtomic) {
2252 lex();
2253 return false;
2254 }
2255
2256 return error("expected an atomic scope, ordering or a size integer literal");
2257}
2258
2259bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
2260 if (expectAndConsume(MIToken::lparen))
2261 return true;
2262 MachineMemOperand::Flags Flags = MachineMemOperand::MONone;
2263 while (Token.isMemoryOperandFlag()) {
2264 if (parseMemoryOperandFlag(Flags))
2265 return true;
2266 }
2267 if (Token.isNot(MIToken::Identifier) ||
2268 (Token.stringValue() != "load" && Token.stringValue() != "store"))
2269 return error("expected 'load' or 'store' memory operation");
2270 if (Token.stringValue() == "load")
2271 Flags |= MachineMemOperand::MOLoad;
2272 else
2273 Flags |= MachineMemOperand::MOStore;
2274 lex();
2275
2276 // Optional synchronization scope.
2277 SyncScope::ID SSID;
2278 if (parseOptionalScope(MF.getFunction()->getContext(), SSID))
2279 return true;
2280
2281 // Up to two atomic orderings (cmpxchg provides guarantees on failure).
2282 AtomicOrdering Order, FailureOrder;
2283 if (parseOptionalAtomicOrdering(Order))
2284 return true;
2285
2286 if (parseOptionalAtomicOrdering(FailureOrder))
2287 return true;
2288
2289 if (Token.isNot(MIToken::IntegerLiteral))
2290 return error("expected the size integer literal after memory operation");
2291 uint64_t Size;
2292 if (getUint64(Size))
2293 return true;
2294 lex();
2295
2296 MachinePointerInfo Ptr = MachinePointerInfo();
2297 if (Token.is(MIToken::Identifier)) {
2298 const char *Word = Flags & MachineMemOperand::MOLoad ? "from" : "into";
2299 if (Token.stringValue() != Word)
2300 return error(Twine("expected '") + Word + "'");
2301 lex();
2302
2303 if (parseMachinePointerInfo(Ptr))
2304 return true;
2305 }
2306 unsigned BaseAlignment = Size;
2307 AAMDNodes AAInfo;
2308 MDNode *Range = nullptr;
2309 while (consumeIfPresent(MIToken::comma)) {
2310 switch (Token.kind()) {
2311 case MIToken::kw_align:
2312 if (parseAlignment(BaseAlignment))
2313 return true;
2314 break;
2315 case MIToken::md_tbaa:
2316 lex();
2317 if (parseMDNode(AAInfo.TBAA))
2318 return true;
2319 break;
2320 case MIToken::md_alias_scope:
2321 lex();
2322 if (parseMDNode(AAInfo.Scope))
2323 return true;
2324 break;
2325 case MIToken::md_noalias:
2326 lex();
2327 if (parseMDNode(AAInfo.NoAlias))
2328 return true;
2329 break;
2330 case MIToken::md_range:
2331 lex();
2332 if (parseMDNode(Range))
2333 return true;
2334 break;
2335 // TODO: Report an error on duplicate metadata nodes.
2336 default:
2337 return error("expected 'align' or '!tbaa' or '!alias.scope' or "
2338 "'!noalias' or '!range'");
2339 }
2340 }
2341 if (expectAndConsume(MIToken::rparen))
2342 return true;
2343 Dest = MF.getMachineMemOperand(Ptr, Flags, Size, BaseAlignment, AAInfo, Range,
2344 SSID, Order, FailureOrder);
2345 return false;
2346}
2347
2348void MIParser::initNames2InstrOpCodes() {
2349 if (!Names2InstrOpCodes.empty())
2350 return;
2351 const auto *TII = MF.getSubtarget().getInstrInfo();
2352 assert(TII && "Expected target instruction info")((TII && "Expected target instruction info") ? static_cast
<void> (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2352, __PRETTY_FUNCTION__))
;
2353 for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
2354 Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
2355}
2356
2357bool MIParser::parseInstrName(StringRef InstrName, unsigned &OpCode) {
2358 initNames2InstrOpCodes();
2359 auto InstrInfo = Names2InstrOpCodes.find(InstrName);
2360 if (InstrInfo == Names2InstrOpCodes.end())
2361 return true;
2362 OpCode = InstrInfo->getValue();
2363 return false;
2364}
2365
2366void MIParser::initNames2Regs() {
2367 if (!Names2Regs.empty())
2368 return;
2369 // The '%noreg' register is the register 0.
2370 Names2Regs.insert(std::make_pair("noreg", 0));
2371 const auto *TRI = MF.getSubtarget().getRegisterInfo();
2372 assert(TRI && "Expected target register info")((TRI && "Expected target register info") ? static_cast
<void> (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2372, __PRETTY_FUNCTION__))
;
2373 for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
2374 bool WasInserted =
2375 Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
2376 .second;
2377 (void)WasInserted;
2378 assert(WasInserted && "Expected registers to be unique case-insensitively")((WasInserted && "Expected registers to be unique case-insensitively"
) ? static_cast<void> (0) : __assert_fail ("WasInserted && \"Expected registers to be unique case-insensitively\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2378, __PRETTY_FUNCTION__))
;
2379 }
2380}
2381
2382bool MIParser::getRegisterByName(StringRef RegName, unsigned &Reg) {
2383 initNames2Regs();
2384 auto RegInfo = Names2Regs.find(RegName);
2385 if (RegInfo == Names2Regs.end())
2386 return true;
2387 Reg = RegInfo->getValue();
2388 return false;
2389}
2390
2391void MIParser::initNames2RegMasks() {
2392 if (!Names2RegMasks.empty())
2393 return;
2394 const auto *TRI = MF.getSubtarget().getRegisterInfo();
2395 assert(TRI && "Expected target register info")((TRI && "Expected target register info") ? static_cast
<void> (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2395, __PRETTY_FUNCTION__))
;
2396 ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
2397 ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
2398 assert(RegMasks.size() == RegMaskNames.size())((RegMasks.size() == RegMaskNames.size()) ? static_cast<void
> (0) : __assert_fail ("RegMasks.size() == RegMaskNames.size()"
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2398, __PRETTY_FUNCTION__))
;
2399 for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
2400 Names2RegMasks.insert(
2401 std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
2402}
2403
2404const uint32_t *MIParser::getRegMask(StringRef Identifier) {
2405 initNames2RegMasks();
2406 auto RegMaskInfo = Names2RegMasks.find(Identifier);
2407 if (RegMaskInfo == Names2RegMasks.end())
2408 return nullptr;
2409 return RegMaskInfo->getValue();
2410}
2411
2412void MIParser::initNames2SubRegIndices() {
2413 if (!Names2SubRegIndices.empty())
2414 return;
2415 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
2416 for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
2417 Names2SubRegIndices.insert(
2418 std::make_pair(StringRef(TRI->getSubRegIndexName(I)).lower(), I));
2419}
2420
2421unsigned MIParser::getSubRegIndex(StringRef Name) {
2422 initNames2SubRegIndices();
2423 auto SubRegInfo = Names2SubRegIndices.find(Name);
2424 if (SubRegInfo == Names2SubRegIndices.end())
2425 return 0;
2426 return SubRegInfo->getValue();
2427}
2428
2429static void initSlots2BasicBlocks(
2430 const Function &F,
2431 DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2432 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2433 MST.incorporateFunction(F);
2434 for (auto &BB : F) {
2435 if (BB.hasName())
2436 continue;
2437 int Slot = MST.getLocalSlot(&BB);
2438 if (Slot == -1)
2439 continue;
2440 Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
2441 }
2442}
2443
2444static const BasicBlock *getIRBlockFromSlot(
2445 unsigned Slot,
2446 const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2447 auto BlockInfo = Slots2BasicBlocks.find(Slot);
2448 if (BlockInfo == Slots2BasicBlocks.end())
2449 return nullptr;
2450 return BlockInfo->second;
2451}
2452
2453const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
2454 if (Slots2BasicBlocks.empty())
2455 initSlots2BasicBlocks(*MF.getFunction(), Slots2BasicBlocks);
2456 return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
2457}
2458
2459const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
2460 if (&F == MF.getFunction())
2461 return getIRBlock(Slot);
2462 DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
2463 initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
2464 return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
2465}
2466
2467static void mapValueToSlot(const Value *V, ModuleSlotTracker &MST,
2468 DenseMap<unsigned, const Value *> &Slots2Values) {
2469 int Slot = MST.getLocalSlot(V);
2470 if (Slot == -1)
2471 return;
2472 Slots2Values.insert(std::make_pair(unsigned(Slot), V));
2473}
2474
2475/// Creates the mapping from slot numbers to function's unnamed IR values.
2476static void initSlots2Values(const Function &F,
2477 DenseMap<unsigned, const Value *> &Slots2Values) {
2478 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2479 MST.incorporateFunction(F);
2480 for (const auto &Arg : F.args())
2481 mapValueToSlot(&Arg, MST, Slots2Values);
2482 for (const auto &BB : F) {
2483 mapValueToSlot(&BB, MST, Slots2Values);
2484 for (const auto &I : BB)
2485 mapValueToSlot(&I, MST, Slots2Values);
2486 }
2487}
2488
2489const Value *MIParser::getIRValue(unsigned Slot) {
2490 if (Slots2Values.empty())
2491 initSlots2Values(*MF.getFunction(), Slots2Values);
2492 auto ValueInfo = Slots2Values.find(Slot);
2493 if (ValueInfo == Slots2Values.end())
2494 return nullptr;
2495 return ValueInfo->second;
2496}
2497
2498void MIParser::initNames2TargetIndices() {
2499 if (!Names2TargetIndices.empty())
2500 return;
2501 const auto *TII = MF.getSubtarget().getInstrInfo();
2502 assert(TII && "Expected target instruction info")((TII && "Expected target instruction info") ? static_cast
<void> (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2502, __PRETTY_FUNCTION__))
;
2503 auto Indices = TII->getSerializableTargetIndices();
2504 for (const auto &I : Indices)
2505 Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
2506}
2507
2508bool MIParser::getTargetIndex(StringRef Name, int &Index) {
2509 initNames2TargetIndices();
2510 auto IndexInfo = Names2TargetIndices.find(Name);
2511 if (IndexInfo == Names2TargetIndices.end())
2512 return true;
2513 Index = IndexInfo->second;
2514 return false;
2515}
2516
2517void MIParser::initNames2DirectTargetFlags() {
2518 if (!Names2DirectTargetFlags.empty())
2519 return;
2520 const auto *TII = MF.getSubtarget().getInstrInfo();
2521 assert(TII && "Expected target instruction info")((TII && "Expected target instruction info") ? static_cast
<void> (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2521, __PRETTY_FUNCTION__))
;
2522 auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
2523 for (const auto &I : Flags)
2524 Names2DirectTargetFlags.insert(
2525 std::make_pair(StringRef(I.second), I.first));
2526}
2527
2528bool MIParser::getDirectTargetFlag(StringRef Name, unsigned &Flag) {
2529 initNames2DirectTargetFlags();
2530 auto FlagInfo = Names2DirectTargetFlags.find(Name);
2531 if (FlagInfo == Names2DirectTargetFlags.end())
2532 return true;
2533 Flag = FlagInfo->second;
2534 return false;
2535}
2536
2537void MIParser::initNames2BitmaskTargetFlags() {
2538 if (!Names2BitmaskTargetFlags.empty())
2539 return;
2540 const auto *TII = MF.getSubtarget().getInstrInfo();
2541 assert(TII && "Expected target instruction info")((TII && "Expected target instruction info") ? static_cast
<void> (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2541, __PRETTY_FUNCTION__))
;
2542 auto Flags = TII->getSerializableBitmaskMachineOperandTargetFlags();
2543 for (const auto &I : Flags)
2544 Names2BitmaskTargetFlags.insert(
2545 std::make_pair(StringRef(I.second), I.first));
2546}
2547
2548bool MIParser::getBitmaskTargetFlag(StringRef Name, unsigned &Flag) {
2549 initNames2BitmaskTargetFlags();
2550 auto FlagInfo = Names2BitmaskTargetFlags.find(Name);
2551 if (FlagInfo == Names2BitmaskTargetFlags.end())
2552 return true;
2553 Flag = FlagInfo->second;
2554 return false;
2555}
2556
2557void MIParser::initNames2MMOTargetFlags() {
2558 if (!Names2MMOTargetFlags.empty())
2559 return;
2560 const auto *TII = MF.getSubtarget().getInstrInfo();
2561 assert(TII && "Expected target instruction info")((TII && "Expected target instruction info") ? static_cast
<void> (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-6.0~svn316068/lib/CodeGen/MIRParser/MIParser.cpp"
, 2561, __PRETTY_FUNCTION__))
;
2562 auto Flags = TII->getSerializableMachineMemOperandTargetFlags();
2563 for (const auto &I : Flags)
2564 Names2MMOTargetFlags.insert(
2565 std::make_pair(StringRef(I.second), I.first));
2566}
2567
2568bool MIParser::getMMOTargetFlag(StringRef Name,
2569 MachineMemOperand::Flags &Flag) {
2570 initNames2MMOTargetFlags();
2571 auto FlagInfo = Names2MMOTargetFlags.find(Name);
2572 if (FlagInfo == Names2MMOTargetFlags.end())
2573 return true;
2574 Flag = FlagInfo->second;
2575 return false;
2576}
2577
2578bool MIParser::parseStringConstant(std::string &Result) {
2579 if (Token.isNot(MIToken::StringConstant))
2580 return error("expected string constant");
2581 Result = Token.stringValue();
2582 lex();
2583 return false;
2584}
2585
2586bool llvm::parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS,
2587 StringRef Src,
2588 SMDiagnostic &Error) {
2589 return MIParser(PFS, Error, Src).parseBasicBlockDefinitions(PFS.MBBSlots);
2590}
2591
2592bool llvm::parseMachineInstructions(PerFunctionMIParsingState &PFS,
2593 StringRef Src, SMDiagnostic &Error) {
2594 return MIParser(PFS, Error, Src).parseBasicBlocks();
2595}
2596
2597bool llvm::parseMBBReference(PerFunctionMIParsingState &PFS,
2598 MachineBasicBlock *&MBB, StringRef Src,
2599 SMDiagnostic &Error) {
2600 return MIParser(PFS, Error, Src).parseStandaloneMBB(MBB);
2601}
2602
2603bool llvm::parseRegisterReference(PerFunctionMIParsingState &PFS,
2604 unsigned &Reg, StringRef Src,
2605 SMDiagnostic &Error) {
2606 return MIParser(PFS, Error, Src).parseStandaloneRegister(Reg);
2607}
2608
2609bool llvm::parseNamedRegisterReference(PerFunctionMIParsingState &PFS,
2610 unsigned &Reg, StringRef Src,
2611 SMDiagnostic &Error) {
2612 return MIParser(PFS, Error, Src).parseStandaloneNamedRegister(Reg);
2613}
2614
2615bool llvm::parseVirtualRegisterReference(PerFunctionMIParsingState &PFS,
2616 VRegInfo *&Info, StringRef Src,
2617 SMDiagnostic &Error) {
2618 return MIParser(PFS, Error, Src).parseStandaloneVirtualRegister(Info);
2619}
2620
2621bool llvm::parseStackObjectReference(PerFunctionMIParsingState &PFS,
2622 int &FI, StringRef Src,
2623 SMDiagnostic &Error) {
2624 return MIParser(PFS, Error, Src).parseStandaloneStackObject(FI);
2625}
2626
2627bool llvm::parseMDNode(PerFunctionMIParsingState &PFS,
2628 MDNode *&Node, StringRef Src, SMDiagnostic &Error) {
2629 return MIParser(PFS, Error, Src).parseStandaloneMDNode(Node);
2630}