Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name MIParser.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-11/lib/clang/11.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/lib/CodeGen/MIRParser -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/CodeGen/MIRParser -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-11/lib/clang/11.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/lib/CodeGen/MIRParser -fdebug-prefix-map=/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-03-09-184146-41876-1 -x c++ /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/CodeGen/MIRParser/MIParser.cpp

/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/CodeGen/MIRParser/MIParser.cpp

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

/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/CodeGen/MIRParser/MILexer.h

1//===- MILexer.h - Lexer for machine instructions ---------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file declares the function that lexes the machine instruction source
10// string.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_CODEGEN_MIRPARSER_MILEXER_H
15#define LLVM_LIB_CODEGEN_MIRPARSER_MILEXER_H
16
17#include "llvm/ADT/APSInt.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/StringRef.h"
20#include <string>
21
22namespace llvm {
23
24class Twine;
25
26/// A token produced by the machine instruction lexer.
27struct MIToken {
28 enum TokenKind {
29 // Markers
30 Eof,
31 Error,
32 Newline,
33
34 // Tokens with no info.
35 comma,
36 equal,
37 underscore,
38 colon,
39 coloncolon,
40 dot,
41 exclaim,
42 lparen,
43 rparen,
44 lbrace,
45 rbrace,
46 plus,
47 minus,
48 less,
49 greater,
50
51 // Keywords
52 kw_implicit,
53 kw_implicit_define,
54 kw_def,
55 kw_dead,
56 kw_dereferenceable,
57 kw_killed,
58 kw_undef,
59 kw_internal,
60 kw_early_clobber,
61 kw_debug_use,
62 kw_renamable,
63 kw_tied_def,
64 kw_frame_setup,
65 kw_frame_destroy,
66 kw_nnan,
67 kw_ninf,
68 kw_nsz,
69 kw_arcp,
70 kw_contract,
71 kw_afn,
72 kw_reassoc,
73 kw_nuw,
74 kw_nsw,
75 kw_exact,
76 kw_nofpexcept,
77 kw_debug_location,
78 kw_cfi_same_value,
79 kw_cfi_offset,
80 kw_cfi_rel_offset,
81 kw_cfi_def_cfa_register,
82 kw_cfi_def_cfa_offset,
83 kw_cfi_adjust_cfa_offset,
84 kw_cfi_escape,
85 kw_cfi_def_cfa,
86 kw_cfi_register,
87 kw_cfi_remember_state,
88 kw_cfi_restore,
89 kw_cfi_restore_state,
90 kw_cfi_undefined,
91 kw_cfi_window_save,
92 kw_cfi_aarch64_negate_ra_sign_state,
93 kw_blockaddress,
94 kw_intrinsic,
95 kw_target_index,
96 kw_half,
97 kw_float,
98 kw_double,
99 kw_x86_fp80,
100 kw_fp128,
101 kw_ppc_fp128,
102 kw_target_flags,
103 kw_volatile,
104 kw_non_temporal,
105 kw_invariant,
106 kw_align,
107 kw_addrspace,
108 kw_stack,
109 kw_got,
110 kw_jump_table,
111 kw_constant_pool,
112 kw_call_entry,
113 kw_custom,
114 kw_liveout,
115 kw_address_taken,
116 kw_landing_pad,
117 kw_liveins,
118 kw_successors,
119 kw_floatpred,
120 kw_intpred,
121 kw_shufflemask,
122 kw_pre_instr_symbol,
123 kw_post_instr_symbol,
124 kw_heap_alloc_marker,
125 kw_unknown_size,
126
127 // Named metadata keywords
128 md_tbaa,
129 md_alias_scope,
130 md_noalias,
131 md_range,
132 md_diexpr,
133 md_dilocation,
134
135 // Identifier tokens
136 Identifier,
137 NamedRegister,
138 NamedVirtualRegister,
139 MachineBasicBlockLabel,
140 MachineBasicBlock,
141 StackObject,
142 FixedStackObject,
143 NamedGlobalValue,
144 GlobalValue,
145 ExternalSymbol,
146 MCSymbol,
147
148 // Other tokens
149 IntegerLiteral,
150 FloatingPointLiteral,
151 HexLiteral,
152 VectorLiteral,
153 VirtualRegister,
154 ConstantPoolItem,
155 JumpTableIndex,
156 NamedIRBlock,
157 IRBlock,
158 NamedIRValue,
159 IRValue,
160 QuotedIRValue, // `<constant value>`
161 SubRegisterIndex,
162 StringConstant
163 };
164
165private:
166 TokenKind Kind = Error;
167 StringRef Range;
168 StringRef StringValue;
169 std::string StringValueStorage;
170 APSInt IntVal;
171
172public:
173 MIToken() = default;
174
175 MIToken &reset(TokenKind Kind, StringRef Range);
176
177 MIToken &setStringValue(StringRef StrVal);
178 MIToken &setOwnedStringValue(std::string StrVal);
179 MIToken &setIntegerValue(APSInt IntVal);
180
181 TokenKind kind() const { return Kind; }
5
Returning the value 106, which participates in a condition later
182
183 bool isError() const { return Kind == Error; }
184
185 bool isNewlineOrEOF() const { return Kind == Newline || Kind == Eof; }
186
187 bool isErrorOrEOF() const { return Kind == Error || Kind == Eof; }
188
189 bool isRegister() const {
190 return Kind == NamedRegister || Kind == underscore ||
191 Kind == NamedVirtualRegister || Kind == VirtualRegister;
192 }
193
194 bool isRegisterFlag() const {
195 return Kind == kw_implicit || Kind == kw_implicit_define ||
196 Kind == kw_def || Kind == kw_dead || Kind == kw_killed ||
197 Kind == kw_undef || Kind == kw_internal ||
198 Kind == kw_early_clobber || Kind == kw_debug_use ||
199 Kind == kw_renamable;
200 }
201
202 bool isMemoryOperandFlag() const {
203 return Kind == kw_volatile || Kind == kw_non_temporal ||
204 Kind == kw_dereferenceable || Kind == kw_invariant ||
205 Kind == StringConstant;
206 }
207
208 bool is(TokenKind K) const { return Kind == K; }
209
210 bool isNot(TokenKind K) const { return Kind != K; }
211
212 StringRef::iterator location() const { return Range.begin(); }
213
214 StringRef range() const { return Range; }
215
216 /// Return the token's string value.
217 StringRef stringValue() const { return StringValue; }
218
219 const APSInt &integerValue() const { return IntVal; }
220
221 bool hasIntegerValue() const {
222 return Kind
10.1
Field 'Kind' is not equal to IntegerLiteral
10.1
Field 'Kind' is not equal to IntegerLiteral
== IntegerLiteral || Kind
10.2
Field 'Kind' is not equal to MachineBasicBlock
10.2
Field 'Kind' is not equal to MachineBasicBlock
== MachineBasicBlock ||
11
Returning the value 1, which participates in a condition later
223 Kind
10.3
Field 'Kind' is not equal to MachineBasicBlockLabel
10.3
Field 'Kind' is not equal to MachineBasicBlockLabel
== MachineBasicBlockLabel || Kind
10.4
Field 'Kind' is not equal to StackObject
10.4
Field 'Kind' is not equal to StackObject
== StackObject ||
224 Kind
10.5
Field 'Kind' is not equal to FixedStackObject
10.5
Field 'Kind' is not equal to FixedStackObject
== FixedStackObject || Kind
10.6
Field 'Kind' is equal to GlobalValue
10.6
Field 'Kind' is equal to GlobalValue
== GlobalValue ||
225 Kind == VirtualRegister || Kind == ConstantPoolItem ||
226 Kind == JumpTableIndex || Kind == IRBlock || Kind == IRValue;
227 }
228};
229
230/// Consume a single machine instruction token in the given source and return
231/// the remaining source string.
232StringRef lexMIToken(
233 StringRef Source, MIToken &Token,
234 function_ref<void(StringRef::iterator, const Twine &)> ErrorCallback);
235
236} // end namespace llvm
237
238#endif // LLVM_LIB_CODEGEN_MIRPARSER_MILEXER_H