Bug Summary

File:lib/CodeGen/MIRParser/MIParser.cpp
Warning:line 1511, column 56
1st function call argument is an uninitialized value

Annotated Source Code

1//===- MIParser.cpp - Machine instructions parser implementation ----------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the parsing of machine instructions.
11//
12//===----------------------------------------------------------------------===//
13
14#include "MIParser.h"
15#include "MILexer.h"
16#include "llvm/ADT/APInt.h"
17#include "llvm/ADT/APSInt.h"
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/DenseMap.h"
20#include "llvm/ADT/None.h"
21#include "llvm/ADT/Optional.h"
22#include "llvm/ADT/SmallVector.h"
23#include "llvm/ADT/StringMap.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/ADT/StringSwitch.h"
26#include "llvm/ADT/Twine.h"
27#include "llvm/AsmParser/Parser.h"
28#include "llvm/AsmParser/SlotMapping.h"
29#include "llvm/CodeGen/MIRPrinter.h"
30#include "llvm/CodeGen/MachineBasicBlock.h"
31#include "llvm/CodeGen/MachineFrameInfo.h"
32#include "llvm/CodeGen/MachineFunction.h"
33#include "llvm/CodeGen/MachineInstr.h"
34#include "llvm/CodeGen/MachineInstrBuilder.h"
35#include "llvm/CodeGen/MachineMemOperand.h"
36#include "llvm/CodeGen/MachineModuleInfo.h"
37#include "llvm/CodeGen/MachineOperand.h"
38#include "llvm/CodeGen/MachineRegisterInfo.h"
39#include "llvm/CodeGen/TargetInstrInfo.h"
40#include "llvm/CodeGen/TargetRegisterInfo.h"
41#include "llvm/CodeGen/TargetSubtargetInfo.h"
42#include "llvm/IR/BasicBlock.h"
43#include "llvm/IR/Constants.h"
44#include "llvm/IR/DataLayout.h"
45#include "llvm/IR/DebugInfoMetadata.h"
46#include "llvm/IR/DebugLoc.h"
47#include "llvm/IR/Function.h"
48#include "llvm/IR/InstrTypes.h"
49#include "llvm/IR/Instructions.h"
50#include "llvm/IR/Intrinsics.h"
51#include "llvm/IR/Metadata.h"
52#include "llvm/IR/Module.h"
53#include "llvm/IR/ModuleSlotTracker.h"
54#include "llvm/IR/Type.h"
55#include "llvm/IR/Value.h"
56#include "llvm/IR/ValueSymbolTable.h"
57#include "llvm/MC/LaneBitmask.h"
58#include "llvm/MC/MCDwarf.h"
59#include "llvm/MC/MCInstrDesc.h"
60#include "llvm/MC/MCRegisterInfo.h"
61#include "llvm/Support/AtomicOrdering.h"
62#include "llvm/Support/BranchProbability.h"
63#include "llvm/Support/Casting.h"
64#include "llvm/Support/ErrorHandling.h"
65#include "llvm/Support/LowLevelTypeImpl.h"
66#include "llvm/Support/MemoryBuffer.h"
67#include "llvm/Support/SMLoc.h"
68#include "llvm/Support/SourceMgr.h"
69#include "llvm/Support/raw_ostream.h"
70#include "llvm/Target/TargetIntrinsicInfo.h"
71#include "llvm/Target/TargetMachine.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() &&(static_cast <bool> (Operand.isReg() && Operand
.isUse() && "Only used register operands can be tied"
) ? void (0) : __assert_fail ("Operand.isReg() && Operand.isUse() && \"Only used register operands can be tied\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 117, __extension__ __PRETTY_FUNCTION__))
117 "Only used register operands can be tied")(static_cast <bool> (Operand.isReg() && Operand
.isUse() && "Only used register operands can be tied"
) ? void (0) : __assert_fail ("Operand.isReg() && Operand.isUse() && \"Only used register operands can be tied\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 117, __extension__ __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()))(static_cast <bool> (Loc >= Source.data() &&
Loc <= (Source.data() + Source.size())) ? void (0) : __assert_fail
("Loc >= Source.data() && Loc <= (Source.data() + Source.size())"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 357, __extension__ __PRETTY_FUNCTION__))
;
358 const MemoryBuffer &Buffer = *SM.getMemoryBuffer(SM.getMainFileID());
359 if (Loc >= Buffer.getBufferStart() && Loc <= Buffer.getBufferEnd()) {
360 // Create an ordinary diagnostic when the source manager's buffer is the
361 // source string.
362 Error = SM.GetMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
363 return true;
364 }
365 // Create a diagnostic for a YAML string literal.
366 Error = SMDiagnostic(SM, SMLoc(), Buffer.getBufferIdentifier(), 1,
367 Loc - Source.data(), SourceMgr::DK_Error, Msg.str(),
368 Source, None, None);
369 return true;
370}
371
372static const char *toString(MIToken::TokenKind TokenKind) {
373 switch (TokenKind) {
374 case MIToken::comma:
375 return "','";
376 case MIToken::equal:
377 return "'='";
378 case MIToken::colon:
379 return "':'";
380 case MIToken::lparen:
381 return "'('";
382 case MIToken::rparen:
383 return "')'";
384 default:
385 return "<unknown token>";
386 }
387}
388
389bool MIParser::expectAndConsume(MIToken::TokenKind TokenKind) {
390 if (Token.isNot(TokenKind))
391 return error(Twine("expected ") + toString(TokenKind));
392 lex();
393 return false;
394}
395
396bool MIParser::consumeIfPresent(MIToken::TokenKind TokenKind) {
397 if (Token.isNot(TokenKind))
398 return false;
399 lex();
400 return true;
401}
402
403bool MIParser::parseBasicBlockDefinition(
404 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
405 assert(Token.is(MIToken::MachineBasicBlockLabel))(static_cast <bool> (Token.is(MIToken::MachineBasicBlockLabel
)) ? void (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 405, __extension__ __PRETTY_FUNCTION__))
;
406 unsigned ID = 0;
407 if (getUnsigned(ID))
408 return true;
409 auto Loc = Token.location();
410 auto Name = Token.stringValue();
411 lex();
412 bool HasAddressTaken = false;
413 bool IsLandingPad = false;
414 unsigned Alignment = 0;
415 BasicBlock *BB = nullptr;
416 if (consumeIfPresent(MIToken::lparen)) {
417 do {
418 // TODO: Report an error when multiple same attributes are specified.
419 switch (Token.kind()) {
420 case MIToken::kw_address_taken:
421 HasAddressTaken = true;
422 lex();
423 break;
424 case MIToken::kw_landing_pad:
425 IsLandingPad = true;
426 lex();
427 break;
428 case MIToken::kw_align:
429 if (parseAlignment(Alignment))
430 return true;
431 break;
432 case MIToken::IRBlock:
433 // TODO: Report an error when both name and ir block are specified.
434 if (parseIRBlock(BB, *MF.getFunction()))
435 return true;
436 lex();
437 break;
438 default:
439 break;
440 }
441 } while (consumeIfPresent(MIToken::comma));
442 if (expectAndConsume(MIToken::rparen))
443 return true;
444 }
445 if (expectAndConsume(MIToken::colon))
446 return true;
447
448 if (!Name.empty()) {
449 BB = dyn_cast_or_null<BasicBlock>(
450 MF.getFunction()->getValueSymbolTable()->lookup(Name));
451 if (!BB)
452 return error(Loc, Twine("basic block '") + Name +
453 "' is not defined in the function '" +
454 MF.getName() + "'");
455 }
456 auto *MBB = MF.CreateMachineBasicBlock(BB);
457 MF.insert(MF.end(), MBB);
458 bool WasInserted = MBBSlots.insert(std::make_pair(ID, MBB)).second;
459 if (!WasInserted)
460 return error(Loc, Twine("redefinition of machine basic block with id #") +
461 Twine(ID));
462 if (Alignment)
463 MBB->setAlignment(Alignment);
464 if (HasAddressTaken)
465 MBB->setHasAddressTaken();
466 MBB->setIsEHPad(IsLandingPad);
467 return false;
468}
469
470bool MIParser::parseBasicBlockDefinitions(
471 DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
472 lex();
473 // Skip until the first machine basic block.
474 while (Token.is(MIToken::Newline))
475 lex();
476 if (Token.isErrorOrEOF())
477 return Token.isError();
478 if (Token.isNot(MIToken::MachineBasicBlockLabel))
479 return error("expected a basic block definition before instructions");
480 unsigned BraceDepth = 0;
481 do {
482 if (parseBasicBlockDefinition(MBBSlots))
483 return true;
484 bool IsAfterNewline = false;
485 // Skip until the next machine basic block.
486 while (true) {
487 if ((Token.is(MIToken::MachineBasicBlockLabel) && IsAfterNewline) ||
488 Token.isErrorOrEOF())
489 break;
490 else if (Token.is(MIToken::MachineBasicBlockLabel))
491 return error("basic block definition should be located at the start of "
492 "the line");
493 else if (consumeIfPresent(MIToken::Newline)) {
494 IsAfterNewline = true;
495 continue;
496 }
497 IsAfterNewline = false;
498 if (Token.is(MIToken::lbrace))
499 ++BraceDepth;
500 if (Token.is(MIToken::rbrace)) {
501 if (!BraceDepth)
502 return error("extraneous closing brace ('}')");
503 --BraceDepth;
504 }
505 lex();
506 }
507 // Verify that we closed all of the '{' at the end of a file or a block.
508 if (!Token.isError() && BraceDepth)
509 return error("expected '}'"); // FIXME: Report a note that shows '{'.
510 } while (!Token.isErrorOrEOF());
511 return Token.isError();
512}
513
514bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
515 assert(Token.is(MIToken::kw_liveins))(static_cast <bool> (Token.is(MIToken::kw_liveins)) ? void
(0) : __assert_fail ("Token.is(MIToken::kw_liveins)", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 515, __extension__ __PRETTY_FUNCTION__))
;
516 lex();
517 if (expectAndConsume(MIToken::colon))
518 return true;
519 if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
520 return false;
521 do {
522 if (Token.isNot(MIToken::NamedRegister))
523 return error("expected a named register");
524 unsigned Reg = 0;
525 if (parseNamedRegister(Reg))
526 return true;
527 lex();
528 LaneBitmask Mask = LaneBitmask::getAll();
529 if (consumeIfPresent(MIToken::colon)) {
530 // Parse lane mask.
531 if (Token.isNot(MIToken::IntegerLiteral) &&
532 Token.isNot(MIToken::HexLiteral))
533 return error("expected a lane mask");
534 static_assert(sizeof(LaneBitmask::Type) == sizeof(unsigned),
535 "Use correct get-function for lane mask");
536 LaneBitmask::Type V;
537 if (getUnsigned(V))
538 return error("invalid lane mask value");
539 Mask = LaneBitmask(V);
540 lex();
541 }
542 MBB.addLiveIn(Reg, Mask);
543 } while (consumeIfPresent(MIToken::comma));
544 return false;
545}
546
547bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
548 assert(Token.is(MIToken::kw_successors))(static_cast <bool> (Token.is(MIToken::kw_successors)) ?
void (0) : __assert_fail ("Token.is(MIToken::kw_successors)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 548, __extension__ __PRETTY_FUNCTION__))
;
549 lex();
550 if (expectAndConsume(MIToken::colon))
551 return true;
552 if (Token.isNewlineOrEOF()) // Allow an empty list of successors.
553 return false;
554 do {
555 if (Token.isNot(MIToken::MachineBasicBlock))
556 return error("expected a machine basic block reference");
557 MachineBasicBlock *SuccMBB = nullptr;
558 if (parseMBBReference(SuccMBB))
559 return true;
560 lex();
561 unsigned Weight = 0;
562 if (consumeIfPresent(MIToken::lparen)) {
563 if (Token.isNot(MIToken::IntegerLiteral) &&
564 Token.isNot(MIToken::HexLiteral))
565 return error("expected an integer literal after '('");
566 if (getUnsigned(Weight))
567 return true;
568 lex();
569 if (expectAndConsume(MIToken::rparen))
570 return true;
571 }
572 MBB.addSuccessor(SuccMBB, BranchProbability::getRaw(Weight));
573 } while (consumeIfPresent(MIToken::comma));
574 MBB.normalizeSuccProbs();
575 return false;
576}
577
578bool MIParser::parseBasicBlock(MachineBasicBlock &MBB,
579 MachineBasicBlock *&AddFalthroughFrom) {
580 // Skip the definition.
581 assert(Token.is(MIToken::MachineBasicBlockLabel))(static_cast <bool> (Token.is(MIToken::MachineBasicBlockLabel
)) ? void (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 581, __extension__ __PRETTY_FUNCTION__))
;
582 lex();
583 if (consumeIfPresent(MIToken::lparen)) {
584 while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
585 lex();
586 consumeIfPresent(MIToken::rparen);
587 }
588 consumeIfPresent(MIToken::colon);
589
590 // Parse the liveins and successors.
591 // N.B: Multiple lists of successors and liveins are allowed and they're
592 // merged into one.
593 // Example:
594 // liveins: %edi
595 // liveins: %esi
596 //
597 // is equivalent to
598 // liveins: %edi, %esi
599 bool ExplicitSuccessors = false;
600 while (true) {
601 if (Token.is(MIToken::kw_successors)) {
602 if (parseBasicBlockSuccessors(MBB))
603 return true;
604 ExplicitSuccessors = true;
605 } else if (Token.is(MIToken::kw_liveins)) {
606 if (parseBasicBlockLiveins(MBB))
607 return true;
608 } else if (consumeIfPresent(MIToken::Newline)) {
609 continue;
610 } else
611 break;
612 if (!Token.isNewlineOrEOF())
613 return error("expected line break at the end of a list");
614 lex();
615 }
616
617 // Parse the instructions.
618 bool IsInBundle = false;
619 MachineInstr *PrevMI = nullptr;
620 while (!Token.is(MIToken::MachineBasicBlockLabel) &&
621 !Token.is(MIToken::Eof)) {
622 if (consumeIfPresent(MIToken::Newline))
623 continue;
624 if (consumeIfPresent(MIToken::rbrace)) {
625 // The first parsing pass should verify that all closing '}' have an
626 // opening '{'.
627 assert(IsInBundle)(static_cast <bool> (IsInBundle) ? void (0) : __assert_fail
("IsInBundle", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 627, __extension__ __PRETTY_FUNCTION__))
;
628 IsInBundle = false;
629 continue;
630 }
631 MachineInstr *MI = nullptr;
632 if (parse(MI))
633 return true;
634 MBB.insert(MBB.end(), MI);
635 if (IsInBundle) {
636 PrevMI->setFlag(MachineInstr::BundledSucc);
637 MI->setFlag(MachineInstr::BundledPred);
638 }
639 PrevMI = MI;
640 if (Token.is(MIToken::lbrace)) {
641 if (IsInBundle)
642 return error("nested instruction bundles are not allowed");
643 lex();
644 // This instruction is the start of the bundle.
645 MI->setFlag(MachineInstr::BundledSucc);
646 IsInBundle = true;
647 if (!Token.is(MIToken::Newline))
648 // The next instruction can be on the same line.
649 continue;
650 }
651 assert(Token.isNewlineOrEOF() && "MI is not fully parsed")(static_cast <bool> (Token.isNewlineOrEOF() && "MI is not fully parsed"
) ? void (0) : __assert_fail ("Token.isNewlineOrEOF() && \"MI is not fully parsed\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 651, __extension__ __PRETTY_FUNCTION__))
;
652 lex();
653 }
654
655 // Construct successor list by searching for basic block machine operands.
656 if (!ExplicitSuccessors) {
657 SmallVector<MachineBasicBlock*,4> Successors;
658 bool IsFallthrough;
659 guessSuccessors(MBB, Successors, IsFallthrough);
660 for (MachineBasicBlock *Succ : Successors)
661 MBB.addSuccessor(Succ);
662
663 if (IsFallthrough) {
664 AddFalthroughFrom = &MBB;
665 } else {
666 MBB.normalizeSuccProbs();
667 }
668 }
669
670 return false;
671}
672
673bool MIParser::parseBasicBlocks() {
674 lex();
675 // Skip until the first machine basic block.
676 while (Token.is(MIToken::Newline))
677 lex();
678 if (Token.isErrorOrEOF())
679 return Token.isError();
680 // The first parsing pass should have verified that this token is a MBB label
681 // in the 'parseBasicBlockDefinitions' method.
682 assert(Token.is(MIToken::MachineBasicBlockLabel))(static_cast <bool> (Token.is(MIToken::MachineBasicBlockLabel
)) ? void (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 682, __extension__ __PRETTY_FUNCTION__))
;
683 MachineBasicBlock *AddFalthroughFrom = nullptr;
684 do {
685 MachineBasicBlock *MBB = nullptr;
686 if (parseMBBReference(MBB))
687 return true;
688 if (AddFalthroughFrom) {
689 if (!AddFalthroughFrom->isSuccessor(MBB))
690 AddFalthroughFrom->addSuccessor(MBB);
691 AddFalthroughFrom->normalizeSuccProbs();
692 AddFalthroughFrom = nullptr;
693 }
694 if (parseBasicBlock(*MBB, AddFalthroughFrom))
695 return true;
696 // The method 'parseBasicBlock' should parse the whole block until the next
697 // block or the end of file.
698 assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof))(static_cast <bool> (Token.is(MIToken::MachineBasicBlockLabel
) || Token.is(MIToken::Eof)) ? void (0) : __assert_fail ("Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 698, __extension__ __PRETTY_FUNCTION__))
;
699 } while (Token.isNot(MIToken::Eof));
700 return false;
701}
702
703bool MIParser::parse(MachineInstr *&MI) {
704 // Parse any register operands before '='
705 MachineOperand MO = MachineOperand::CreateImm(0);
706 SmallVector<ParsedMachineOperand, 8> Operands;
707 while (Token.isRegister() || Token.isRegisterFlag()) {
708 auto Loc = Token.location();
709 Optional<unsigned> TiedDefIdx;
710 if (parseRegisterOperand(MO, TiedDefIdx, /*IsDef=*/true))
711 return true;
712 Operands.push_back(
713 ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
714 if (Token.isNot(MIToken::comma))
715 break;
716 lex();
717 }
718 if (!Operands.empty() && expectAndConsume(MIToken::equal))
719 return true;
720
721 unsigned OpCode, Flags = 0;
722 if (Token.isError() || parseInstruction(OpCode, Flags))
723 return true;
724
725 // Parse the remaining machine operands.
726 while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_debug_location) &&
727 Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
728 auto Loc = Token.location();
729 Optional<unsigned> TiedDefIdx;
730 if (parseMachineOperandAndTargetFlags(MO, TiedDefIdx))
731 return true;
732 Operands.push_back(
733 ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
734 if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
735 Token.is(MIToken::lbrace))
736 break;
737 if (Token.isNot(MIToken::comma))
738 return error("expected ',' before the next machine operand");
739 lex();
740 }
741
742 DebugLoc DebugLocation;
743 if (Token.is(MIToken::kw_debug_location)) {
744 lex();
745 if (Token.isNot(MIToken::exclaim))
746 return error("expected a metadata node after 'debug-location'");
747 MDNode *Node = nullptr;
748 if (parseMDNode(Node))
749 return true;
750 DebugLocation = DebugLoc(Node);
751 }
752
753 // Parse the machine memory operands.
754 SmallVector<MachineMemOperand *, 2> MemOperands;
755 if (Token.is(MIToken::coloncolon)) {
756 lex();
757 while (!Token.isNewlineOrEOF()) {
758 MachineMemOperand *MemOp = nullptr;
759 if (parseMachineMemoryOperand(MemOp))
760 return true;
761 MemOperands.push_back(MemOp);
762 if (Token.isNewlineOrEOF())
763 break;
764 if (Token.isNot(MIToken::comma))
765 return error("expected ',' before the next machine memory operand");
766 lex();
767 }
768 }
769
770 const auto &MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
771 if (!MCID.isVariadic()) {
772 // FIXME: Move the implicit operand verification to the machine verifier.
773 if (verifyImplicitOperands(Operands, MCID))
774 return true;
775 }
776
777 // TODO: Check for extraneous machine operands.
778 MI = MF.CreateMachineInstr(MCID, DebugLocation, /*NoImplicit=*/true);
779 MI->setFlags(Flags);
780 for (const auto &Operand : Operands)
781 MI->addOperand(MF, Operand.Operand);
782 if (assignRegisterTies(*MI, Operands))
783 return true;
784 if (MemOperands.empty())
785 return false;
786 MachineInstr::mmo_iterator MemRefs =
787 MF.allocateMemRefsArray(MemOperands.size());
788 std::copy(MemOperands.begin(), MemOperands.end(), MemRefs);
789 MI->setMemRefs(MemRefs, MemRefs + MemOperands.size());
790 return false;
791}
792
793bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
794 lex();
795 if (Token.isNot(MIToken::MachineBasicBlock))
796 return error("expected a machine basic block reference");
797 if (parseMBBReference(MBB))
798 return true;
799 lex();
800 if (Token.isNot(MIToken::Eof))
801 return error(
802 "expected end of string after the machine basic block reference");
803 return false;
804}
805
806bool MIParser::parseStandaloneNamedRegister(unsigned &Reg) {
807 lex();
808 if (Token.isNot(MIToken::NamedRegister))
809 return error("expected a named register");
810 if (parseNamedRegister(Reg))
811 return true;
812 lex();
813 if (Token.isNot(MIToken::Eof))
814 return error("expected end of string after the register reference");
815 return false;
816}
817
818bool MIParser::parseStandaloneVirtualRegister(VRegInfo *&Info) {
819 lex();
820 if (Token.isNot(MIToken::VirtualRegister))
821 return error("expected a virtual register");
822 if (parseVirtualRegister(Info))
823 return true;
824 lex();
825 if (Token.isNot(MIToken::Eof))
826 return error("expected end of string after the register reference");
827 return false;
828}
829
830bool MIParser::parseStandaloneRegister(unsigned &Reg) {
831 lex();
832 if (Token.isNot(MIToken::NamedRegister) &&
833 Token.isNot(MIToken::VirtualRegister))
834 return error("expected either a named or virtual register");
835
836 VRegInfo *Info;
837 if (parseRegister(Reg, Info))
838 return true;
839
840 lex();
841 if (Token.isNot(MIToken::Eof))
842 return error("expected end of string after the register reference");
843 return false;
844}
845
846bool MIParser::parseStandaloneStackObject(int &FI) {
847 lex();
848 if (Token.isNot(MIToken::StackObject))
849 return error("expected a stack object");
850 if (parseStackFrameIndex(FI))
851 return true;
852 if (Token.isNot(MIToken::Eof))
853 return error("expected end of string after the stack object reference");
854 return false;
855}
856
857bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
858 lex();
859 if (Token.is(MIToken::exclaim)) {
860 if (parseMDNode(Node))
861 return true;
862 } else if (Token.is(MIToken::md_diexpr)) {
863 if (parseDIExpression(Node))
864 return true;
865 } else
866 return error("expected a metadata node");
867 if (Token.isNot(MIToken::Eof))
868 return error("expected end of string after the metadata node");
869 return false;
870}
871
872static const char *printImplicitRegisterFlag(const MachineOperand &MO) {
873 assert(MO.isImplicit())(static_cast <bool> (MO.isImplicit()) ? void (0) : __assert_fail
("MO.isImplicit()", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 873, __extension__ __PRETTY_FUNCTION__))
;
874 return MO.isDef() ? "implicit-def" : "implicit";
875}
876
877static std::string getRegisterName(const TargetRegisterInfo *TRI,
878 unsigned Reg) {
879 assert(TargetRegisterInfo::isPhysicalRegister(Reg) && "expected phys reg")(static_cast <bool> (TargetRegisterInfo::isPhysicalRegister
(Reg) && "expected phys reg") ? void (0) : __assert_fail
("TargetRegisterInfo::isPhysicalRegister(Reg) && \"expected phys reg\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 879, __extension__ __PRETTY_FUNCTION__))
;
880 return StringRef(TRI->getName(Reg)).lower();
881}
882
883/// Return true if the parsed machine operands contain a given machine operand.
884static bool isImplicitOperandIn(const MachineOperand &ImplicitOperand,
885 ArrayRef<ParsedMachineOperand> Operands) {
886 for (const auto &I : Operands) {
887 if (ImplicitOperand.isIdenticalTo(I.Operand))
888 return true;
889 }
890 return false;
891}
892
893bool MIParser::verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
894 const MCInstrDesc &MCID) {
895 if (MCID.isCall())
896 // We can't verify call instructions as they can contain arbitrary implicit
897 // register and register mask operands.
898 return false;
899
900 // Gather all the expected implicit operands.
901 SmallVector<MachineOperand, 4> ImplicitOperands;
902 if (MCID.ImplicitDefs)
903 for (const MCPhysReg *ImpDefs = MCID.getImplicitDefs(); *ImpDefs; ++ImpDefs)
904 ImplicitOperands.push_back(
905 MachineOperand::CreateReg(*ImpDefs, true, true));
906 if (MCID.ImplicitUses)
907 for (const MCPhysReg *ImpUses = MCID.getImplicitUses(); *ImpUses; ++ImpUses)
908 ImplicitOperands.push_back(
909 MachineOperand::CreateReg(*ImpUses, false, true));
910
911 const auto *TRI = MF.getSubtarget().getRegisterInfo();
912 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 912, __extension__ __PRETTY_FUNCTION__))
;
913 for (const auto &I : ImplicitOperands) {
914 if (isImplicitOperandIn(I, Operands))
915 continue;
916 return error(Operands.empty() ? Token.location() : Operands.back().End,
917 Twine("missing implicit register operand '") +
918 printImplicitRegisterFlag(I) + " %" +
919 getRegisterName(TRI, I.getReg()) + "'");
920 }
921 return false;
922}
923
924bool MIParser::parseInstruction(unsigned &OpCode, unsigned &Flags) {
925 if (Token.is(MIToken::kw_frame_setup)) {
926 Flags |= MachineInstr::FrameSetup;
927 lex();
928 }
929 if (Token.isNot(MIToken::Identifier))
930 return error("expected a machine instruction");
931 StringRef InstrName = Token.stringValue();
932 if (parseInstrName(InstrName, OpCode))
933 return error(Twine("unknown machine instruction name '") + InstrName + "'");
934 lex();
935 return false;
936}
937
938bool MIParser::parseNamedRegister(unsigned &Reg) {
939 assert(Token.is(MIToken::NamedRegister) && "Needs NamedRegister token")(static_cast <bool> (Token.is(MIToken::NamedRegister) &&
"Needs NamedRegister token") ? void (0) : __assert_fail ("Token.is(MIToken::NamedRegister) && \"Needs NamedRegister token\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 939, __extension__ __PRETTY_FUNCTION__))
;
940 StringRef Name = Token.stringValue();
941 if (getRegisterByName(Name, Reg))
942 return error(Twine("unknown register name '") + Name + "'");
943 return false;
944}
945
946bool MIParser::parseVirtualRegister(VRegInfo *&Info) {
947 assert(Token.is(MIToken::VirtualRegister) && "Needs VirtualRegister token")(static_cast <bool> (Token.is(MIToken::VirtualRegister)
&& "Needs VirtualRegister token") ? void (0) : __assert_fail
("Token.is(MIToken::VirtualRegister) && \"Needs VirtualRegister token\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 947, __extension__ __PRETTY_FUNCTION__))
;
948 unsigned ID;
949 if (getUnsigned(ID))
950 return true;
951 Info = &PFS.getVRegInfo(ID);
952 return false;
953}
954
955bool MIParser::parseRegister(unsigned &Reg, VRegInfo *&Info) {
956 switch (Token.kind()) {
957 case MIToken::underscore:
958 Reg = 0;
959 return false;
960 case MIToken::NamedRegister:
961 return parseNamedRegister(Reg);
962 case MIToken::VirtualRegister:
963 if (parseVirtualRegister(Info))
964 return true;
965 Reg = Info->VReg;
966 return false;
967 // TODO: Parse other register kinds.
968 default:
969 llvm_unreachable("The current token should be a register")::llvm::llvm_unreachable_internal("The current token should be a register"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/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~svn318631/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~svn318631/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~svn318631/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))(static_cast <bool> (Token.is(MIToken::dot)) ? void (0)
: __assert_fail ("Token.is(MIToken::dot)", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1075, __extension__ __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))(static_cast <bool> (Token.is(MIToken::IntegerLiteral))
? void (0) : __assert_fail ("Token.is(MIToken::IntegerLiteral)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1220, __extension__ __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))(static_cast <bool> (Token.is(MIToken::IntegerType)) ? void
(0) : __assert_fail ("Token.is(MIToken::IntegerType)", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1290, __extension__ __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) ||(static_cast <bool> (Token.is(MIToken::MachineBasicBlock
) || Token.is(MIToken::MachineBasicBlockLabel)) ? void (0) : __assert_fail
("Token.is(MIToken::MachineBasicBlock) || Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1338, __extension__ __PRETTY_FUNCTION__))
1338 Token.is(MIToken::MachineBasicBlockLabel))(static_cast <bool> (Token.is(MIToken::MachineBasicBlock
) || Token.is(MIToken::MachineBasicBlockLabel)) ? void (0) : __assert_fail
("Token.is(MIToken::MachineBasicBlock) || Token.is(MIToken::MachineBasicBlockLabel)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1338, __extension__ __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))(static_cast <bool> (Token.is(MIToken::StackObject)) ? void
(0) : __assert_fail ("Token.is(MIToken::StackObject)", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1363, __extension__ __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))(static_cast <bool> (Token.is(MIToken::FixedStackObject
)) ? void (0) : __assert_fail ("Token.is(MIToken::FixedStackObject)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1392, __extension__ __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()) {
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;
1425 if (getUnsigned(GVIdx))
1426 return true;
1427 if (GVIdx >= PFS.IRSlots.GlobalValues.size())
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~svn318631/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))(static_cast <bool> (Token.is(MIToken::ConstantPoolItem
)) ? void (0) : __assert_fail ("Token.is(MIToken::ConstantPoolItem)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1451, __extension__ __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))(static_cast <bool> (Token.is(MIToken::JumpTableIndex))
? void (0) : __assert_fail ("Token.is(MIToken::JumpTableIndex)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1466, __extension__ __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))(static_cast <bool> (Token.is(MIToken::ExternalSymbol))
? void (0) : __assert_fail ("Token.is(MIToken::ExternalSymbol)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1479, __extension__ __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))(static_cast <bool> (Token.is(MIToken::SubRegisterIndex
)) ? void (0) : __assert_fail ("Token.is(MIToken::SubRegisterIndex)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1489, __extension__ __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))(static_cast <bool> (Token.is(MIToken::exclaim)) ? void
(0) : __assert_fail ("Token.is(MIToken::exclaim)", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1500, __extension__ __PRETTY_FUNCTION__))
;
1501
1502 auto Loc = Token.location();
1503 lex();
1504 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
7
Taking false branch
1505 return error("expected metadata id after '!'");
1506 unsigned ID;
8
'ID' declared without an initial value
1507 if (getUnsigned(ID))
9
Calling 'MIParser::getUnsigned'
22
Returning from 'MIParser::getUnsigned'
23
Assuming the condition is false
24
Taking false branch
1508 return true;
1509 auto NodeInfo = PFS.IRSlots.MetadataNodes.find(ID);
1510 if (NodeInfo == PFS.IRSlots.MetadataNodes.end())
25
Assuming the condition is true
26
Taking true branch
1511 return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
27
1st function call argument is an uninitialized value
1512 lex();
1513 Node = NodeInfo->second.get();
1514 return false;
1515}
1516
1517bool MIParser::parseDIExpression(MDNode *&Expr) {
1518 assert(Token.is(MIToken::md_diexpr))(static_cast <bool> (Token.is(MIToken::md_diexpr)) ? void
(0) : __assert_fail ("Token.is(MIToken::md_diexpr)", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1518, __extension__ __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)) {
5
Taking true branch
1561 if (parseMDNode(Node))
6
Calling 'MIParser::parseMDNode'
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")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1588, __extension__ __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 case MIToken::kw_cfi_restore:
1638 if (parseCFIRegister(Reg))
1639 return true;
1640 CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestore(nullptr, Reg));
1641 break;
1642
1643 default:
1644 // TODO: Parse the other CFI operands.
1645 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~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1645)
;
1646 }
1647 Dest = MachineOperand::CreateCFIIndex(CFIIndex);
1648 return false;
1649}
1650
1651bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
1652 switch (Token.kind()) {
1653 case MIToken::NamedIRBlock: {
1654 BB = dyn_cast_or_null<BasicBlock>(
1655 F.getValueSymbolTable()->lookup(Token.stringValue()));
1656 if (!BB)
1657 return error(Twine("use of undefined IR block '") + Token.range() + "'");
1658 break;
1659 }
1660 case MIToken::IRBlock: {
1661 unsigned SlotNumber = 0;
1662 if (getUnsigned(SlotNumber))
1663 return true;
1664 BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
1665 if (!BB)
1666 return error(Twine("use of undefined IR block '%ir-block.") +
1667 Twine(SlotNumber) + "'");
1668 break;
1669 }
1670 default:
1671 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~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1671)
;
1672 }
1673 return false;
1674}
1675
1676bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
1677 assert(Token.is(MIToken::kw_blockaddress))(static_cast <bool> (Token.is(MIToken::kw_blockaddress)
) ? void (0) : __assert_fail ("Token.is(MIToken::kw_blockaddress)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1677, __extension__ __PRETTY_FUNCTION__))
;
1678 lex();
1679 if (expectAndConsume(MIToken::lparen))
1680 return true;
1681 if (Token.isNot(MIToken::GlobalValue) &&
1682 Token.isNot(MIToken::NamedGlobalValue))
1683 return error("expected a global value");
1684 GlobalValue *GV = nullptr;
1685 if (parseGlobalValue(GV))
1686 return true;
1687 auto *F = dyn_cast<Function>(GV);
1688 if (!F)
1689 return error("expected an IR function reference");
1690 lex();
1691 if (expectAndConsume(MIToken::comma))
1692 return true;
1693 BasicBlock *BB = nullptr;
1694 if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
1695 return error("expected an IR block reference");
1696 if (parseIRBlock(BB, *F))
1697 return true;
1698 lex();
1699 if (expectAndConsume(MIToken::rparen))
1700 return true;
1701 Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
1702 if (parseOperandsOffset(Dest))
1703 return true;
1704 return false;
1705}
1706
1707bool MIParser::parseIntrinsicOperand(MachineOperand &Dest) {
1708 assert(Token.is(MIToken::kw_intrinsic))(static_cast <bool> (Token.is(MIToken::kw_intrinsic)) ?
void (0) : __assert_fail ("Token.is(MIToken::kw_intrinsic)",
"/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1708, __extension__ __PRETTY_FUNCTION__))
;
1709 lex();
1710 if (expectAndConsume(MIToken::lparen))
1711 return error("expected syntax intrinsic(@llvm.whatever)");
1712
1713 if (Token.isNot(MIToken::NamedGlobalValue))
1714 return error("expected syntax intrinsic(@llvm.whatever)");
1715
1716 std::string Name = Token.stringValue();
1717 lex();
1718
1719 if (expectAndConsume(MIToken::rparen))
1720 return error("expected ')' to terminate intrinsic name");
1721
1722 // Find out what intrinsic we're dealing with, first try the global namespace
1723 // and then the target's private intrinsics if that fails.
1724 const TargetIntrinsicInfo *TII = MF.getTarget().getIntrinsicInfo();
1725 Intrinsic::ID ID = Function::lookupIntrinsicID(Name);
1726 if (ID == Intrinsic::not_intrinsic && TII)
1727 ID = static_cast<Intrinsic::ID>(TII->lookupName(Name));
1728
1729 if (ID == Intrinsic::not_intrinsic)
1730 return error("unknown intrinsic name");
1731 Dest = MachineOperand::CreateIntrinsicID(ID);
1732
1733 return false;
1734}
1735
1736bool MIParser::parsePredicateOperand(MachineOperand &Dest) {
1737 assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred))(static_cast <bool> (Token.is(MIToken::kw_intpred) || Token
.is(MIToken::kw_floatpred)) ? void (0) : __assert_fail ("Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1737, __extension__ __PRETTY_FUNCTION__))
;
1738 bool IsFloat = Token.is(MIToken::kw_floatpred);
1739 lex();
1740
1741 if (expectAndConsume(MIToken::lparen))
1742 return error("expected syntax intpred(whatever) or floatpred(whatever");
1743
1744 if (Token.isNot(MIToken::Identifier))
1745 return error("whatever");
1746
1747 CmpInst::Predicate Pred;
1748 if (IsFloat) {
1749 Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1750 .Case("false", CmpInst::FCMP_FALSE)
1751 .Case("oeq", CmpInst::FCMP_OEQ)
1752 .Case("ogt", CmpInst::FCMP_OGT)
1753 .Case("oge", CmpInst::FCMP_OGE)
1754 .Case("olt", CmpInst::FCMP_OLT)
1755 .Case("ole", CmpInst::FCMP_OLE)
1756 .Case("one", CmpInst::FCMP_ONE)
1757 .Case("ord", CmpInst::FCMP_ORD)
1758 .Case("uno", CmpInst::FCMP_UNO)
1759 .Case("ueq", CmpInst::FCMP_UEQ)
1760 .Case("ugt", CmpInst::FCMP_UGT)
1761 .Case("uge", CmpInst::FCMP_UGE)
1762 .Case("ult", CmpInst::FCMP_ULT)
1763 .Case("ule", CmpInst::FCMP_ULE)
1764 .Case("une", CmpInst::FCMP_UNE)
1765 .Case("true", CmpInst::FCMP_TRUE)
1766 .Default(CmpInst::BAD_FCMP_PREDICATE);
1767 if (!CmpInst::isFPPredicate(Pred))
1768 return error("invalid floating-point predicate");
1769 } else {
1770 Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
1771 .Case("eq", CmpInst::ICMP_EQ)
1772 .Case("ne", CmpInst::ICMP_NE)
1773 .Case("sgt", CmpInst::ICMP_SGT)
1774 .Case("sge", CmpInst::ICMP_SGE)
1775 .Case("slt", CmpInst::ICMP_SLT)
1776 .Case("sle", CmpInst::ICMP_SLE)
1777 .Case("ugt", CmpInst::ICMP_UGT)
1778 .Case("uge", CmpInst::ICMP_UGE)
1779 .Case("ult", CmpInst::ICMP_ULT)
1780 .Case("ule", CmpInst::ICMP_ULE)
1781 .Default(CmpInst::BAD_ICMP_PREDICATE);
1782 if (!CmpInst::isIntPredicate(Pred))
1783 return error("invalid integer predicate");
1784 }
1785
1786 lex();
1787 Dest = MachineOperand::CreatePredicate(Pred);
1788 if (expectAndConsume(MIToken::rparen))
1789 return error("predicate should be terminated by ')'.");
1790
1791 return false;
1792}
1793
1794bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
1795 assert(Token.is(MIToken::kw_target_index))(static_cast <bool> (Token.is(MIToken::kw_target_index)
) ? void (0) : __assert_fail ("Token.is(MIToken::kw_target_index)"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1795, __extension__ __PRETTY_FUNCTION__))
;
1796 lex();
1797 if (expectAndConsume(MIToken::lparen))
1798 return true;
1799 if (Token.isNot(MIToken::Identifier))
1800 return error("expected the name of the target index");
1801 int Index = 0;
1802 if (getTargetIndex(Token.stringValue(), Index))
1803 return error("use of undefined target index '" + Token.stringValue() + "'");
1804 lex();
1805 if (expectAndConsume(MIToken::rparen))
1806 return true;
1807 Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
1808 if (parseOperandsOffset(Dest))
1809 return true;
1810 return false;
1811}
1812
1813bool MIParser::parseCustomRegisterMaskOperand(MachineOperand &Dest) {
1814 assert(Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask")(static_cast <bool> (Token.stringValue() == "CustomRegMask"
&& "Expected a custom RegMask") ? void (0) : __assert_fail
("Token.stringValue() == \"CustomRegMask\" && \"Expected a custom RegMask\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1814, __extension__ __PRETTY_FUNCTION__))
;
1815 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
1816 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1816, __extension__ __PRETTY_FUNCTION__))
;
1817 lex();
1818 if (expectAndConsume(MIToken::lparen))
1819 return true;
1820
1821 uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1822 while (true) {
1823 if (Token.isNot(MIToken::NamedRegister))
1824 return error("expected a named register");
1825 unsigned Reg;
1826 if (parseNamedRegister(Reg))
1827 return true;
1828 lex();
1829 Mask[Reg / 32] |= 1U << (Reg % 32);
1830 // TODO: Report an error if the same register is used more than once.
1831 if (Token.isNot(MIToken::comma))
1832 break;
1833 lex();
1834 }
1835
1836 if (expectAndConsume(MIToken::rparen))
1837 return true;
1838 Dest = MachineOperand::CreateRegMask(Mask);
1839 return false;
1840}
1841
1842bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
1843 assert(Token.is(MIToken::kw_liveout))(static_cast <bool> (Token.is(MIToken::kw_liveout)) ? void
(0) : __assert_fail ("Token.is(MIToken::kw_liveout)", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1843, __extension__ __PRETTY_FUNCTION__))
;
1844 const auto *TRI = MF.getSubtarget().getRegisterInfo();
1845 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 1845, __extension__ __PRETTY_FUNCTION__))
;
1846 uint32_t *Mask = MF.allocateRegisterMask(TRI->getNumRegs());
1847 lex();
1848 if (expectAndConsume(MIToken::lparen))
1849 return true;
1850 while (true) {
1851 if (Token.isNot(MIToken::NamedRegister))
1852 return error("expected a named register");
1853 unsigned Reg;
1854 if (parseNamedRegister(Reg))
1855 return true;
1856 lex();
1857 Mask[Reg / 32] |= 1U << (Reg % 32);
1858 // TODO: Report an error if the same register is used more than once.
1859 if (Token.isNot(MIToken::comma))
1860 break;
1861 lex();
1862 }
1863 if (expectAndConsume(MIToken::rparen))
1864 return true;
1865 Dest = MachineOperand::CreateRegLiveOut(Mask);
1866 return false;
1867}
1868
1869bool MIParser::parseMachineOperand(MachineOperand &Dest,
1870 Optional<unsigned> &TiedDefIdx) {
1871 switch (Token.kind()) {
3
Control jumps to 'case exclaim:' at line 1914
1872 case MIToken::kw_implicit:
1873 case MIToken::kw_implicit_define:
1874 case MIToken::kw_def:
1875 case MIToken::kw_dead:
1876 case MIToken::kw_killed:
1877 case MIToken::kw_undef:
1878 case MIToken::kw_internal:
1879 case MIToken::kw_early_clobber:
1880 case MIToken::kw_debug_use:
1881 case MIToken::underscore:
1882 case MIToken::NamedRegister:
1883 case MIToken::VirtualRegister:
1884 return parseRegisterOperand(Dest, TiedDefIdx);
1885 case MIToken::IntegerLiteral:
1886 return parseImmediateOperand(Dest);
1887 case MIToken::IntegerType:
1888 return parseTypedImmediateOperand(Dest);
1889 case MIToken::kw_half:
1890 case MIToken::kw_float:
1891 case MIToken::kw_double:
1892 case MIToken::kw_x86_fp80:
1893 case MIToken::kw_fp128:
1894 case MIToken::kw_ppc_fp128:
1895 return parseFPImmediateOperand(Dest);
1896 case MIToken::MachineBasicBlock:
1897 return parseMBBOperand(Dest);
1898 case MIToken::StackObject:
1899 return parseStackObjectOperand(Dest);
1900 case MIToken::FixedStackObject:
1901 return parseFixedStackObjectOperand(Dest);
1902 case MIToken::GlobalValue:
1903 case MIToken::NamedGlobalValue:
1904 return parseGlobalAddressOperand(Dest);
1905 case MIToken::ConstantPoolItem:
1906 return parseConstantPoolIndexOperand(Dest);
1907 case MIToken::JumpTableIndex:
1908 return parseJumpTableIndexOperand(Dest);
1909 case MIToken::ExternalSymbol:
1910 return parseExternalSymbolOperand(Dest);
1911 case MIToken::SubRegisterIndex:
1912 return parseSubRegisterIndexOperand(Dest);
1913 case MIToken::md_diexpr:
1914 case MIToken::exclaim:
1915 return parseMetadataOperand(Dest);
4
Calling 'MIParser::parseMetadataOperand'
1916 case MIToken::kw_cfi_same_value:
1917 case MIToken::kw_cfi_offset:
1918 case MIToken::kw_cfi_def_cfa_register:
1919 case MIToken::kw_cfi_def_cfa_offset:
1920 case MIToken::kw_cfi_def_cfa:
1921 case MIToken::kw_cfi_restore:
1922 return parseCFIOperand(Dest);
1923 case MIToken::kw_blockaddress:
1924 return parseBlockAddressOperand(Dest);
1925 case MIToken::kw_intrinsic:
1926 return parseIntrinsicOperand(Dest);
1927 case MIToken::kw_target_index:
1928 return parseTargetIndexOperand(Dest);
1929 case MIToken::kw_liveout:
1930 return parseLiveoutRegisterMaskOperand(Dest);
1931 case MIToken::kw_floatpred:
1932 case MIToken::kw_intpred:
1933 return parsePredicateOperand(Dest);
1934 case MIToken::Error:
1935 return true;
1936 case MIToken::Identifier:
1937 if (const auto *RegMask = getRegMask(Token.stringValue())) {
1938 Dest = MachineOperand::CreateRegMask(RegMask);
1939 lex();
1940 break;
1941 } else
1942 return parseCustomRegisterMaskOperand(Dest);
1943 default:
1944 // FIXME: Parse the MCSymbol machine operand.
1945 return error("expected a machine operand");
1946 }
1947 return false;
1948}
1949
1950bool MIParser::parseMachineOperandAndTargetFlags(
1951 MachineOperand &Dest, Optional<unsigned> &TiedDefIdx) {
1952 unsigned TF = 0;
1953 bool HasTargetFlags = false;
1954 if (Token.is(MIToken::kw_target_flags)) {
1
Taking false branch
1955 HasTargetFlags = true;
1956 lex();
1957 if (expectAndConsume(MIToken::lparen))
1958 return true;
1959 if (Token.isNot(MIToken::Identifier))
1960 return error("expected the name of the target flag");
1961 if (getDirectTargetFlag(Token.stringValue(), TF)) {
1962 if (getBitmaskTargetFlag(Token.stringValue(), TF))
1963 return error("use of undefined target flag '" + Token.stringValue() +
1964 "'");
1965 }
1966 lex();
1967 while (Token.is(MIToken::comma)) {
1968 lex();
1969 if (Token.isNot(MIToken::Identifier))
1970 return error("expected the name of the target flag");
1971 unsigned BitFlag = 0;
1972 if (getBitmaskTargetFlag(Token.stringValue(), BitFlag))
1973 return error("use of undefined target flag '" + Token.stringValue() +
1974 "'");
1975 // TODO: Report an error when using a duplicate bit target flag.
1976 TF |= BitFlag;
1977 lex();
1978 }
1979 if (expectAndConsume(MIToken::rparen))
1980 return true;
1981 }
1982 auto Loc = Token.location();
1983 if (parseMachineOperand(Dest, TiedDefIdx))
2
Calling 'MIParser::parseMachineOperand'
1984 return true;
1985 if (!HasTargetFlags)
1986 return false;
1987 if (Dest.isReg())
1988 return error(Loc, "register operands can't have target flags");
1989 Dest.setTargetFlags(TF);
1990 return false;
1991}
1992
1993bool MIParser::parseOffset(int64_t &Offset) {
1994 if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
1995 return false;
1996 StringRef Sign = Token.range();
1997 bool IsNegative = Token.is(MIToken::minus);
1998 lex();
1999 if (Token.isNot(MIToken::IntegerLiteral))
2000 return error("expected an integer literal after '" + Sign + "'");
2001 if (Token.integerValue().getMinSignedBits() > 64)
2002 return error("expected 64-bit integer (too large)");
2003 Offset = Token.integerValue().getExtValue();
2004 if (IsNegative)
2005 Offset = -Offset;
2006 lex();
2007 return false;
2008}
2009
2010bool MIParser::parseAlignment(unsigned &Alignment) {
2011 assert(Token.is(MIToken::kw_align))(static_cast <bool> (Token.is(MIToken::kw_align)) ? void
(0) : __assert_fail ("Token.is(MIToken::kw_align)", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2011, __extension__ __PRETTY_FUNCTION__))
;
2012 lex();
2013 if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
2014 return error("expected an integer literal after 'align'");
2015 if (getUnsigned(Alignment))
2016 return true;
2017 lex();
2018 return false;
2019}
2020
2021bool MIParser::parseOperandsOffset(MachineOperand &Op) {
2022 int64_t Offset = 0;
2023 if (parseOffset(Offset))
2024 return true;
2025 Op.setOffset(Offset);
2026 return false;
2027}
2028
2029bool MIParser::parseIRValue(const Value *&V) {
2030 switch (Token.kind()) {
2031 case MIToken::NamedIRValue: {
2032 V = MF.getFunction()->getValueSymbolTable()->lookup(Token.stringValue());
2033 break;
2034 }
2035 case MIToken::IRValue: {
2036 unsigned SlotNumber = 0;
2037 if (getUnsigned(SlotNumber))
2038 return true;
2039 V = getIRValue(SlotNumber);
2040 break;
2041 }
2042 case MIToken::NamedGlobalValue:
2043 case MIToken::GlobalValue: {
2044 GlobalValue *GV = nullptr;
2045 if (parseGlobalValue(GV))
2046 return true;
2047 V = GV;
2048 break;
2049 }
2050 case MIToken::QuotedIRValue: {
2051 const Constant *C = nullptr;
2052 if (parseIRConstant(Token.location(), Token.stringValue(), C))
2053 return true;
2054 V = C;
2055 break;
2056 }
2057 default:
2058 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~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2058)
;
2059 }
2060 if (!V)
2061 return error(Twine("use of undefined IR value '") + Token.range() + "'");
2062 return false;
2063}
2064
2065bool MIParser::getUint64(uint64_t &Result) {
2066 if (Token.hasIntegerValue()) {
2067 if (Token.integerValue().getActiveBits() > 64)
2068 return error("expected 64-bit integer (too large)");
2069 Result = Token.integerValue().getZExtValue();
2070 return false;
2071 }
2072 if (Token.is(MIToken::HexLiteral)) {
2073 APInt A;
2074 if (getHexUint(A))
2075 return true;
2076 if (A.getBitWidth() > 64)
2077 return error("expected 64-bit integer (too large)");
2078 Result = A.getZExtValue();
2079 return false;
2080 }
2081 return true;
2082}
2083
2084bool MIParser::getHexUint(APInt &Result) {
2085 assert(Token.is(MIToken::HexLiteral))(static_cast <bool> (Token.is(MIToken::HexLiteral)) ? void
(0) : __assert_fail ("Token.is(MIToken::HexLiteral)", "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2085, __extension__ __PRETTY_FUNCTION__))
;
2086 StringRef S = Token.range();
2087 assert(S[0] == '0' && tolower(S[1]) == 'x')(static_cast <bool> (S[0] == '0' && tolower(S[1
]) == 'x') ? void (0) : __assert_fail ("S[0] == '0' && tolower(S[1]) == 'x'"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2087, __extension__ __PRETTY_FUNCTION__))
;
2088 // This could be a floating point literal with a special prefix.
2089 if (!isxdigit(S[2]))
2090 return true;
2091 StringRef V = S.substr(2);
2092 APInt A(V.size()*4, V, 16);
2093
2094 // If A is 0, then A.getActiveBits() is 0. This isn't a valid bitwidth. Make
2095 // sure it isn't the case before constructing result.
2096 unsigned NumBits = (A == 0) ? 32 : A.getActiveBits();
2097 Result = APInt(NumBits, ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
2098 return false;
2099}
2100
2101bool MIParser::parseMemoryOperandFlag(MachineMemOperand::Flags &Flags) {
2102 const auto OldFlags = Flags;
2103 switch (Token.kind()) {
2104 case MIToken::kw_volatile:
2105 Flags |= MachineMemOperand::MOVolatile;
2106 break;
2107 case MIToken::kw_non_temporal:
2108 Flags |= MachineMemOperand::MONonTemporal;
2109 break;
2110 case MIToken::kw_dereferenceable:
2111 Flags |= MachineMemOperand::MODereferenceable;
2112 break;
2113 case MIToken::kw_invariant:
2114 Flags |= MachineMemOperand::MOInvariant;
2115 break;
2116 case MIToken::StringConstant: {
2117 MachineMemOperand::Flags TF;
2118 if (getMMOTargetFlag(Token.stringValue(), TF))
2119 return error("use of undefined target MMO flag '" + Token.stringValue() +
2120 "'");
2121 Flags |= TF;
2122 break;
2123 }
2124 default:
2125 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~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2125)
;
2126 }
2127 if (OldFlags == Flags)
2128 // We know that the same flag is specified more than once when the flags
2129 // weren't modified.
2130 return error("duplicate '" + Token.stringValue() + "' memory operand flag");
2131 lex();
2132 return false;
2133}
2134
2135bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
2136 switch (Token.kind()) {
2137 case MIToken::kw_stack:
2138 PSV = MF.getPSVManager().getStack();
2139 break;
2140 case MIToken::kw_got:
2141 PSV = MF.getPSVManager().getGOT();
2142 break;
2143 case MIToken::kw_jump_table:
2144 PSV = MF.getPSVManager().getJumpTable();
2145 break;
2146 case MIToken::kw_constant_pool:
2147 PSV = MF.getPSVManager().getConstantPool();
2148 break;
2149 case MIToken::FixedStackObject: {
2150 int FI;
2151 if (parseFixedStackFrameIndex(FI))
2152 return true;
2153 PSV = MF.getPSVManager().getFixedStack(FI);
2154 // The token was already consumed, so use return here instead of break.
2155 return false;
2156 }
2157 case MIToken::StackObject: {
2158 int FI;
2159 if (parseStackFrameIndex(FI))
2160 return true;
2161 PSV = MF.getPSVManager().getFixedStack(FI);
2162 // The token was already consumed, so use return here instead of break.
2163 return false;
2164 }
2165 case MIToken::kw_call_entry:
2166 lex();
2167 switch (Token.kind()) {
2168 case MIToken::GlobalValue:
2169 case MIToken::NamedGlobalValue: {
2170 GlobalValue *GV = nullptr;
2171 if (parseGlobalValue(GV))
2172 return true;
2173 PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
2174 break;
2175 }
2176 case MIToken::ExternalSymbol:
2177 PSV = MF.getPSVManager().getExternalSymbolCallEntry(
2178 MF.createExternalSymbolName(Token.stringValue()));
2179 break;
2180 default:
2181 return error(
2182 "expected a global value or an external symbol after 'call-entry'");
2183 }
2184 break;
2185 default:
2186 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~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2186)
;
2187 }
2188 lex();
2189 return false;
2190}
2191
2192bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
2193 if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
2194 Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
2195 Token.is(MIToken::FixedStackObject) || Token.is(MIToken::StackObject) ||
2196 Token.is(MIToken::kw_call_entry)) {
2197 const PseudoSourceValue *PSV = nullptr;
2198 if (parseMemoryPseudoSourceValue(PSV))
2199 return true;
2200 int64_t Offset = 0;
2201 if (parseOffset(Offset))
2202 return true;
2203 Dest = MachinePointerInfo(PSV, Offset);
2204 return false;
2205 }
2206 if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue) &&
2207 Token.isNot(MIToken::GlobalValue) &&
2208 Token.isNot(MIToken::NamedGlobalValue) &&
2209 Token.isNot(MIToken::QuotedIRValue))
2210 return error("expected an IR value reference");
2211 const Value *V = nullptr;
2212 if (parseIRValue(V))
2213 return true;
2214 if (!V->getType()->isPointerTy())
2215 return error("expected a pointer IR value");
2216 lex();
2217 int64_t Offset = 0;
2218 if (parseOffset(Offset))
2219 return true;
2220 Dest = MachinePointerInfo(V, Offset);
2221 return false;
2222}
2223
2224bool MIParser::parseOptionalScope(LLVMContext &Context,
2225 SyncScope::ID &SSID) {
2226 SSID = SyncScope::System;
2227 if (Token.is(MIToken::Identifier) && Token.stringValue() == "syncscope") {
2228 lex();
2229 if (expectAndConsume(MIToken::lparen))
2230 return error("expected '(' in syncscope");
2231
2232 std::string SSN;
2233 if (parseStringConstant(SSN))
2234 return true;
2235
2236 SSID = Context.getOrInsertSyncScopeID(SSN);
2237 if (expectAndConsume(MIToken::rparen))
2238 return error("expected ')' in syncscope");
2239 }
2240
2241 return false;
2242}
2243
2244bool MIParser::parseOptionalAtomicOrdering(AtomicOrdering &Order) {
2245 Order = AtomicOrdering::NotAtomic;
2246 if (Token.isNot(MIToken::Identifier))
2247 return false;
2248
2249 Order = StringSwitch<AtomicOrdering>(Token.stringValue())
2250 .Case("unordered", AtomicOrdering::Unordered)
2251 .Case("monotonic", AtomicOrdering::Monotonic)
2252 .Case("acquire", AtomicOrdering::Acquire)
2253 .Case("release", AtomicOrdering::Release)
2254 .Case("acq_rel", AtomicOrdering::AcquireRelease)
2255 .Case("seq_cst", AtomicOrdering::SequentiallyConsistent)
2256 .Default(AtomicOrdering::NotAtomic);
2257
2258 if (Order != AtomicOrdering::NotAtomic) {
2259 lex();
2260 return false;
2261 }
2262
2263 return error("expected an atomic scope, ordering or a size integer literal");
2264}
2265
2266bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
2267 if (expectAndConsume(MIToken::lparen))
2268 return true;
2269 MachineMemOperand::Flags Flags = MachineMemOperand::MONone;
2270 while (Token.isMemoryOperandFlag()) {
2271 if (parseMemoryOperandFlag(Flags))
2272 return true;
2273 }
2274 if (Token.isNot(MIToken::Identifier) ||
2275 (Token.stringValue() != "load" && Token.stringValue() != "store"))
2276 return error("expected 'load' or 'store' memory operation");
2277 if (Token.stringValue() == "load")
2278 Flags |= MachineMemOperand::MOLoad;
2279 else
2280 Flags |= MachineMemOperand::MOStore;
2281 lex();
2282
2283 // Optional synchronization scope.
2284 SyncScope::ID SSID;
2285 if (parseOptionalScope(MF.getFunction()->getContext(), SSID))
2286 return true;
2287
2288 // Up to two atomic orderings (cmpxchg provides guarantees on failure).
2289 AtomicOrdering Order, FailureOrder;
2290 if (parseOptionalAtomicOrdering(Order))
2291 return true;
2292
2293 if (parseOptionalAtomicOrdering(FailureOrder))
2294 return true;
2295
2296 if (Token.isNot(MIToken::IntegerLiteral))
2297 return error("expected the size integer literal after memory operation");
2298 uint64_t Size;
2299 if (getUint64(Size))
2300 return true;
2301 lex();
2302
2303 MachinePointerInfo Ptr = MachinePointerInfo();
2304 if (Token.is(MIToken::Identifier)) {
2305 const char *Word = Flags & MachineMemOperand::MOLoad ? "from" : "into";
2306 if (Token.stringValue() != Word)
2307 return error(Twine("expected '") + Word + "'");
2308 lex();
2309
2310 if (parseMachinePointerInfo(Ptr))
2311 return true;
2312 }
2313 unsigned BaseAlignment = Size;
2314 AAMDNodes AAInfo;
2315 MDNode *Range = nullptr;
2316 while (consumeIfPresent(MIToken::comma)) {
2317 switch (Token.kind()) {
2318 case MIToken::kw_align:
2319 if (parseAlignment(BaseAlignment))
2320 return true;
2321 break;
2322 case MIToken::md_tbaa:
2323 lex();
2324 if (parseMDNode(AAInfo.TBAA))
2325 return true;
2326 break;
2327 case MIToken::md_alias_scope:
2328 lex();
2329 if (parseMDNode(AAInfo.Scope))
2330 return true;
2331 break;
2332 case MIToken::md_noalias:
2333 lex();
2334 if (parseMDNode(AAInfo.NoAlias))
2335 return true;
2336 break;
2337 case MIToken::md_range:
2338 lex();
2339 if (parseMDNode(Range))
2340 return true;
2341 break;
2342 // TODO: Report an error on duplicate metadata nodes.
2343 default:
2344 return error("expected 'align' or '!tbaa' or '!alias.scope' or "
2345 "'!noalias' or '!range'");
2346 }
2347 }
2348 if (expectAndConsume(MIToken::rparen))
2349 return true;
2350 Dest = MF.getMachineMemOperand(Ptr, Flags, Size, BaseAlignment, AAInfo, Range,
2351 SSID, Order, FailureOrder);
2352 return false;
2353}
2354
2355void MIParser::initNames2InstrOpCodes() {
2356 if (!Names2InstrOpCodes.empty())
2357 return;
2358 const auto *TII = MF.getSubtarget().getInstrInfo();
2359 assert(TII && "Expected target instruction info")(static_cast <bool> (TII && "Expected target instruction info"
) ? void (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2359, __extension__ __PRETTY_FUNCTION__))
;
2360 for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
2361 Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
2362}
2363
2364bool MIParser::parseInstrName(StringRef InstrName, unsigned &OpCode) {
2365 initNames2InstrOpCodes();
2366 auto InstrInfo = Names2InstrOpCodes.find(InstrName);
2367 if (InstrInfo == Names2InstrOpCodes.end())
2368 return true;
2369 OpCode = InstrInfo->getValue();
2370 return false;
2371}
2372
2373void MIParser::initNames2Regs() {
2374 if (!Names2Regs.empty())
2375 return;
2376 // The '%noreg' register is the register 0.
2377 Names2Regs.insert(std::make_pair("noreg", 0));
2378 const auto *TRI = MF.getSubtarget().getRegisterInfo();
2379 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2379, __extension__ __PRETTY_FUNCTION__))
;
2380 for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
2381 bool WasInserted =
2382 Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
2383 .second;
2384 (void)WasInserted;
2385 assert(WasInserted && "Expected registers to be unique case-insensitively")(static_cast <bool> (WasInserted && "Expected registers to be unique case-insensitively"
) ? void (0) : __assert_fail ("WasInserted && \"Expected registers to be unique case-insensitively\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2385, __extension__ __PRETTY_FUNCTION__))
;
2386 }
2387}
2388
2389bool MIParser::getRegisterByName(StringRef RegName, unsigned &Reg) {
2390 initNames2Regs();
2391 auto RegInfo = Names2Regs.find(RegName);
2392 if (RegInfo == Names2Regs.end())
2393 return true;
2394 Reg = RegInfo->getValue();
2395 return false;
2396}
2397
2398void MIParser::initNames2RegMasks() {
2399 if (!Names2RegMasks.empty())
2400 return;
2401 const auto *TRI = MF.getSubtarget().getRegisterInfo();
2402 assert(TRI && "Expected target register info")(static_cast <bool> (TRI && "Expected target register info"
) ? void (0) : __assert_fail ("TRI && \"Expected target register info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2402, __extension__ __PRETTY_FUNCTION__))
;
2403 ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
2404 ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
2405 assert(RegMasks.size() == RegMaskNames.size())(static_cast <bool> (RegMasks.size() == RegMaskNames.size
()) ? void (0) : __assert_fail ("RegMasks.size() == RegMaskNames.size()"
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2405, __extension__ __PRETTY_FUNCTION__))
;
2406 for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
2407 Names2RegMasks.insert(
2408 std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
2409}
2410
2411const uint32_t *MIParser::getRegMask(StringRef Identifier) {
2412 initNames2RegMasks();
2413 auto RegMaskInfo = Names2RegMasks.find(Identifier);
2414 if (RegMaskInfo == Names2RegMasks.end())
2415 return nullptr;
2416 return RegMaskInfo->getValue();
2417}
2418
2419void MIParser::initNames2SubRegIndices() {
2420 if (!Names2SubRegIndices.empty())
2421 return;
2422 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
2423 for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
2424 Names2SubRegIndices.insert(
2425 std::make_pair(StringRef(TRI->getSubRegIndexName(I)).lower(), I));
2426}
2427
2428unsigned MIParser::getSubRegIndex(StringRef Name) {
2429 initNames2SubRegIndices();
2430 auto SubRegInfo = Names2SubRegIndices.find(Name);
2431 if (SubRegInfo == Names2SubRegIndices.end())
2432 return 0;
2433 return SubRegInfo->getValue();
2434}
2435
2436static void initSlots2BasicBlocks(
2437 const Function &F,
2438 DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2439 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2440 MST.incorporateFunction(F);
2441 for (auto &BB : F) {
2442 if (BB.hasName())
2443 continue;
2444 int Slot = MST.getLocalSlot(&BB);
2445 if (Slot == -1)
2446 continue;
2447 Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
2448 }
2449}
2450
2451static const BasicBlock *getIRBlockFromSlot(
2452 unsigned Slot,
2453 const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
2454 auto BlockInfo = Slots2BasicBlocks.find(Slot);
2455 if (BlockInfo == Slots2BasicBlocks.end())
2456 return nullptr;
2457 return BlockInfo->second;
2458}
2459
2460const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
2461 if (Slots2BasicBlocks.empty())
2462 initSlots2BasicBlocks(*MF.getFunction(), Slots2BasicBlocks);
2463 return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
2464}
2465
2466const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
2467 if (&F == MF.getFunction())
2468 return getIRBlock(Slot);
2469 DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
2470 initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
2471 return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
2472}
2473
2474static void mapValueToSlot(const Value *V, ModuleSlotTracker &MST,
2475 DenseMap<unsigned, const Value *> &Slots2Values) {
2476 int Slot = MST.getLocalSlot(V);
2477 if (Slot == -1)
2478 return;
2479 Slots2Values.insert(std::make_pair(unsigned(Slot), V));
2480}
2481
2482/// Creates the mapping from slot numbers to function's unnamed IR values.
2483static void initSlots2Values(const Function &F,
2484 DenseMap<unsigned, const Value *> &Slots2Values) {
2485 ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
2486 MST.incorporateFunction(F);
2487 for (const auto &Arg : F.args())
2488 mapValueToSlot(&Arg, MST, Slots2Values);
2489 for (const auto &BB : F) {
2490 mapValueToSlot(&BB, MST, Slots2Values);
2491 for (const auto &I : BB)
2492 mapValueToSlot(&I, MST, Slots2Values);
2493 }
2494}
2495
2496const Value *MIParser::getIRValue(unsigned Slot) {
2497 if (Slots2Values.empty())
2498 initSlots2Values(*MF.getFunction(), Slots2Values);
2499 auto ValueInfo = Slots2Values.find(Slot);
2500 if (ValueInfo == Slots2Values.end())
2501 return nullptr;
2502 return ValueInfo->second;
2503}
2504
2505void MIParser::initNames2TargetIndices() {
2506 if (!Names2TargetIndices.empty())
2507 return;
2508 const auto *TII = MF.getSubtarget().getInstrInfo();
2509 assert(TII && "Expected target instruction info")(static_cast <bool> (TII && "Expected target instruction info"
) ? void (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2509, __extension__ __PRETTY_FUNCTION__))
;
2510 auto Indices = TII->getSerializableTargetIndices();
2511 for (const auto &I : Indices)
2512 Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
2513}
2514
2515bool MIParser::getTargetIndex(StringRef Name, int &Index) {
2516 initNames2TargetIndices();
2517 auto IndexInfo = Names2TargetIndices.find(Name);
2518 if (IndexInfo == Names2TargetIndices.end())
2519 return true;
2520 Index = IndexInfo->second;
2521 return false;
2522}
2523
2524void MIParser::initNames2DirectTargetFlags() {
2525 if (!Names2DirectTargetFlags.empty())
2526 return;
2527 const auto *TII = MF.getSubtarget().getInstrInfo();
2528 assert(TII && "Expected target instruction info")(static_cast <bool> (TII && "Expected target instruction info"
) ? void (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2528, __extension__ __PRETTY_FUNCTION__))
;
2529 auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
2530 for (const auto &I : Flags)
2531 Names2DirectTargetFlags.insert(
2532 std::make_pair(StringRef(I.second), I.first));
2533}
2534
2535bool MIParser::getDirectTargetFlag(StringRef Name, unsigned &Flag) {
2536 initNames2DirectTargetFlags();
2537 auto FlagInfo = Names2DirectTargetFlags.find(Name);
2538 if (FlagInfo == Names2DirectTargetFlags.end())
2539 return true;
2540 Flag = FlagInfo->second;
2541 return false;
2542}
2543
2544void MIParser::initNames2BitmaskTargetFlags() {
2545 if (!Names2BitmaskTargetFlags.empty())
2546 return;
2547 const auto *TII = MF.getSubtarget().getInstrInfo();
2548 assert(TII && "Expected target instruction info")(static_cast <bool> (TII && "Expected target instruction info"
) ? void (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2548, __extension__ __PRETTY_FUNCTION__))
;
2549 auto Flags = TII->getSerializableBitmaskMachineOperandTargetFlags();
2550 for (const auto &I : Flags)
2551 Names2BitmaskTargetFlags.insert(
2552 std::make_pair(StringRef(I.second), I.first));
2553}
2554
2555bool MIParser::getBitmaskTargetFlag(StringRef Name, unsigned &Flag) {
2556 initNames2BitmaskTargetFlags();
2557 auto FlagInfo = Names2BitmaskTargetFlags.find(Name);
2558 if (FlagInfo == Names2BitmaskTargetFlags.end())
2559 return true;
2560 Flag = FlagInfo->second;
2561 return false;
2562}
2563
2564void MIParser::initNames2MMOTargetFlags() {
2565 if (!Names2MMOTargetFlags.empty())
2566 return;
2567 const auto *TII = MF.getSubtarget().getInstrInfo();
2568 assert(TII && "Expected target instruction info")(static_cast <bool> (TII && "Expected target instruction info"
) ? void (0) : __assert_fail ("TII && \"Expected target instruction info\""
, "/build/llvm-toolchain-snapshot-6.0~svn318631/lib/CodeGen/MIRParser/MIParser.cpp"
, 2568, __extension__ __PRETTY_FUNCTION__))
;
2569 auto Flags = TII->getSerializableMachineMemOperandTargetFlags();
2570 for (const auto &I : Flags)
2571 Names2MMOTargetFlags.insert(
2572 std::make_pair(StringRef(I.second), I.first));
2573}
2574
2575bool MIParser::getMMOTargetFlag(StringRef Name,
2576 MachineMemOperand::Flags &Flag) {
2577 initNames2MMOTargetFlags();
2578 auto FlagInfo = Names2MMOTargetFlags.find(Name);
2579 if (FlagInfo == Names2MMOTargetFlags.end())
2580 return true;
2581 Flag = FlagInfo->second;
2582 return false;
2583}
2584
2585bool MIParser::parseStringConstant(std::string &Result) {
2586 if (Token.isNot(MIToken::StringConstant))
2587 return error("expected string constant");
2588 Result = Token.stringValue();
2589 lex();
2590 return false;
2591}
2592
2593bool llvm::parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS,
2594 StringRef Src,
2595 SMDiagnostic &Error) {
2596 return MIParser(PFS, Error, Src).parseBasicBlockDefinitions(PFS.MBBSlots);
2597}
2598
2599bool llvm::parseMachineInstructions(PerFunctionMIParsingState &PFS,
2600 StringRef Src, SMDiagnostic &Error) {
2601 return MIParser(PFS, Error, Src).parseBasicBlocks();
2602}
2603
2604bool llvm::parseMBBReference(PerFunctionMIParsingState &PFS,
2605 MachineBasicBlock *&MBB, StringRef Src,
2606 SMDiagnostic &Error) {
2607 return MIParser(PFS, Error, Src).parseStandaloneMBB(MBB);
2608}
2609
2610bool llvm::parseRegisterReference(PerFunctionMIParsingState &PFS,
2611 unsigned &Reg, StringRef Src,
2612 SMDiagnostic &Error) {
2613 return MIParser(PFS, Error, Src).parseStandaloneRegister(Reg);
2614}
2615
2616bool llvm::parseNamedRegisterReference(PerFunctionMIParsingState &PFS,
2617 unsigned &Reg, StringRef Src,
2618 SMDiagnostic &Error) {
2619 return MIParser(PFS, Error, Src).parseStandaloneNamedRegister(Reg);
2620}
2621
2622bool llvm::parseVirtualRegisterReference(PerFunctionMIParsingState &PFS,
2623 VRegInfo *&Info, StringRef Src,
2624 SMDiagnostic &Error) {
2625 return MIParser(PFS, Error, Src).parseStandaloneVirtualRegister(Info);
2626}
2627
2628bool llvm::parseStackObjectReference(PerFunctionMIParsingState &PFS,
2629 int &FI, StringRef Src,
2630 SMDiagnostic &Error) {
2631 return MIParser(PFS, Error, Src).parseStandaloneStackObject(FI);
2632}
2633
2634bool llvm::parseMDNode(PerFunctionMIParsingState &PFS,
2635 MDNode *&Node, StringRef Src, SMDiagnostic &Error) {
2636 return MIParser(PFS, Error, Src).parseStandaloneMDNode(Node);
2637}