/usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support/Alignment.h

Bug Summary

File:	src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support/Alignment.h
Warning:	line 85, column 47 The result of the left shift is undefined due to shifting by '255', which is greater or equal to the width of type 'uint64_t'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Analysis -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ASMParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/BinaryFormat -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitstream -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /include/llvm/CodeGen -I /include/llvm/CodeGen/PBQP -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Coroutines -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData/Coverage -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/CodeView -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/DWARF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/MSF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/PDB -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Demangle -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/JITLink -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/Orc -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenACC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenMP -I /include/llvm/CodeGen/GlobalISel -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IRReader -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/LTO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Linker -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC/MCParser -I /include/llvm/CodeGen/MIRParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Object -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Option -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Passes -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Scalar -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ADT -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/Symbolize -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Target -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Utils -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Vectorize -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/IPO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libLLVM/../include -I /usr/src/gnu/usr.bin/clang/libLLVM/obj -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/CodeGen/MIRParser/MIParser.cpp

/usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/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//===----------------------------------------------------------------------===//

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>

84using namespace llvm;

86void PerTargetMIParsingState::setTarget(
const TargetSubtargetInfo &NewSubtarget) {

// If the subtarget changed, over conservatively assume everything is invalid.
if (&Subtarget == &NewSubtarget)
  return;

Names2InstrOpCodes.clear();
Names2Regs.clear();
Names2RegMasks.clear();
Names2SubRegIndices.clear();
Names2TargetIndices.clear();
Names2DirectTargetFlags.clear();
Names2BitmaskTargetFlags.clear();
Names2MMOTargetFlags.clear();

initNames2RegClasses();
initNames2RegBanks();
104}

106void PerTargetMIParsingState::initNames2Regs() {
if (!Names2Regs.empty())
  return;

// The '%noreg' register is the register 0.
Names2Regs.insert(std::make_pair("noreg", 0));
const auto *TRI = Subtarget.getRegisterInfo();
assert(TRI && "Expected target register info")((void)0);

for (unsigned I = 0, E = TRI->getNumRegs(); I < E; ++I) {
  bool WasInserted =
      Names2Regs.insert(std::make_pair(StringRef(TRI->getName(I)).lower(), I))
          .second;
  (void)WasInserted;
  assert(WasInserted && "Expected registers to be unique case-insensitively")((void)0);
}
122}

124bool PerTargetMIParsingState::getRegisterByName(StringRef RegName,
                                              Register &Reg) {
initNames2Regs();
auto RegInfo = Names2Regs.find(RegName);
if (RegInfo == Names2Regs.end())
  return true;
Reg = RegInfo->getValue();
return false;
132}

134void PerTargetMIParsingState::initNames2InstrOpCodes() {
if (!Names2InstrOpCodes.empty())
  return;
const auto *TII = Subtarget.getInstrInfo();
assert(TII && "Expected target instruction info")((void)0);
for (unsigned I = 0, E = TII->getNumOpcodes(); I < E; ++I)
  Names2InstrOpCodes.insert(std::make_pair(StringRef(TII->getName(I)), I));
141}

143bool PerTargetMIParsingState::parseInstrName(StringRef InstrName,
                                           unsigned &OpCode) {
initNames2InstrOpCodes();
auto InstrInfo = Names2InstrOpCodes.find(InstrName);
if (InstrInfo == Names2InstrOpCodes.end())
  return true;
OpCode = InstrInfo->getValue();
return false;
151}

153void PerTargetMIParsingState::initNames2RegMasks() {
if (!Names2RegMasks.empty())
  return;
const auto *TRI = Subtarget.getRegisterInfo();
assert(TRI && "Expected target register info")((void)0);
ArrayRef<const uint32_t *> RegMasks = TRI->getRegMasks();
ArrayRef<const char *> RegMaskNames = TRI->getRegMaskNames();
assert(RegMasks.size() == RegMaskNames.size())((void)0);
for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
  Names2RegMasks.insert(
      std::make_pair(StringRef(RegMaskNames[I]).lower(), RegMasks[I]));
164}

166const uint32_t *PerTargetMIParsingState::getRegMask(StringRef Identifier) {
initNames2RegMasks();
auto RegMaskInfo = Names2RegMasks.find(Identifier);
if (RegMaskInfo == Names2RegMasks.end())
  return nullptr;
return RegMaskInfo->getValue();
172}

174void PerTargetMIParsingState::initNames2SubRegIndices() {
if (!Names2SubRegIndices.empty())
  return;
const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo();
for (unsigned I = 1, E = TRI->getNumSubRegIndices(); I < E; ++I)
  Names2SubRegIndices.insert(
      std::make_pair(TRI->getSubRegIndexName(I), I));
181}

183unsigned PerTargetMIParsingState::getSubRegIndex(StringRef Name) {
initNames2SubRegIndices();
auto SubRegInfo = Names2SubRegIndices.find(Name);
if (SubRegInfo == Names2SubRegIndices.end())
  return 0;
return SubRegInfo->getValue();
189}

191void PerTargetMIParsingState::initNames2TargetIndices() {
if (!Names2TargetIndices.empty())
  return;
const auto *TII = Subtarget.getInstrInfo();
assert(TII && "Expected target instruction info")((void)0);
auto Indices = TII->getSerializableTargetIndices();
for (const auto &I : Indices)
  Names2TargetIndices.insert(std::make_pair(StringRef(I.second), I.first));
199}

201bool PerTargetMIParsingState::getTargetIndex(StringRef Name, int &Index) {
initNames2TargetIndices();
auto IndexInfo = Names2TargetIndices.find(Name);
if (IndexInfo == Names2TargetIndices.end())
  return true;
Index = IndexInfo->second;
return false;
208}

210void PerTargetMIParsingState::initNames2DirectTargetFlags() {
if (!Names2DirectTargetFlags.empty())
  return;

const auto *TII = Subtarget.getInstrInfo();
assert(TII && "Expected target instruction info")((void)0);
auto Flags = TII->getSerializableDirectMachineOperandTargetFlags();
for (const auto &I : Flags)
  Names2DirectTargetFlags.insert(
      std::make_pair(StringRef(I.second), I.first));
220}

222bool PerTargetMIParsingState::getDirectTargetFlag(StringRef Name,
                                                unsigned &Flag) {
initNames2DirectTargetFlags();
auto FlagInfo = Names2DirectTargetFlags.find(Name);
if (FlagInfo == Names2DirectTargetFlags.end())
  return true;
Flag = FlagInfo->second;
return false;
230}

232void PerTargetMIParsingState::initNames2BitmaskTargetFlags() {
if (!Names2BitmaskTargetFlags.empty())
  return;

const auto *TII = Subtarget.getInstrInfo();
assert(TII && "Expected target instruction info")((void)0);
auto Flags = TII->getSerializableBitmaskMachineOperandTargetFlags();
for (const auto &I : Flags)
  Names2BitmaskTargetFlags.insert(
      std::make_pair(StringRef(I.second), I.first));
242}

244bool PerTargetMIParsingState::getBitmaskTargetFlag(StringRef Name,
                                                 unsigned &Flag) {
initNames2BitmaskTargetFlags();
auto FlagInfo = Names2BitmaskTargetFlags.find(Name);
if (FlagInfo == Names2BitmaskTargetFlags.end())
  return true;
Flag = FlagInfo->second;
return false;
252}

254void PerTargetMIParsingState::initNames2MMOTargetFlags() {
if (!Names2MMOTargetFlags.empty())
  return;

const auto *TII = Subtarget.getInstrInfo();
assert(TII && "Expected target instruction info")((void)0);
auto Flags = TII->getSerializableMachineMemOperandTargetFlags();
for (const auto &I : Flags)
  Names2MMOTargetFlags.insert(std::make_pair(StringRef(I.second), I.first));
263}

265bool PerTargetMIParsingState::getMMOTargetFlag(StringRef Name,
                                             MachineMemOperand::Flags &Flag) {
initNames2MMOTargetFlags();
auto FlagInfo = Names2MMOTargetFlags.find(Name);
if (FlagInfo == Names2MMOTargetFlags.end())
  return true;
Flag = FlagInfo->second;
return false;
273}

275void PerTargetMIParsingState::initNames2RegClasses() {
if (!Names2RegClasses.empty())
  return;

const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo();
for (unsigned I = 0, E = TRI->getNumRegClasses(); I < E; ++I) {
  const auto *RC = TRI->getRegClass(I);
  Names2RegClasses.insert(
      std::make_pair(StringRef(TRI->getRegClassName(RC)).lower(), RC));
}
285}

287void PerTargetMIParsingState::initNames2RegBanks() {
if (!Names2RegBanks.empty())
  return;

const RegisterBankInfo *RBI = Subtarget.getRegBankInfo();
// If the target does not support GlobalISel, we may not have a
// register bank info.
if (!RBI)
  return;

for (unsigned I = 0, E = RBI->getNumRegBanks(); I < E; ++I) {
  const auto &RegBank = RBI->getRegBank(I);
  Names2RegBanks.insert(
      std::make_pair(StringRef(RegBank.getName()).lower(), &RegBank));
}
302}

304const TargetRegisterClass *
305PerTargetMIParsingState::getRegClass(StringRef Name) {
auto RegClassInfo = Names2RegClasses.find(Name);
if (RegClassInfo == Names2RegClasses.end())
  return nullptr;
return RegClassInfo->getValue();
310}

312const RegisterBank *PerTargetMIParsingState::getRegBank(StringRef Name) {
auto RegBankInfo = Names2RegBanks.find(Name);
if (RegBankInfo == Names2RegBanks.end())
  return nullptr;
return RegBankInfo->getValue();
317}

319PerFunctionMIParsingState::PerFunctionMIParsingState(MachineFunction &MF,
  SourceMgr &SM, const SlotMapping &IRSlots, PerTargetMIParsingState &T)
: MF(MF), SM(&SM), IRSlots(IRSlots), Target(T) {
322}

324VRegInfo &PerFunctionMIParsingState::getVRegInfo(Register Num) {
auto I = VRegInfos.insert(std::make_pair(Num, nullptr));
if (I.second) {
  MachineRegisterInfo &MRI = MF.getRegInfo();
  VRegInfo *Info = new (Allocator) VRegInfo;
  Info->VReg = MRI.createIncompleteVirtualRegister();
  I.first->second = Info;
}
return *I.first->second;
333}

335VRegInfo &PerFunctionMIParsingState::getVRegInfoNamed(StringRef RegName) {
assert(RegName != "" && "Expected named reg.")((void)0);

auto I = VRegInfosNamed.insert(std::make_pair(RegName.str(), nullptr));
if (I.second) {
2
←
Assuming field 'second' is true→
3
←
Taking true branch→
  VRegInfo *Info = new (Allocator) VRegInfo;
4
←
Calling 'operator new<llvm::MallocAllocator, 4096UL, 4096UL, 128UL>'→
  Info->VReg = MF.getRegInfo().createIncompleteVirtualRegister(RegName);
  I.first->second = Info;
}
return *I.first->second;
345}

347static void mapValueToSlot(const Value *V, ModuleSlotTracker &MST,
                         DenseMap<unsigned, const Value *> &Slots2Values) {
int Slot = MST.getLocalSlot(V);
if (Slot == -1)
  return;
Slots2Values.insert(std::make_pair(unsigned(Slot), V));
353}

355/// Creates the mapping from slot numbers to function's unnamed IR values.
356static void initSlots2Values(const Function &F,
                           DenseMap<unsigned, const Value *> &Slots2Values) {
ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
MST.incorporateFunction(F);
for (const auto &Arg : F.args())
  mapValueToSlot(&Arg, MST, Slots2Values);
for (const auto &BB : F) {
  mapValueToSlot(&BB, MST, Slots2Values);
  for (const auto &I : BB)
    mapValueToSlot(&I, MST, Slots2Values);
}
367}

369const Value* PerFunctionMIParsingState::getIRValue(unsigned Slot) {
if (Slots2Values.empty())
  initSlots2Values(MF.getFunction(), Slots2Values);
return Slots2Values.lookup(Slot);
373}

375namespace {

377/// A wrapper struct around the 'MachineOperand' struct that includes a source
378/// range and other attributes.
379struct ParsedMachineOperand {
MachineOperand Operand;
StringRef::iterator Begin;
StringRef::iterator End;
Optional<unsigned> TiedDefIdx;

ParsedMachineOperand(const MachineOperand &Operand, StringRef::iterator Begin,
                     StringRef::iterator End, Optional<unsigned> &TiedDefIdx)
    : Operand(Operand), Begin(Begin), End(End), TiedDefIdx(TiedDefIdx) {
  if (TiedDefIdx)
    assert(Operand.isReg() && Operand.isUse() &&((void)0)
           "Only used register operands can be tied")((void)0);
}
392};

394class MIParser {
MachineFunction &MF;
SMDiagnostic &Error;
StringRef Source, CurrentSource;
SMRange SourceRange;
MIToken Token;
PerFunctionMIParsingState &PFS;
/// Maps from slot numbers to function's unnamed basic blocks.
DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;

404public:
MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
         StringRef Source);
MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
         StringRef Source, SMRange SourceRange);

/// \p SkipChar gives the number of characters to skip before looking
/// for the next token.
void lex(unsigned SkipChar = 0);

/// Report an error at the current location with the given message.
///
/// This function always return true.
bool error(const Twine &Msg);

/// Report an error at the given location with the given message.
///
/// This function always return true.
bool error(StringRef::iterator Loc, const Twine &Msg);

bool
parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
bool parseBasicBlocks();
bool parse(MachineInstr *&MI);
bool parseStandaloneMBB(MachineBasicBlock *&MBB);
bool parseStandaloneNamedRegister(Register &Reg);
bool parseStandaloneVirtualRegister(VRegInfo *&Info);
bool parseStandaloneRegister(Register &Reg);
bool parseStandaloneStackObject(int &FI);
bool parseStandaloneMDNode(MDNode *&Node);
bool parseMachineMetadata();
bool parseMDTuple(MDNode *&MD, bool IsDistinct);
bool parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);
bool parseMetadata(Metadata *&MD);

bool
parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
bool parseBasicBlock(MachineBasicBlock &MBB,
                     MachineBasicBlock *&AddFalthroughFrom);
bool parseBasicBlockLiveins(MachineBasicBlock &MBB);
bool parseBasicBlockSuccessors(MachineBasicBlock &MBB);

bool parseNamedRegister(Register &Reg);
bool parseVirtualRegister(VRegInfo *&Info);
bool parseNamedVirtualRegister(VRegInfo *&Info);
bool parseRegister(Register &Reg, VRegInfo *&VRegInfo);
bool parseRegisterFlag(unsigned &Flags);
bool parseRegisterClassOrBank(VRegInfo &RegInfo);
bool parseSubRegisterIndex(unsigned &SubReg);
bool parseRegisterTiedDefIndex(unsigned &TiedDefIdx);
bool parseRegisterOperand(MachineOperand &Dest,
                          Optional<unsigned> &TiedDefIdx, bool IsDef = false);
bool parseImmediateOperand(MachineOperand &Dest);
bool parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
                     const Constant *&C);
bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
bool parseLowLevelType(StringRef::iterator Loc, LLT &Ty);
bool parseTypedImmediateOperand(MachineOperand &Dest);
bool parseFPImmediateOperand(MachineOperand &Dest);
bool parseMBBReference(MachineBasicBlock *&MBB);
bool parseMBBOperand(MachineOperand &Dest);
bool parseStackFrameIndex(int &FI);
bool parseStackObjectOperand(MachineOperand &Dest);
bool parseFixedStackFrameIndex(int &FI);
bool parseFixedStackObjectOperand(MachineOperand &Dest);
bool parseGlobalValue(GlobalValue *&GV);
bool parseGlobalAddressOperand(MachineOperand &Dest);
bool parseConstantPoolIndexOperand(MachineOperand &Dest);
bool parseSubRegisterIndexOperand(MachineOperand &Dest);
bool parseJumpTableIndexOperand(MachineOperand &Dest);
bool parseExternalSymbolOperand(MachineOperand &Dest);
bool parseMCSymbolOperand(MachineOperand &Dest);
bool parseMDNode(MDNode *&Node);
bool parseDIExpression(MDNode *&Expr);
bool parseDILocation(MDNode *&Expr);
bool parseMetadataOperand(MachineOperand &Dest);
bool parseCFIOffset(int &Offset);
bool parseCFIRegister(Register &Reg);
bool parseCFIAddressSpace(unsigned &AddressSpace);
bool parseCFIEscapeValues(std::string& Values);
bool parseCFIOperand(MachineOperand &Dest);
bool parseIRBlock(BasicBlock *&BB, const Function &F);
bool parseBlockAddressOperand(MachineOperand &Dest);
bool parseIntrinsicOperand(MachineOperand &Dest);
bool parsePredicateOperand(MachineOperand &Dest);
bool parseShuffleMaskOperand(MachineOperand &Dest);
bool parseTargetIndexOperand(MachineOperand &Dest);
bool parseCustomRegisterMaskOperand(MachineOperand &Dest);
bool parseLiveoutRegisterMaskOperand(MachineOperand &Dest);
bool parseMachineOperand(const unsigned OpCode, const unsigned OpIdx,
                         MachineOperand &Dest,
                         Optional<unsigned> &TiedDefIdx);
bool parseMachineOperandAndTargetFlags(const unsigned OpCode,
                                       const unsigned OpIdx,
                                       MachineOperand &Dest,
                                       Optional<unsigned> &TiedDefIdx);
bool parseOffset(int64_t &Offset);
bool parseAlignment(unsigned &Alignment);
bool parseAddrspace(unsigned &Addrspace);
bool parseSectionID(Optional<MBBSectionID> &SID);
bool parseOperandsOffset(MachineOperand &Op);
bool parseIRValue(const Value *&V);
bool parseMemoryOperandFlag(MachineMemOperand::Flags &Flags);
bool parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV);
bool parseMachinePointerInfo(MachinePointerInfo &Dest);
bool parseOptionalScope(LLVMContext &Context, SyncScope::ID &SSID);
bool parseOptionalAtomicOrdering(AtomicOrdering &Order);
bool parseMachineMemoryOperand(MachineMemOperand *&Dest);
bool parsePreOrPostInstrSymbol(MCSymbol *&Symbol);
bool parseHeapAllocMarker(MDNode *&Node);

bool parseTargetImmMnemonic(const unsigned OpCode, const unsigned OpIdx,
                            MachineOperand &Dest, const MIRFormatter &MF);

518private:
/// Convert the integer literal in the current token into an unsigned integer.
///
/// Return true if an error occurred.
bool getUnsigned(unsigned &Result);

/// Convert the integer literal in the current token into an uint64.
///
/// Return true if an error occurred.
bool getUint64(uint64_t &Result);

/// Convert the hexadecimal literal in the current token into an unsigned
///  APInt with a minimum bitwidth required to represent the value.
///
/// Return true if the literal does not represent an integer value.
bool getHexUint(APInt &Result);

/// If the current token is of the given kind, consume it and return false.
/// Otherwise report an error and return true.
bool expectAndConsume(MIToken::TokenKind TokenKind);

/// If the current token is of the given kind, consume it and return true.
/// Otherwise return false.
bool consumeIfPresent(MIToken::TokenKind TokenKind);

bool parseInstruction(unsigned &OpCode, unsigned &Flags);

bool assignRegisterTies(MachineInstr &MI,
                        ArrayRef<ParsedMachineOperand> Operands);

bool verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
                            const MCInstrDesc &MCID);

const BasicBlock *getIRBlock(unsigned Slot);
const BasicBlock *getIRBlock(unsigned Slot, const Function &F);

/// Get or create an MCSymbol for a given name.
MCSymbol *getOrCreateMCSymbol(StringRef Name);

/// parseStringConstant
///   ::= StringConstant
bool parseStringConstant(std::string &Result);

/// Map the location in the MI string to the corresponding location specified
/// in `SourceRange`.
SMLoc mapSMLoc(StringRef::iterator Loc);
564};

566} // end anonymous namespace

568MIParser::MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
                 StringRef Source)
  : MF(PFS.MF), Error(Error), Source(Source), CurrentSource(Source), PFS(PFS)
571{}

573MIParser::MIParser(PerFunctionMIParsingState &PFS, SMDiagnostic &Error,
                 StringRef Source, SMRange SourceRange)
  : MF(PFS.MF), Error(Error), Source(Source), CurrentSource(Source),
    SourceRange(SourceRange), PFS(PFS) {}

578void MIParser::lex(unsigned SkipChar) {
CurrentSource = lexMIToken(
    CurrentSource.slice(SkipChar, StringRef::npos), Token,
    [this](StringRef::iterator Loc, const Twine &Msg) { error(Loc, Msg); });
582}

584bool MIParser::error(const Twine &Msg) { return error(Token.location(), Msg); }

586bool MIParser::error(StringRef::iterator Loc, const Twine &Msg) {
const SourceMgr &SM = *PFS.SM;
assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()))((void)0);
const MemoryBuffer &Buffer = *SM.getMemoryBuffer(SM.getMainFileID());
if (Loc >= Buffer.getBufferStart() && Loc <= Buffer.getBufferEnd()) {
  // Create an ordinary diagnostic when the source manager's buffer is the
  // source string.
  Error = SM.GetMessage(SMLoc::getFromPointer(Loc), SourceMgr::DK_Error, Msg);
  return true;
}
// Create a diagnostic for a YAML string literal.
Error = SMDiagnostic(SM, SMLoc(), Buffer.getBufferIdentifier(), 1,
                     Loc - Source.data(), SourceMgr::DK_Error, Msg.str(),
                     Source, None, None);
return true;
601}

603SMLoc MIParser::mapSMLoc(StringRef::iterator Loc) {
assert(SourceRange.isValid() && "Invalid source range")((void)0);
assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()))((void)0);
return SMLoc::getFromPointer(SourceRange.Start.getPointer() +
                             (Loc - Source.data()));
608}

610typedef function_ref<bool(StringRef::iterator Loc, const Twine &)>
  ErrorCallbackType;

613static const char *toString(MIToken::TokenKind TokenKind) {
switch (TokenKind) {
case MIToken::comma:
  return "','";
case MIToken::equal:
  return "'='";
case MIToken::colon:
  return "':'";
case MIToken::lparen:
  return "'('";
case MIToken::rparen:
  return "')'";
default:
  return "<unknown token>";
}
628}

630bool MIParser::expectAndConsume(MIToken::TokenKind TokenKind) {
if (Token.isNot(TokenKind))
  return error(Twine("expected ") + toString(TokenKind));
lex();
return false;
635}

637bool MIParser::consumeIfPresent(MIToken::TokenKind TokenKind) {
if (Token.isNot(TokenKind))
  return false;
lex();
return true;
642}

644// Parse Machine Basic Block Section ID.
645bool MIParser::parseSectionID(Optional<MBBSectionID> &SID) {
assert(Token.is(MIToken::kw_bbsections))((void)0);
lex();
if (Token.is(MIToken::IntegerLiteral)) {
  unsigned Value = 0;
  if (getUnsigned(Value))
    return error("Unknown Section ID");
  SID = MBBSectionID{Value};
} else {
  const StringRef &S = Token.stringValue();
  if (S == "Exception")
    SID = MBBSectionID::ExceptionSectionID;
  else if (S == "Cold")
    SID = MBBSectionID::ColdSectionID;
  else
    return error("Unknown Section ID");
}
lex();
return false;
664}

666bool MIParser::parseBasicBlockDefinition(
  DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
assert(Token.is(MIToken::MachineBasicBlockLabel))((void)0);
unsigned ID = 0;
if (getUnsigned(ID))
  return true;
auto Loc = Token.location();
auto Name = Token.stringValue();
lex();
bool HasAddressTaken = false;
bool IsLandingPad = false;
bool IsEHFuncletEntry = false;
Optional<MBBSectionID> SectionID;
unsigned Alignment = 0;
BasicBlock *BB = nullptr;
if (consumeIfPresent(MIToken::lparen)) {
  do {
    // TODO: Report an error when multiple same attributes are specified.
    switch (Token.kind()) {
    case MIToken::kw_address_taken:
      HasAddressTaken = true;
      lex();
      break;
    case MIToken::kw_landing_pad:
      IsLandingPad = true;
      lex();
      break;
    case MIToken::kw_ehfunclet_entry:
      IsEHFuncletEntry = true;
      lex();
      break;
    case MIToken::kw_align:
      if (parseAlignment(Alignment))
        return true;
      break;
    case MIToken::IRBlock:
      // TODO: Report an error when both name and ir block are specified.
      if (parseIRBlock(BB, MF.getFunction()))
        return true;
      lex();
      break;
    case MIToken::kw_bbsections:
      if (parseSectionID(SectionID))
        return true;
      break;
    default:
      break;
    }
  } while (consumeIfPresent(MIToken::comma));
  if (expectAndConsume(MIToken::rparen))
    return true;
}
if (expectAndConsume(MIToken::colon))
  return true;

if (!Name.empty()) {
  BB = dyn_cast_or_null<BasicBlock>(
      MF.getFunction().getValueSymbolTable()->lookup(Name));
  if (!BB)
    return error(Loc, Twine("basic block '") + Name +
                          "' is not defined in the function '" +
                          MF.getName() + "'");
}
auto *MBB = MF.CreateMachineBasicBlock(BB);
MF.insert(MF.end(), MBB);
bool WasInserted = MBBSlots.insert(std::make_pair(ID, MBB)).second;
if (!WasInserted)
  return error(Loc, Twine("redefinition of machine basic block with id #") +
                        Twine(ID));
if (Alignment)
  MBB->setAlignment(Align(Alignment));
if (HasAddressTaken)
  MBB->setHasAddressTaken();
MBB->setIsEHPad(IsLandingPad);
MBB->setIsEHFuncletEntry(IsEHFuncletEntry);
if (SectionID.hasValue()) {
  MBB->setSectionID(SectionID.getValue());
  MF.setBBSectionsType(BasicBlockSection::List);
}
return false;
746}

748bool MIParser::parseBasicBlockDefinitions(
  DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
lex();
// Skip until the first machine basic block.
while (Token.is(MIToken::Newline))
  lex();
if (Token.isErrorOrEOF())
  return Token.isError();
if (Token.isNot(MIToken::MachineBasicBlockLabel))
  return error("expected a basic block definition before instructions");
unsigned BraceDepth = 0;
do {
  if (parseBasicBlockDefinition(MBBSlots))
    return true;
  bool IsAfterNewline = false;
  // Skip until the next machine basic block.
  while (true) {
    if ((Token.is(MIToken::MachineBasicBlockLabel) && IsAfterNewline) ||
        Token.isErrorOrEOF())
      break;
    else if (Token.is(MIToken::MachineBasicBlockLabel))
      return error("basic block definition should be located at the start of "
                   "the line");
    else if (consumeIfPresent(MIToken::Newline)) {
      IsAfterNewline = true;
      continue;
    }
    IsAfterNewline = false;
    if (Token.is(MIToken::lbrace))
      ++BraceDepth;
    if (Token.is(MIToken::rbrace)) {
      if (!BraceDepth)
        return error("extraneous closing brace ('}')");
      --BraceDepth;
    }
    lex();
  }
  // Verify that we closed all of the '{' at the end of a file or a block.
  if (!Token.isError() && BraceDepth)
    return error("expected '}'"); // FIXME: Report a note that shows '{'.
} while (!Token.isErrorOrEOF());
return Token.isError();
790}

792bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
assert(Token.is(MIToken::kw_liveins))((void)0);
lex();
if (expectAndConsume(MIToken::colon))
  return true;
if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
  return false;
do {
  if (Token.isNot(MIToken::NamedRegister))
    return error("expected a named register");
  Register Reg;
  if (parseNamedRegister(Reg))
    return true;
  lex();
  LaneBitmask Mask = LaneBitmask::getAll();
  if (consumeIfPresent(MIToken::colon)) {
    // Parse lane mask.
    if (Token.isNot(MIToken::IntegerLiteral) &&
        Token.isNot(MIToken::HexLiteral))
      return error("expected a lane mask");
    static_assert(sizeof(LaneBitmask::Type) == sizeof(uint64_t),
                  "Use correct get-function for lane mask");
    LaneBitmask::Type V;
    if (getUint64(V))
      return error("invalid lane mask value");
    Mask = LaneBitmask(V);
    lex();
  }
  MBB.addLiveIn(Reg, Mask);
} while (consumeIfPresent(MIToken::comma));
return false;
823}

825bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
assert(Token.is(MIToken::kw_successors))((void)0);
lex();
if (expectAndConsume(MIToken::colon))
  return true;
if (Token.isNewlineOrEOF()) // Allow an empty list of successors.
  return false;
do {
  if (Token.isNot(MIToken::MachineBasicBlock))
    return error("expected a machine basic block reference");
  MachineBasicBlock *SuccMBB = nullptr;
  if (parseMBBReference(SuccMBB))
    return true;
  lex();
  unsigned Weight = 0;
  if (consumeIfPresent(MIToken::lparen)) {
    if (Token.isNot(MIToken::IntegerLiteral) &&
        Token.isNot(MIToken::HexLiteral))
      return error("expected an integer literal after '('");
    if (getUnsigned(Weight))
      return true;
    lex();
    if (expectAndConsume(MIToken::rparen))
      return true;
  }
  MBB.addSuccessor(SuccMBB, BranchProbability::getRaw(Weight));
} while (consumeIfPresent(MIToken::comma));
MBB.normalizeSuccProbs();
return false;
854}

856bool MIParser::parseBasicBlock(MachineBasicBlock &MBB,
                             MachineBasicBlock *&AddFalthroughFrom) {
// Skip the definition.
assert(Token.is(MIToken::MachineBasicBlockLabel))((void)0);
lex();
if (consumeIfPresent(MIToken::lparen)) {
  while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
    lex();
  consumeIfPresent(MIToken::rparen);
}
consumeIfPresent(MIToken::colon);

// Parse the liveins and successors.
// N.B: Multiple lists of successors and liveins are allowed and they're
// merged into one.
// Example:
//   liveins: %edi
//   liveins: %esi
//
// is equivalent to
//   liveins: %edi, %esi
bool ExplicitSuccessors = false;
while (true) {
  if (Token.is(MIToken::kw_successors)) {
    if (parseBasicBlockSuccessors(MBB))
      return true;
    ExplicitSuccessors = true;
  } else if (Token.is(MIToken::kw_liveins)) {
    if (parseBasicBlockLiveins(MBB))
      return true;
  } else if (consumeIfPresent(MIToken::Newline)) {
    continue;
  } else
    break;
  if (!Token.isNewlineOrEOF())
    return error("expected line break at the end of a list");
  lex();
}

// Parse the instructions.
bool IsInBundle = false;
MachineInstr *PrevMI = nullptr;
while (!Token.is(MIToken::MachineBasicBlockLabel) &&
       !Token.is(MIToken::Eof)) {
  if (consumeIfPresent(MIToken::Newline))
    continue;
  if (consumeIfPresent(MIToken::rbrace)) {
    // The first parsing pass should verify that all closing '}' have an
    // opening '{'.
    assert(IsInBundle)((void)0);
    IsInBundle = false;
    continue;
  }
  MachineInstr *MI = nullptr;
  if (parse(MI))
    return true;
  MBB.insert(MBB.end(), MI);
  if (IsInBundle) {
    PrevMI->setFlag(MachineInstr::BundledSucc);
    MI->setFlag(MachineInstr::BundledPred);
  }
  PrevMI = MI;
  if (Token.is(MIToken::lbrace)) {
    if (IsInBundle)
      return error("nested instruction bundles are not allowed");
    lex();
    // This instruction is the start of the bundle.
    MI->setFlag(MachineInstr::BundledSucc);
    IsInBundle = true;
    if (!Token.is(MIToken::Newline))
      // The next instruction can be on the same line.
      continue;
  }
  assert(Token.isNewlineOrEOF() && "MI is not fully parsed")((void)0);
  lex();
}

// Construct successor list by searching for basic block machine operands.
if (!ExplicitSuccessors) {
  SmallVector<MachineBasicBlock*,4> Successors;
  bool IsFallthrough;
  guessSuccessors(MBB, Successors, IsFallthrough);
  for (MachineBasicBlock *Succ : Successors)
    MBB.addSuccessor(Succ);

  if (IsFallthrough) {
    AddFalthroughFrom = &MBB;
  } else {
    MBB.normalizeSuccProbs();
  }
}

return false;
949}

951bool MIParser::parseBasicBlocks() {
lex();
// Skip until the first machine basic block.
while (Token.is(MIToken::Newline))
  lex();
if (Token.isErrorOrEOF())
  return Token.isError();
// The first parsing pass should have verified that this token is a MBB label
// in the 'parseBasicBlockDefinitions' method.
assert(Token.is(MIToken::MachineBasicBlockLabel))((void)0);
MachineBasicBlock *AddFalthroughFrom = nullptr;
do {
  MachineBasicBlock *MBB = nullptr;
  if (parseMBBReference(MBB))
    return true;
  if (AddFalthroughFrom) {
    if (!AddFalthroughFrom->isSuccessor(MBB))
      AddFalthroughFrom->addSuccessor(MBB);
    AddFalthroughFrom->normalizeSuccProbs();
    AddFalthroughFrom = nullptr;
  }
  if (parseBasicBlock(*MBB, AddFalthroughFrom))
    return true;
  // The method 'parseBasicBlock' should parse the whole block until the next
  // block or the end of file.
  assert(Token.is(MIToken::MachineBasicBlockLabel) || Token.is(MIToken::Eof))((void)0);
} while (Token.isNot(MIToken::Eof));
return false;
979}

981bool MIParser::parse(MachineInstr *&MI) {
// Parse any register operands before '='
MachineOperand MO = MachineOperand::CreateImm(0);
SmallVector<ParsedMachineOperand, 8> Operands;
while (Token.isRegister() || Token.isRegisterFlag()) {
  auto Loc = Token.location();
  Optional<unsigned> TiedDefIdx;
  if (parseRegisterOperand(MO, TiedDefIdx, /*IsDef=*/true))
    return true;
  Operands.push_back(
      ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
  if (Token.isNot(MIToken::comma))
    break;
  lex();
}
if (!Operands.empty() && expectAndConsume(MIToken::equal))
  return true;

unsigned OpCode, Flags = 0;
if (Token.isError() || parseInstruction(OpCode, Flags))
  return true;

// Parse the remaining machine operands.
while (!Token.isNewlineOrEOF() && Token.isNot(MIToken::kw_pre_instr_symbol) &&
       Token.isNot(MIToken::kw_post_instr_symbol) &&
       Token.isNot(MIToken::kw_heap_alloc_marker) &&
       Token.isNot(MIToken::kw_debug_location) &&
       Token.isNot(MIToken::kw_debug_instr_number) &&
       Token.isNot(MIToken::coloncolon) && Token.isNot(MIToken::lbrace)) {
  auto Loc = Token.location();
  Optional<unsigned> TiedDefIdx;
  if (parseMachineOperandAndTargetFlags(OpCode, Operands.size(), MO, TiedDefIdx))
    return true;
  if ((OpCode == TargetOpcode::DBG_VALUE ||
       OpCode == TargetOpcode::DBG_VALUE_LIST) &&
      MO.isReg())
    MO.setIsDebug();
  Operands.push_back(
      ParsedMachineOperand(MO, Loc, Token.location(), TiedDefIdx));
  if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
      Token.is(MIToken::lbrace))
    break;
  if (Token.isNot(MIToken::comma))
    return error("expected ',' before the next machine operand");
  lex();
}

MCSymbol *PreInstrSymbol = nullptr;
if (Token.is(MIToken::kw_pre_instr_symbol))
  if (parsePreOrPostInstrSymbol(PreInstrSymbol))
    return true;
MCSymbol *PostInstrSymbol = nullptr;
if (Token.is(MIToken::kw_post_instr_symbol))
  if (parsePreOrPostInstrSymbol(PostInstrSymbol))
    return true;
MDNode *HeapAllocMarker = nullptr;
if (Token.is(MIToken::kw_heap_alloc_marker))
  if (parseHeapAllocMarker(HeapAllocMarker))
    return true;

unsigned InstrNum = 0;
if (Token.is(MIToken::kw_debug_instr_number)) {
  lex();
  if (Token.isNot(MIToken::IntegerLiteral))
    return error("expected an integer literal after 'debug-instr-number'");
  if (getUnsigned(InstrNum))
    return true;
  lex();
  // Lex past trailing comma if present.
  if (Token.is(MIToken::comma))
    lex();
}

DebugLoc DebugLocation;
if (Token.is(MIToken::kw_debug_location)) {
  lex();
  MDNode *Node = nullptr;
  if (Token.is(MIToken::exclaim)) {
    if (parseMDNode(Node))
      return true;
  } else if (Token.is(MIToken::md_dilocation)) {
    if (parseDILocation(Node))
      return true;
  } else
    return error("expected a metadata node after 'debug-location'");
  if (!isa<DILocation>(Node))
    return error("referenced metadata is not a DILocation");
  DebugLocation = DebugLoc(Node);
}

// Parse the machine memory operands.
SmallVector<MachineMemOperand *, 2> MemOperands;
if (Token.is(MIToken::coloncolon)) {
  lex();
  while (!Token.isNewlineOrEOF()) {
    MachineMemOperand *MemOp = nullptr;
    if (parseMachineMemoryOperand(MemOp))
      return true;
    MemOperands.push_back(MemOp);
    if (Token.isNewlineOrEOF())
      break;
    if (Token.isNot(MIToken::comma))
      return error("expected ',' before the next machine memory operand");
    lex();
  }
}

const auto &MCID = MF.getSubtarget().getInstrInfo()->get(OpCode);
if (!MCID.isVariadic()) {
  // FIXME: Move the implicit operand verification to the machine verifier.
  if (verifyImplicitOperands(Operands, MCID))
    return true;
}

// TODO: Check for extraneous machine operands.
MI = MF.CreateMachineInstr(MCID, DebugLocation, /*NoImplicit=*/true);
MI->setFlags(Flags);
for (const auto &Operand : Operands)
  MI->addOperand(MF, Operand.Operand);
if (assignRegisterTies(*MI, Operands))
  return true;
if (PreInstrSymbol)
  MI->setPreInstrSymbol(MF, PreInstrSymbol);
if (PostInstrSymbol)
  MI->setPostInstrSymbol(MF, PostInstrSymbol);
if (HeapAllocMarker)
  MI->setHeapAllocMarker(MF, HeapAllocMarker);
if (!MemOperands.empty())
  MI->setMemRefs(MF, MemOperands);
if (InstrNum)
  MI->setDebugInstrNum(InstrNum);
return false;
1113}

1115bool MIParser::parseStandaloneMBB(MachineBasicBlock *&MBB) {
lex();
if (Token.isNot(MIToken::MachineBasicBlock))
  return error("expected a machine basic block reference");
if (parseMBBReference(MBB))
  return true;
lex();
if (Token.isNot(MIToken::Eof))
  return error(
      "expected end of string after the machine basic block reference");
return false;
1126}

1128bool MIParser::parseStandaloneNamedRegister(Register &Reg) {
lex();
if (Token.isNot(MIToken::NamedRegister))
  return error("expected a named register");
if (parseNamedRegister(Reg))
  return true;
lex();
if (Token.isNot(MIToken::Eof))
  return error("expected end of string after the register reference");
return false;
1138}

1140bool MIParser::parseStandaloneVirtualRegister(VRegInfo *&Info) {
lex();
if (Token.isNot(MIToken::VirtualRegister))
  return error("expected a virtual register");
if (parseVirtualRegister(Info))
  return true;
lex();
if (Token.isNot(MIToken::Eof))
  return error("expected end of string after the register reference");
return false;
1150}

1152bool MIParser::parseStandaloneRegister(Register &Reg) {
lex();
if (Token.isNot(MIToken::NamedRegister) &&
    Token.isNot(MIToken::VirtualRegister))
  return error("expected either a named or virtual register");

VRegInfo *Info;
if (parseRegister(Reg, Info))
  return true;

lex();
if (Token.isNot(MIToken::Eof))
  return error("expected end of string after the register reference");
return false;
1166}

1168bool MIParser::parseStandaloneStackObject(int &FI) {
lex();
if (Token.isNot(MIToken::StackObject))
  return error("expected a stack object");
if (parseStackFrameIndex(FI))
  return true;
if (Token.isNot(MIToken::Eof))
  return error("expected end of string after the stack object reference");
return false;
1177}

1179bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
lex();
if (Token.is(MIToken::exclaim)) {
  if (parseMDNode(Node))
    return true;
} else if (Token.is(MIToken::md_diexpr)) {
  if (parseDIExpression(Node))
    return true;
} else if (Token.is(MIToken::md_dilocation)) {
  if (parseDILocation(Node))
    return true;
} else
  return error("expected a metadata node");
if (Token.isNot(MIToken::Eof))
  return error("expected end of string after the metadata node");
return false;
1195}

1197bool MIParser::parseMachineMetadata() {
lex();
if (Token.isNot(MIToken::exclaim))
  return error("expected a metadata node");

lex();
if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
  return error("expected metadata id after '!'");
unsigned ID = 0;
if (getUnsigned(ID))
  return true;
lex();
if (expectAndConsume(MIToken::equal))
  return true;
bool IsDistinct = Token.is(MIToken::kw_distinct);
if (IsDistinct)
  lex();
if (Token.isNot(MIToken::exclaim))
  return error("expected a metadata node");
lex();

MDNode *MD;
if (parseMDTuple(MD, IsDistinct))
  return true;

auto FI = PFS.MachineForwardRefMDNodes.find(ID);
if (FI != PFS.MachineForwardRefMDNodes.end()) {
  FI->second.first->replaceAllUsesWith(MD);
  PFS.MachineForwardRefMDNodes.erase(FI);

  assert(PFS.MachineMetadataNodes[ID] == MD && "Tracking VH didn't work")((void)0);
} else {
  if (PFS.MachineMetadataNodes.count(ID))
    return error("Metadata id is already used");
  PFS.MachineMetadataNodes[ID].reset(MD);
}

return false;
1235}

1237bool MIParser::parseMDTuple(MDNode *&MD, bool IsDistinct) {
SmallVector<Metadata *, 16> Elts;
if (parseMDNodeVector(Elts))
  return true;
MD = (IsDistinct ? MDTuple::getDistinct
                 : MDTuple::get)(MF.getFunction().getContext(), Elts);
return false;
1244}

1246bool MIParser::parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts) {
if (Token.isNot(MIToken::lbrace))
  return error("expected '{' here");
lex();

if (Token.is(MIToken::rbrace)) {
  lex();
  return false;
}

do {
  Metadata *MD;
  if (parseMetadata(MD))
    return true;

  Elts.push_back(MD);

  if (Token.isNot(MIToken::comma))
    break;
  lex();
} while (true);

if (Token.isNot(MIToken::rbrace))
  return error("expected end of metadata node");
lex();

return false;
1273}

1275// ::= !42
1276// ::= !"string"
1277bool MIParser::parseMetadata(Metadata *&MD) {
if (Token.isNot(MIToken::exclaim))
  return error("expected '!' here");
lex();

if (Token.is(MIToken::StringConstant)) {
  std::string Str;
  if (parseStringConstant(Str))
    return true;
  MD = MDString::get(MF.getFunction().getContext(), Str);
  return false;
}

if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
  return error("expected metadata id after '!'");

SMLoc Loc = mapSMLoc(Token.location());

unsigned ID = 0;
if (getUnsigned(ID))
  return true;
lex();

auto NodeInfo = PFS.IRSlots.MetadataNodes.find(ID);
if (NodeInfo != PFS.IRSlots.MetadataNodes.end()) {
  MD = NodeInfo->second.get();
  return false;
}
// Check machine metadata.
NodeInfo = PFS.MachineMetadataNodes.find(ID);
if (NodeInfo != PFS.MachineMetadataNodes.end()) {
  MD = NodeInfo->second.get();
  return false;
}
// Forward reference.
auto &FwdRef = PFS.MachineForwardRefMDNodes[ID];
FwdRef = std::make_pair(
    MDTuple::getTemporary(MF.getFunction().getContext(), None), Loc);
PFS.MachineMetadataNodes[ID].reset(FwdRef.first.get());
MD = FwdRef.first.get();

return false;
1319}

1321static const char *printImplicitRegisterFlag(const MachineOperand &MO) {
assert(MO.isImplicit())((void)0);
return MO.isDef() ? "implicit-def" : "implicit";
1324}

1326static std::string getRegisterName(const TargetRegisterInfo *TRI,
                                 Register Reg) {
assert(Register::isPhysicalRegister(Reg) && "expected phys reg")((void)0);
return StringRef(TRI->getName(Reg)).lower();
1330}

1332/// Return true if the parsed machine operands contain a given machine operand.
1333static bool isImplicitOperandIn(const MachineOperand &ImplicitOperand,
                              ArrayRef<ParsedMachineOperand> Operands) {
for (const auto &I : Operands) {
  if (ImplicitOperand.isIdenticalTo(I.Operand))
    return true;
}
return false;
1340}

1342bool MIParser::verifyImplicitOperands(ArrayRef<ParsedMachineOperand> Operands,
                                    const MCInstrDesc &MCID) {
if (MCID.isCall())
  // We can't verify call instructions as they can contain arbitrary implicit
  // register and register mask operands.
  return false;

// Gather all the expected implicit operands.
SmallVector<MachineOperand, 4> ImplicitOperands;
if (MCID.ImplicitDefs)
  for (const MCPhysReg *ImpDefs = MCID.getImplicitDefs(); *ImpDefs; ++ImpDefs)
    ImplicitOperands.push_back(
        MachineOperand::CreateReg(*ImpDefs, true, true));
if (MCID.ImplicitUses)
  for (const MCPhysReg *ImpUses = MCID.getImplicitUses(); *ImpUses; ++ImpUses)
    ImplicitOperands.push_back(
        MachineOperand::CreateReg(*ImpUses, false, true));

const auto *TRI = MF.getSubtarget().getRegisterInfo();
assert(TRI && "Expected target register info")((void)0);
for (const auto &I : ImplicitOperands) {
  if (isImplicitOperandIn(I, Operands))
    continue;
  return error(Operands.empty() ? Token.location() : Operands.back().End,
               Twine("missing implicit register operand '") +
                   printImplicitRegisterFlag(I) + " $" +
                   getRegisterName(TRI, I.getReg()) + "'");
}
return false;
1371}

1373bool MIParser::parseInstruction(unsigned &OpCode, unsigned &Flags) {
// Allow frame and fast math flags for OPCODE
while (Token.is(MIToken::kw_frame_setup) ||
       Token.is(MIToken::kw_frame_destroy) ||
       Token.is(MIToken::kw_nnan) ||
       Token.is(MIToken::kw_ninf) ||
       Token.is(MIToken::kw_nsz) ||
       Token.is(MIToken::kw_arcp) ||
       Token.is(MIToken::kw_contract) ||
       Token.is(MIToken::kw_afn) ||
       Token.is(MIToken::kw_reassoc) ||
       Token.is(MIToken::kw_nuw) ||
       Token.is(MIToken::kw_nsw) ||
       Token.is(MIToken::kw_exact) ||
       Token.is(MIToken::kw_nofpexcept)) {
  // Mine frame and fast math flags
  if (Token.is(MIToken::kw_frame_setup))
    Flags |= MachineInstr::FrameSetup;
  if (Token.is(MIToken::kw_frame_destroy))
    Flags |= MachineInstr::FrameDestroy;
  if (Token.is(MIToken::kw_nnan))
    Flags |= MachineInstr::FmNoNans;
  if (Token.is(MIToken::kw_ninf))
    Flags |= MachineInstr::FmNoInfs;
  if (Token.is(MIToken::kw_nsz))
    Flags |= MachineInstr::FmNsz;
  if (Token.is(MIToken::kw_arcp))
    Flags |= MachineInstr::FmArcp;
  if (Token.is(MIToken::kw_contract))
    Flags |= MachineInstr::FmContract;
  if (Token.is(MIToken::kw_afn))
    Flags |= MachineInstr::FmAfn;
  if (Token.is(MIToken::kw_reassoc))
    Flags |= MachineInstr::FmReassoc;
  if (Token.is(MIToken::kw_nuw))
    Flags |= MachineInstr::NoUWrap;
  if (Token.is(MIToken::kw_nsw))
    Flags |= MachineInstr::NoSWrap;
  if (Token.is(MIToken::kw_exact))
    Flags |= MachineInstr::IsExact;
  if (Token.is(MIToken::kw_nofpexcept))
    Flags |= MachineInstr::NoFPExcept;

  lex();
}
if (Token.isNot(MIToken::Identifier))
  return error("expected a machine instruction");
StringRef InstrName = Token.stringValue();
if (PFS.Target.parseInstrName(InstrName, OpCode))
  return error(Twine("unknown machine instruction name '") + InstrName + "'");
lex();
return false;
1425}

1427bool MIParser::parseNamedRegister(Register &Reg) {
assert(Token.is(MIToken::NamedRegister) && "Needs NamedRegister token")((void)0);
StringRef Name = Token.stringValue();
if (PFS.Target.getRegisterByName(Name, Reg))
  return error(Twine("unknown register name '") + Name + "'");
return false;
1433}

1435bool MIParser::parseNamedVirtualRegister(VRegInfo *&Info) {
assert(Token.is(MIToken::NamedVirtualRegister) && "Expected NamedVReg token")((void)0);
StringRef Name = Token.stringValue();
// TODO: Check that the VReg name is not the same as a physical register name.
//       If it is, then print a warning (when warnings are implemented).
Info = &PFS.getVRegInfoNamed(Name);
1
Calling 'PerFunctionMIParsingState::getVRegInfoNamed'→
return false;
1442}

1444bool MIParser::parseVirtualRegister(VRegInfo *&Info) {
if (Token.is(MIToken::NamedVirtualRegister))
  return parseNamedVirtualRegister(Info);
assert(Token.is(MIToken::VirtualRegister) && "Needs VirtualRegister token")((void)0);
unsigned ID;
if (getUnsigned(ID))
  return true;
Info = &PFS.getVRegInfo(ID);
return false;
1453}

1455bool MIParser::parseRegister(Register &Reg, VRegInfo *&Info) {
switch (Token.kind()) {
case MIToken::underscore:
  Reg = 0;
  return false;
case MIToken::NamedRegister:
  return parseNamedRegister(Reg);
case MIToken::NamedVirtualRegister:
case MIToken::VirtualRegister:
  if (parseVirtualRegister(Info))
    return true;
  Reg = Info->VReg;
  return false;
// TODO: Parse other register kinds.
default:
  llvm_unreachable("The current token should be a register")__builtin_unreachable();
}
1472}

1474bool MIParser::parseRegisterClassOrBank(VRegInfo &RegInfo) {
if (Token.isNot(MIToken::Identifier) && Token.isNot(MIToken::underscore))
  return error("expected '_', register class, or register bank name");
StringRef::iterator Loc = Token.location();
StringRef Name = Token.stringValue();

// Was it a register class?
const TargetRegisterClass *RC = PFS.Target.getRegClass(Name);
if (RC) {
  lex();

  switch (RegInfo.Kind) {
  case VRegInfo::UNKNOWN:
  case VRegInfo::NORMAL:
    RegInfo.Kind = VRegInfo::NORMAL;
    if (RegInfo.Explicit && RegInfo.D.RC != RC) {
      const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
      return error(Loc, Twine("conflicting register classes, previously: ") +
                   Twine(TRI.getRegClassName(RegInfo.D.RC)));
    }
    RegInfo.D.RC = RC;
    RegInfo.Explicit = true;
    return false;

  case VRegInfo::GENERIC:
  case VRegInfo::REGBANK:
    return error(Loc, "register class specification on generic register");
  }
  llvm_unreachable("Unexpected register kind")__builtin_unreachable();
}

// Should be a register bank or a generic register.
const RegisterBank *RegBank = nullptr;
if (Name != "_") {
  RegBank = PFS.Target.getRegBank(Name);
  if (!RegBank)
    return error(Loc, "expected '_', register class, or register bank name");
}

lex();

switch (RegInfo.Kind) {
case VRegInfo::UNKNOWN:
case VRegInfo::GENERIC:
case VRegInfo::REGBANK:
  RegInfo.Kind = RegBank ? VRegInfo::REGBANK : VRegInfo::GENERIC;
  if (RegInfo.Explicit && RegInfo.D.RegBank != RegBank)
    return error(Loc, "conflicting generic register banks");
  RegInfo.D.RegBank = RegBank;
  RegInfo.Explicit = true;
  return false;

case VRegInfo::NORMAL:
  return error(Loc, "register bank specification on normal register");
}
llvm_unreachable("Unexpected register kind")__builtin_unreachable();
1530}

1532bool MIParser::parseRegisterFlag(unsigned &Flags) {
const unsigned OldFlags = Flags;
switch (Token.kind()) {
case MIToken::kw_implicit:
  Flags |= RegState::Implicit;
  break;
case MIToken::kw_implicit_define:
  Flags |= RegState::ImplicitDefine;
  break;
case MIToken::kw_def:
  Flags |= RegState::Define;
  break;
case MIToken::kw_dead:
  Flags |= RegState::Dead;
  break;
case MIToken::kw_killed:
  Flags |= RegState::Kill;
  break;
case MIToken::kw_undef:
  Flags |= RegState::Undef;
  break;
case MIToken::kw_internal:
  Flags |= RegState::InternalRead;
  break;
case MIToken::kw_early_clobber:
  Flags |= RegState::EarlyClobber;
  break;
case MIToken::kw_debug_use:
  Flags |= RegState::Debug;
  break;
case MIToken::kw_renamable:
  Flags |= RegState::Renamable;
  break;
default:
  llvm_unreachable("The current token should be a register flag")__builtin_unreachable();
}
if (OldFlags == Flags)
  // We know that the same flag is specified more than once when the flags
  // weren't modified.
  return error("duplicate '" + Token.stringValue() + "' register flag");
lex();
return false;
1574}

1576bool MIParser::parseSubRegisterIndex(unsigned &SubReg) {
assert(Token.is(MIToken::dot))((void)0);
lex();
if (Token.isNot(MIToken::Identifier))
  return error("expected a subregister index after '.'");
auto Name = Token.stringValue();
SubReg = PFS.Target.getSubRegIndex(Name);
if (!SubReg)
  return error(Twine("use of unknown subregister index '") + Name + "'");
lex();
return false;
1587}

1589bool MIParser::parseRegisterTiedDefIndex(unsigned &TiedDefIdx) {
if (!consumeIfPresent(MIToken::kw_tied_def))
  return true;
if (Token.isNot(MIToken::IntegerLiteral))
  return error("expected an integer literal after 'tied-def'");
if (getUnsigned(TiedDefIdx))
  return true;
lex();
if (expectAndConsume(MIToken::rparen))
  return true;
return false;
1600}

1602bool MIParser::assignRegisterTies(MachineInstr &MI,
                                ArrayRef<ParsedMachineOperand> Operands) {
SmallVector<std::pair<unsigned, unsigned>, 4> TiedRegisterPairs;
for (unsigned I = 0, E = Operands.size(); I != E; ++I) {
  if (!Operands[I].TiedDefIdx)
    continue;
  // The parser ensures that this operand is a register use, so we just have
  // to check the tied-def operand.
  unsigned DefIdx = Operands[I].TiedDefIdx.getValue();
  if (DefIdx >= E)
    return error(Operands[I].Begin,
                 Twine("use of invalid tied-def operand index '" +
                       Twine(DefIdx) + "'; instruction has only ") +
                     Twine(E) + " operands");
  const auto &DefOperand = Operands[DefIdx].Operand;
  if (!DefOperand.isReg() || !DefOperand.isDef())
    // FIXME: add note with the def operand.
    return error(Operands[I].Begin,
                 Twine("use of invalid tied-def operand index '") +
                     Twine(DefIdx) + "'; the operand #" + Twine(DefIdx) +
                     " isn't a defined register");
  // Check that the tied-def operand wasn't tied elsewhere.
  for (const auto &TiedPair : TiedRegisterPairs) {
    if (TiedPair.first == DefIdx)
      return error(Operands[I].Begin,
                   Twine("the tied-def operand #") + Twine(DefIdx) +
                       " is already tied with another register operand");
  }
  TiedRegisterPairs.push_back(std::make_pair(DefIdx, I));
}
// FIXME: Verify that for non INLINEASM instructions, the def and use tied
// indices must be less than tied max.
for (const auto &TiedPair : TiedRegisterPairs)
  MI.tieOperands(TiedPair.first, TiedPair.second);
return false;
1637}

1639bool MIParser::parseRegisterOperand(MachineOperand &Dest,
                                  Optional<unsigned> &TiedDefIdx,
                                  bool IsDef) {
unsigned Flags = IsDef ? RegState::Define : 0;
while (Token.isRegisterFlag()) {
  if (parseRegisterFlag(Flags))
    return true;
}
if (!Token.isRegister())
  return error("expected a register after register flags");
Register Reg;
VRegInfo *RegInfo;
if (parseRegister(Reg, RegInfo))
  return true;
lex();
unsigned SubReg = 0;
if (Token.is(MIToken::dot)) {
  if (parseSubRegisterIndex(SubReg))
    return true;
  if (!Register::isVirtualRegister(Reg))
    return error("subregister index expects a virtual register");
}
if (Token.is(MIToken::colon)) {
  if (!Register::isVirtualRegister(Reg))
    return error("register class specification expects a virtual register");
  lex();
  if (parseRegisterClassOrBank(*RegInfo))
      return true;
}
MachineRegisterInfo &MRI = MF.getRegInfo();
if ((Flags & RegState::Define) == 0) {
  if (consumeIfPresent(MIToken::lparen)) {
    unsigned Idx;
    if (!parseRegisterTiedDefIndex(Idx))
      TiedDefIdx = Idx;
    else {
      // Try a redundant low-level type.
      LLT Ty;
      if (parseLowLevelType(Token.location(), Ty))
        return error("expected tied-def or low-level type after '('");

      if (expectAndConsume(MIToken::rparen))
        return true;

      if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
        return error("inconsistent type for generic virtual register");

      MRI.setRegClassOrRegBank(Reg, static_cast<RegisterBank *>(nullptr));
      MRI.setType(Reg, Ty);
    }
  }
} else if (consumeIfPresent(MIToken::lparen)) {
  // Virtual registers may have a tpe with GlobalISel.
  if (!Register::isVirtualRegister(Reg))
    return error("unexpected type on physical register");

  LLT Ty;
  if (parseLowLevelType(Token.location(), Ty))
    return true;

  if (expectAndConsume(MIToken::rparen))
    return true;

  if (MRI.getType(Reg).isValid() && MRI.getType(Reg) != Ty)
    return error("inconsistent type for generic virtual register");

  MRI.setRegClassOrRegBank(Reg, static_cast<RegisterBank *>(nullptr));
  MRI.setType(Reg, Ty);
} else if (Register::isVirtualRegister(Reg)) {
  // Generic virtual registers must have a type.
  // If we end up here this means the type hasn't been specified and
  // this is bad!
  if (RegInfo->Kind == VRegInfo::GENERIC ||
      RegInfo->Kind == VRegInfo::REGBANK)
    return error("generic virtual registers must have a type");
}
Dest = MachineOperand::CreateReg(
    Reg, Flags & RegState::Define, Flags & RegState::Implicit,
    Flags & RegState::Kill, Flags & RegState::Dead, Flags & RegState::Undef,
    Flags & RegState::EarlyClobber, SubReg, Flags & RegState::Debug,
    Flags & RegState::InternalRead, Flags & RegState::Renamable);

return false;
1722}

1724bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::IntegerLiteral))((void)0);
const APSInt &Int = Token.integerValue();
if (Int.getMinSignedBits() > 64)
  return error("integer literal is too large to be an immediate operand");
Dest = MachineOperand::CreateImm(Int.getExtValue());
lex();
return false;
1732}

1734bool MIParser::parseTargetImmMnemonic(const unsigned OpCode,
                                    const unsigned OpIdx,
                                    MachineOperand &Dest,
                                    const MIRFormatter &MF) {
assert(Token.is(MIToken::dot))((void)0);
auto Loc = Token.location(); // record start position
size_t Len = 1;              // for "."
lex();

// Handle the case that mnemonic starts with number.
if (Token.is(MIToken::IntegerLiteral)) {
  Len += Token.range().size();
  lex();
}

StringRef Src;
if (Token.is(MIToken::comma))
  Src = StringRef(Loc, Len);
else {
  assert(Token.is(MIToken::Identifier))((void)0);
  Src = StringRef(Loc, Len + Token.stringValue().size());
}
int64_t Val;
if (MF.parseImmMnemonic(OpCode, OpIdx, Src, Val,
                        [this](StringRef::iterator Loc, const Twine &Msg)
                            -> bool { return error(Loc, Msg); }))
  return true;

Dest = MachineOperand::CreateImm(Val);
if (!Token.is(MIToken::comma))
  lex();
return false;
1766}

1768static bool parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
                          PerFunctionMIParsingState &PFS, const Constant *&C,
                          ErrorCallbackType ErrCB) {
auto Source = StringValue.str(); // The source has to be null terminated.
SMDiagnostic Err;
C = parseConstantValue(Source, Err, *PFS.MF.getFunction().getParent(),
                       &PFS.IRSlots);
if (!C)
  return ErrCB(Loc + Err.getColumnNo(), Err.getMessage());
return false;
1778}

1780bool MIParser::parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
                             const Constant *&C) {
return ::parseIRConstant(
    Loc, StringValue, PFS, C,
    [this](StringRef::iterator Loc, const Twine &Msg) -> bool {
      return error(Loc, Msg);
    });
1787}

1789bool MIParser::parseIRConstant(StringRef::iterator Loc, const Constant *&C) {
if (parseIRConstant(Loc, StringRef(Loc, Token.range().end() - Loc), C))
  return true;
lex();
return false;
1794}

1796// See LLT implemntation for bit size limits.
1797static bool verifyScalarSize(uint64_t Size) {
return Size != 0 && isUInt<16>(Size);
1799}

1801static bool verifyVectorElementCount(uint64_t NumElts) {
return NumElts != 0 && isUInt<16>(NumElts);
1803}

1805static bool verifyAddrSpace(uint64_t AddrSpace) {
return isUInt<24>(AddrSpace);
1807}

1809bool MIParser::parseLowLevelType(StringRef::iterator Loc, LLT &Ty) {
if (Token.range().front() == 's' || Token.range().front() == 'p') {
  StringRef SizeStr = Token.range().drop_front();
  if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
    return error("expected integers after 's'/'p' type character");
}

if (Token.range().front() == 's') {
  auto ScalarSize = APSInt(Token.range().drop_front()).getZExtValue();
  if (!verifyScalarSize(ScalarSize))
    return error("invalid size for scalar type");

  Ty = LLT::scalar(ScalarSize);
  lex();
  return false;
} else if (Token.range().front() == 'p') {
  const DataLayout &DL = MF.getDataLayout();
  uint64_t AS = APSInt(Token.range().drop_front()).getZExtValue();
  if (!verifyAddrSpace(AS))
    return error("invalid address space number");

  Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
  lex();
  return false;
}

// Now we're looking for a vector.
if (Token.isNot(MIToken::less))
  return error(Loc,
               "expected sN, pA, <M x sN>, or <M x pA> for GlobalISel type");
lex();

if (Token.isNot(MIToken::IntegerLiteral))
  return error(Loc, "expected <M x sN> or <M x pA> for vector type");
uint64_t NumElements = Token.integerValue().getZExtValue();
if (!verifyVectorElementCount(NumElements))
  return error("invalid number of vector elements");

lex();

if (Token.isNot(MIToken::Identifier) || Token.stringValue() != "x")
  return error(Loc, "expected <M x sN> or <M x pA> for vector type");
lex();

if (Token.range().front() != 's' && Token.range().front() != 'p')
  return error(Loc, "expected <M x sN> or <M x pA> for vector type");
StringRef SizeStr = Token.range().drop_front();
if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
  return error("expected integers after 's'/'p' type character");

if (Token.range().front() == 's') {
  auto ScalarSize = APSInt(Token.range().drop_front()).getZExtValue();
  if (!verifyScalarSize(ScalarSize))
    return error("invalid size for scalar type");
  Ty = LLT::scalar(ScalarSize);
} else if (Token.range().front() == 'p') {
  const DataLayout &DL = MF.getDataLayout();
  uint64_t AS = APSInt(Token.range().drop_front()).getZExtValue();
  if (!verifyAddrSpace(AS))
    return error("invalid address space number");

  Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
} else
  return error(Loc, "expected <M x sN> or <M x pA> for vector type");
lex();

if (Token.isNot(MIToken::greater))
  return error(Loc, "expected <M x sN> or <M x pA> for vector type");
lex();

Ty = LLT::fixed_vector(NumElements, Ty);
return false;
1881}

1883bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::Identifier))((void)0);
StringRef TypeStr = Token.range();
if (TypeStr.front() != 'i' && TypeStr.front() != 's' &&
    TypeStr.front() != 'p')
  return error(
      "a typed immediate operand should start with one of 'i', 's', or 'p'");
StringRef SizeStr = Token.range().drop_front();
if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
  return error("expected integers after 'i'/'s'/'p' type character");

auto Loc = Token.location();
lex();
if (Token.isNot(MIToken::IntegerLiteral)) {
  if (Token.isNot(MIToken::Identifier) ||
      !(Token.range() == "true" || Token.range() == "false"))
    return error("expected an integer literal");
}
const Constant *C = nullptr;
if (parseIRConstant(Loc, C))
  return true;
Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
return false;
1906}

1908bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
auto Loc = Token.location();
lex();
if (Token.isNot(MIToken::FloatingPointLiteral) &&
    Token.isNot(MIToken::HexLiteral))
  return error("expected a floating point literal");
const Constant *C = nullptr;
if (parseIRConstant(Loc, C))
  return true;
Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
return false;
1919}

1921static bool getHexUint(const MIToken &Token, APInt &Result) {
assert(Token.is(MIToken::HexLiteral))((void)0);
StringRef S = Token.range();
assert(S[0] == '0' && tolower(S[1]) == 'x')((void)0);
// This could be a floating point literal with a special prefix.
if (!isxdigit(S[2]))
  return true;
StringRef V = S.substr(2);
APInt A(V.size()*4, V, 16);

// If A is 0, then A.getActiveBits() is 0. This isn't a valid bitwidth. Make
// sure it isn't the case before constructing result.
unsigned NumBits = (A == 0) ? 32 : A.getActiveBits();
Result = APInt(NumBits, ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
return false;
1936}

1938static bool getUnsigned(const MIToken &Token, unsigned &Result,
                      ErrorCallbackType ErrCB) {
if (Token.hasIntegerValue()) {
  const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
  uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
  if (Val64 == Limit)
    return ErrCB(Token.location(), "expected 32-bit integer (too large)");
  Result = Val64;
  return false;
}
if (Token.is(MIToken::HexLiteral)) {
  APInt A;
  if (getHexUint(Token, A))
    return true;
  if (A.getBitWidth() > 32)
    return ErrCB(Token.location(), "expected 32-bit integer (too large)");
  Result = A.getZExtValue();
  return false;
}
return true;
1958}

1960bool MIParser::getUnsigned(unsigned &Result) {
return ::getUnsigned(
    Token, Result, [this](StringRef::iterator Loc, const Twine &Msg) -> bool {
      return error(Loc, Msg);
    });
1965}

1967bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
assert(Token.is(MIToken::MachineBasicBlock) ||((void)0)
       Token.is(MIToken::MachineBasicBlockLabel))((void)0);
unsigned Number;
if (getUnsigned(Number))
  return true;
auto MBBInfo = PFS.MBBSlots.find(Number);
if (MBBInfo == PFS.MBBSlots.end())
  return error(Twine("use of undefined machine basic block #") +
               Twine(Number));
MBB = MBBInfo->second;
// TODO: Only parse the name if it's a MachineBasicBlockLabel. Deprecate once
// we drop the <irname> from the bb.<id>.<irname> format.
if (!Token.stringValue().empty() && Token.stringValue() != MBB->getName())
  return error(Twine("the name of machine basic block #") + Twine(Number) +
               " isn't '" + Token.stringValue() + "'");
return false;
1984}

1986bool MIParser::parseMBBOperand(MachineOperand &Dest) {
MachineBasicBlock *MBB;
if (parseMBBReference(MBB))
  return true;
Dest = MachineOperand::CreateMBB(MBB);
lex();
return false;
1993}

1995bool MIParser::parseStackFrameIndex(int &FI) {
assert(Token.is(MIToken::StackObject))((void)0);
unsigned ID;
if (getUnsigned(ID))
  return true;
auto ObjectInfo = PFS.StackObjectSlots.find(ID);
if (ObjectInfo == PFS.StackObjectSlots.end())
  return error(Twine("use of undefined stack object '%stack.") + Twine(ID) +
               "'");
StringRef Name;
if (const auto *Alloca =
        MF.getFrameInfo().getObjectAllocation(ObjectInfo->second))
  Name = Alloca->getName();
if (!Token.stringValue().empty() && Token.stringValue() != Name)
  return error(Twine("the name of the stack object '%stack.") + Twine(ID) +
               "' isn't '" + Token.stringValue() + "'");
lex();
FI = ObjectInfo->second;
return false;
2014}

2016bool MIParser::parseStackObjectOperand(MachineOperand &Dest) {
int FI;
if (parseStackFrameIndex(FI))
  return true;
Dest = MachineOperand::CreateFI(FI);
return false;
2022}

2024bool MIParser::parseFixedStackFrameIndex(int &FI) {
assert(Token.is(MIToken::FixedStackObject))((void)0);
unsigned ID;
if (getUnsigned(ID))
  return true;
auto ObjectInfo = PFS.FixedStackObjectSlots.find(ID);
if (ObjectInfo == PFS.FixedStackObjectSlots.end())
  return error(Twine("use of undefined fixed stack object '%fixed-stack.") +
               Twine(ID) + "'");
lex();
FI = ObjectInfo->second;
return false;
2036}

2038bool MIParser::parseFixedStackObjectOperand(MachineOperand &Dest) {
int FI;
if (parseFixedStackFrameIndex(FI))
  return true;
Dest = MachineOperand::CreateFI(FI);
return false;
2044}

2046static bool parseGlobalValue(const MIToken &Token,
                           PerFunctionMIParsingState &PFS, GlobalValue *&GV,
                           ErrorCallbackType ErrCB) {
switch (Token.kind()) {
case MIToken::NamedGlobalValue: {
  const Module *M = PFS.MF.getFunction().getParent();
  GV = M->getNamedValue(Token.stringValue());
  if (!GV)
    return ErrCB(Token.location(), Twine("use of undefined global value '") +
                                       Token.range() + "'");
  break;
}
case MIToken::GlobalValue: {
  unsigned GVIdx;
  if (getUnsigned(Token, GVIdx, ErrCB))
    return true;
  if (GVIdx >= PFS.IRSlots.GlobalValues.size())
    return ErrCB(Token.location(), Twine("use of undefined global value '@") +
                                       Twine(GVIdx) + "'");
  GV = PFS.IRSlots.GlobalValues[GVIdx];
  break;
}
default:
  llvm_unreachable("The current token should be a global value")__builtin_unreachable();
}
return false;
2072}

2074bool MIParser::parseGlobalValue(GlobalValue *&GV) {
return ::parseGlobalValue(
    Token, PFS, GV,
    [this](StringRef::iterator Loc, const Twine &Msg) -> bool {
      return error(Loc, Msg);
    });
2080}

2082bool MIParser::parseGlobalAddressOperand(MachineOperand &Dest) {
GlobalValue *GV = nullptr;
if (parseGlobalValue(GV))
  return true;
lex();
Dest = MachineOperand::CreateGA(GV, /*Offset=*/0);
if (parseOperandsOffset(Dest))
  return true;
return false;
2091}

2093bool MIParser::parseConstantPoolIndexOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::ConstantPoolItem))((void)0);
unsigned ID;
if (getUnsigned(ID))
  return true;
auto ConstantInfo = PFS.ConstantPoolSlots.find(ID);
if (ConstantInfo == PFS.ConstantPoolSlots.end())
  return error("use of undefined constant '%const." + Twine(ID) + "'");
lex();
Dest = MachineOperand::CreateCPI(ID, /*Offset=*/0);
if (parseOperandsOffset(Dest))
  return true;
return false;
2106}

2108bool MIParser::parseJumpTableIndexOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::JumpTableIndex))((void)0);
unsigned ID;
if (getUnsigned(ID))
  return true;
auto JumpTableEntryInfo = PFS.JumpTableSlots.find(ID);
if (JumpTableEntryInfo == PFS.JumpTableSlots.end())
  return error("use of undefined jump table '%jump-table." + Twine(ID) + "'");
lex();
Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
return false;
2119}

2121bool MIParser::parseExternalSymbolOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::ExternalSymbol))((void)0);
const char *Symbol = MF.createExternalSymbolName(Token.stringValue());
lex();
Dest = MachineOperand::CreateES(Symbol);
if (parseOperandsOffset(Dest))
  return true;
return false;
2129}

2131bool MIParser::parseMCSymbolOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::MCSymbol))((void)0);
MCSymbol *Symbol = getOrCreateMCSymbol(Token.stringValue());
lex();
Dest = MachineOperand::CreateMCSymbol(Symbol);
if (parseOperandsOffset(Dest))
  return true;
return false;
2139}

2141bool MIParser::parseSubRegisterIndexOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::SubRegisterIndex))((void)0);
StringRef Name = Token.stringValue();
unsigned SubRegIndex = PFS.Target.getSubRegIndex(Token.stringValue());
if (SubRegIndex == 0)
  return error(Twine("unknown subregister index '") + Name + "'");
lex();
Dest = MachineOperand::CreateImm(SubRegIndex);
return false;
2150}

2152bool MIParser::parseMDNode(MDNode *&Node) {
assert(Token.is(MIToken::exclaim))((void)0);

auto Loc = Token.location();
lex();
if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
  return error("expected metadata id after '!'");
unsigned ID;
if (getUnsigned(ID))
  return true;
auto NodeInfo = PFS.IRSlots.MetadataNodes.find(ID);
if (NodeInfo == PFS.IRSlots.MetadataNodes.end()) {
  NodeInfo = PFS.MachineMetadataNodes.find(ID);
  if (NodeInfo == PFS.MachineMetadataNodes.end())
    return error(Loc, "use of undefined metadata '!" + Twine(ID) + "'");
}
lex();
Node = NodeInfo->second.get();
return false;
2171}

2173bool MIParser::parseDIExpression(MDNode *&Expr) {
assert(Token.is(MIToken::md_diexpr))((void)0);
lex();

// FIXME: Share this parsing with the IL parser.
SmallVector<uint64_t, 8> Elements;

if (expectAndConsume(MIToken::lparen))
  return true;

if (Token.isNot(MIToken::rparen)) {
  do {
    if (Token.is(MIToken::Identifier)) {
      if (unsigned Op = dwarf::getOperationEncoding(Token.stringValue())) {
        lex();
        Elements.push_back(Op);
        continue;
      }
      if (unsigned Enc = dwarf::getAttributeEncoding(Token.stringValue())) {
        lex();
        Elements.push_back(Enc);
        continue;
      }
      return error(Twine("invalid DWARF op '") + Token.stringValue() + "'");
    }

    if (Token.isNot(MIToken::IntegerLiteral) ||
        Token.integerValue().isSigned())
      return error("expected unsigned integer");

    auto &U = Token.integerValue();
    if (U.ugt(UINT64_MAX0xffffffffffffffffULL))
      return error("element too large, limit is " + Twine(UINT64_MAX0xffffffffffffffffULL));
    Elements.push_back(U.getZExtValue());
    lex();

  } while (consumeIfPresent(MIToken::comma));
}

if (expectAndConsume(MIToken::rparen))
  return true;

Expr = DIExpression::get(MF.getFunction().getContext(), Elements);
return false;
2217}

2219bool MIParser::parseDILocation(MDNode *&Loc) {
assert(Token.is(MIToken::md_dilocation))((void)0);
lex();

bool HaveLine = false;
unsigned Line = 0;
unsigned Column = 0;
MDNode *Scope = nullptr;
MDNode *InlinedAt = nullptr;
bool ImplicitCode = false;

if (expectAndConsume(MIToken::lparen))
  return true;

if (Token.isNot(MIToken::rparen)) {
  do {
    if (Token.is(MIToken::Identifier)) {
      if (Token.stringValue() == "line") {
        lex();
        if (expectAndConsume(MIToken::colon))
          return true;
        if (Token.isNot(MIToken::IntegerLiteral) ||
            Token.integerValue().isSigned())
          return error("expected unsigned integer");
        Line = Token.integerValue().getZExtValue();
        HaveLine = true;
        lex();
        continue;
      }
      if (Token.stringValue() == "column") {
        lex();
        if (expectAndConsume(MIToken::colon))
          return true;
        if (Token.isNot(MIToken::IntegerLiteral) ||
            Token.integerValue().isSigned())
          return error("expected unsigned integer");
        Column = Token.integerValue().getZExtValue();
        lex();
        continue;
      }
      if (Token.stringValue() == "scope") {
        lex();
        if (expectAndConsume(MIToken::colon))
          return true;
        if (parseMDNode(Scope))
          return error("expected metadata node");
        if (!isa<DIScope>(Scope))
          return error("expected DIScope node");
        continue;
      }
      if (Token.stringValue() == "inlinedAt") {
        lex();
        if (expectAndConsume(MIToken::colon))
          return true;
        if (Token.is(MIToken::exclaim)) {
          if (parseMDNode(InlinedAt))
            return true;
        } else if (Token.is(MIToken::md_dilocation)) {
          if (parseDILocation(InlinedAt))
            return true;
        } else
          return error("expected metadata node");
        if (!isa<DILocation>(InlinedAt))
          return error("expected DILocation node");
        continue;
      }
      if (Token.stringValue() == "isImplicitCode") {
        lex();
        if (expectAndConsume(MIToken::colon))
          return true;
        if (!Token.is(MIToken::Identifier))
          return error("expected true/false");
        // As far as I can see, we don't have any existing need for parsing
        // true/false in MIR yet. Do it ad-hoc until there's something else
        // that needs it.
        if (Token.stringValue() == "true")
          ImplicitCode = true;
        else if (Token.stringValue() == "false")
          ImplicitCode = false;
        else
          return error("expected true/false");
        lex();
        continue;
      }
    }
    return error(Twine("invalid DILocation argument '") +
                 Token.stringValue() + "'");
  } while (consumeIfPresent(MIToken::comma));
}

if (expectAndConsume(MIToken::rparen))
  return true;

if (!HaveLine)
  return error("DILocation requires line number");
if (!Scope)
  return error("DILocation requires a scope");

Loc = DILocation::get(MF.getFunction().getContext(), Line, Column, Scope,
                      InlinedAt, ImplicitCode);
return false;
2320}

2322bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
MDNode *Node = nullptr;
if (Token.is(MIToken::exclaim)) {
  if (parseMDNode(Node))
    return true;
} else if (Token.is(MIToken::md_diexpr)) {
  if (parseDIExpression(Node))
    return true;
}
Dest = MachineOperand::CreateMetadata(Node);
return false;
2333}

2335bool MIParser::parseCFIOffset(int &Offset) {
if (Token.isNot(MIToken::IntegerLiteral))
  return error("expected a cfi offset");
if (Token.integerValue().getMinSignedBits() > 32)
  return error("expected a 32 bit integer (the cfi offset is too large)");
Offset = (int)Token.integerValue().getExtValue();
lex();
return false;
2343}

2345bool MIParser::parseCFIRegister(Register &Reg) {
if (Token.isNot(MIToken::NamedRegister))
  return error("expected a cfi register");
Register LLVMReg;
if (parseNamedRegister(LLVMReg))
  return true;
const auto *TRI = MF.getSubtarget().getRegisterInfo();
assert(TRI && "Expected target register info")((void)0);
int DwarfReg = TRI->getDwarfRegNum(LLVMReg, true);
if (DwarfReg < 0)
  return error("invalid DWARF register");
Reg = (unsigned)DwarfReg;
lex();
return false;
2359}

2361bool MIParser::parseCFIAddressSpace(unsigned &AddressSpace) {
if (Token.isNot(MIToken::IntegerLiteral))
  return error("expected a cfi address space literal");
if (Token.integerValue().isSigned())
  return error("expected an unsigned integer (cfi address space)");
AddressSpace = Token.integerValue().getZExtValue();
lex();
return false;
2369}

2371bool MIParser::parseCFIEscapeValues(std::string &Values) {
do {
  if (Token.isNot(MIToken::HexLiteral))
    return error("expected a hexadecimal literal");
  unsigned Value;
  if (getUnsigned(Value))
    return true;
  if (Value > UINT8_MAX0xff)
    return error("expected a 8-bit integer (too large)");
  Values.push_back(static_cast<uint8_t>(Value));
  lex();
} while (consumeIfPresent(MIToken::comma));
return false;
2384}

2386bool MIParser::parseCFIOperand(MachineOperand &Dest) {
auto Kind = Token.kind();
lex();
int Offset;
Register Reg;
unsigned AddressSpace;
unsigned CFIIndex;
switch (Kind) {
case MIToken::kw_cfi_same_value:
  if (parseCFIRegister(Reg))
    return true;
  CFIIndex = MF.addFrameInst(MCCFIInstruction::createSameValue(nullptr, Reg));
  break;
case MIToken::kw_cfi_offset:
  if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
      parseCFIOffset(Offset))
    return true;
  CFIIndex =
      MF.addFrameInst(MCCFIInstruction::createOffset(nullptr, Reg, Offset));
  break;
case MIToken::kw_cfi_rel_offset:
  if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
      parseCFIOffset(Offset))
    return true;
  CFIIndex = MF.addFrameInst(
      MCCFIInstruction::createRelOffset(nullptr, Reg, Offset));
  break;
case MIToken::kw_cfi_def_cfa_register:
  if (parseCFIRegister(Reg))
    return true;
  CFIIndex =
      MF.addFrameInst(MCCFIInstruction::createDefCfaRegister(nullptr, Reg));
  break;
case MIToken::kw_cfi_def_cfa_offset:
  if (parseCFIOffset(Offset))
    return true;
  CFIIndex =
      MF.addFrameInst(MCCFIInstruction::cfiDefCfaOffset(nullptr, Offset));
  break;
case MIToken::kw_cfi_adjust_cfa_offset:
  if (parseCFIOffset(Offset))
    return true;
  CFIIndex = MF.addFrameInst(
      MCCFIInstruction::createAdjustCfaOffset(nullptr, Offset));
  break;
case MIToken::kw_cfi_def_cfa:
  if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
      parseCFIOffset(Offset))
    return true;
  CFIIndex =
      MF.addFrameInst(MCCFIInstruction::cfiDefCfa(nullptr, Reg, Offset));
  break;
case MIToken::kw_cfi_llvm_def_aspace_cfa:
  if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
      parseCFIOffset(Offset) || expectAndConsume(MIToken::comma) ||
      parseCFIAddressSpace(AddressSpace))
    return true;
  CFIIndex = MF.addFrameInst(MCCFIInstruction::createLLVMDefAspaceCfa(
      nullptr, Reg, Offset, AddressSpace));
  break;
case MIToken::kw_cfi_remember_state:
  CFIIndex = MF.addFrameInst(MCCFIInstruction::createRememberState(nullptr));
  break;
case MIToken::kw_cfi_restore:
  if (parseCFIRegister(Reg))
    return true;
  CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestore(nullptr, Reg));
  break;
case MIToken::kw_cfi_restore_state:
  CFIIndex = MF.addFrameInst(MCCFIInstruction::createRestoreState(nullptr));
  break;
case MIToken::kw_cfi_undefined:
  if (parseCFIRegister(Reg))
    return true;
  CFIIndex = MF.addFrameInst(MCCFIInstruction::createUndefined(nullptr, Reg));
  break;
case MIToken::kw_cfi_register: {
  Register Reg2;
  if (parseCFIRegister(Reg) || expectAndConsume(MIToken::comma) ||
      parseCFIRegister(Reg2))
    return true;

  CFIIndex =
      MF.addFrameInst(MCCFIInstruction::createRegister(nullptr, Reg, Reg2));
  break;
}
case MIToken::kw_cfi_window_save:
  CFIIndex = MF.addFrameInst(MCCFIInstruction::createWindowSave(nullptr));
  break;
case MIToken::kw_cfi_aarch64_negate_ra_sign_state:
  CFIIndex = MF.addFrameInst(MCCFIInstruction::createNegateRAState(nullptr));
  break;
case MIToken::kw_cfi_escape: {
  std::string Values;
  if (parseCFIEscapeValues(Values))
    return true;
  CFIIndex = MF.addFrameInst(MCCFIInstruction::createEscape(nullptr, Values));
  break;
}
default:
  // TODO: Parse the other CFI operands.
  llvm_unreachable("The current token should be a cfi operand")__builtin_unreachable();
}
Dest = MachineOperand::CreateCFIIndex(CFIIndex);
return false;
2491}

2493bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
switch (Token.kind()) {
case MIToken::NamedIRBlock: {
  BB = dyn_cast_or_null<BasicBlock>(
      F.getValueSymbolTable()->lookup(Token.stringValue()));
  if (!BB)
    return error(Twine("use of undefined IR block '") + Token.range() + "'");
  break;
}
case MIToken::IRBlock: {
  unsigned SlotNumber = 0;
  if (getUnsigned(SlotNumber))
    return true;
  BB = const_cast<BasicBlock *>(getIRBlock(SlotNumber, F));
  if (!BB)
    return error(Twine("use of undefined IR block '%ir-block.") +
                 Twine(SlotNumber) + "'");
  break;
}
default:
  llvm_unreachable("The current token should be an IR block reference")__builtin_unreachable();
}
return false;
2516}

2518bool MIParser::parseBlockAddressOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::kw_blockaddress))((void)0);
lex();
if (expectAndConsume(MIToken::lparen))
  return true;
if (Token.isNot(MIToken::GlobalValue) &&
    Token.isNot(MIToken::NamedGlobalValue))
  return error("expected a global value");
GlobalValue *GV = nullptr;
if (parseGlobalValue(GV))
  return true;
auto *F = dyn_cast<Function>(GV);
if (!F)
  return error("expected an IR function reference");
lex();
if (expectAndConsume(MIToken::comma))
  return true;
BasicBlock *BB = nullptr;
if (Token.isNot(MIToken::IRBlock) && Token.isNot(MIToken::NamedIRBlock))
  return error("expected an IR block reference");
if (parseIRBlock(BB, *F))
  return true;
lex();
if (expectAndConsume(MIToken::rparen))
  return true;
Dest = MachineOperand::CreateBA(BlockAddress::get(F, BB), /*Offset=*/0);
if (parseOperandsOffset(Dest))
  return true;
return false;
2547}

2549bool MIParser::parseIntrinsicOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::kw_intrinsic))((void)0);
lex();
if (expectAndConsume(MIToken::lparen))
  return error("expected syntax intrinsic(@llvm.whatever)");

if (Token.isNot(MIToken::NamedGlobalValue))
  return error("expected syntax intrinsic(@llvm.whatever)");

std::string Name = std::string(Token.stringValue());
lex();

if (expectAndConsume(MIToken::rparen))
  return error("expected ')' to terminate intrinsic name");

// Find out what intrinsic we're dealing with, first try the global namespace
// and then the target's private intrinsics if that fails.
const TargetIntrinsicInfo *TII = MF.getTarget().getIntrinsicInfo();
Intrinsic::ID ID = Function::lookupIntrinsicID(Name);
if (ID == Intrinsic::not_intrinsic && TII)
  ID = static_cast<Intrinsic::ID>(TII->lookupName(Name));

if (ID == Intrinsic::not_intrinsic)
  return error("unknown intrinsic name");
Dest = MachineOperand::CreateIntrinsicID(ID);

return false;
2576}

2578bool MIParser::parsePredicateOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred))((void)0);
bool IsFloat = Token.is(MIToken::kw_floatpred);
lex();

if (expectAndConsume(MIToken::lparen))
  return error("expected syntax intpred(whatever) or floatpred(whatever");

if (Token.isNot(MIToken::Identifier))
  return error("whatever");

CmpInst::Predicate Pred;
if (IsFloat) {
  Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
             .Case("false", CmpInst::FCMP_FALSE)
             .Case("oeq", CmpInst::FCMP_OEQ)
             .Case("ogt", CmpInst::FCMP_OGT)
             .Case("oge", CmpInst::FCMP_OGE)
             .Case("olt", CmpInst::FCMP_OLT)
             .Case("ole", CmpInst::FCMP_OLE)
             .Case("one", CmpInst::FCMP_ONE)
             .Case("ord", CmpInst::FCMP_ORD)
             .Case("uno", CmpInst::FCMP_UNO)
             .Case("ueq", CmpInst::FCMP_UEQ)
             .Case("ugt", CmpInst::FCMP_UGT)
             .Case("uge", CmpInst::FCMP_UGE)
             .Case("ult", CmpInst::FCMP_ULT)
             .Case("ule", CmpInst::FCMP_ULE)
             .Case("une", CmpInst::FCMP_UNE)
             .Case("true", CmpInst::FCMP_TRUE)
             .Default(CmpInst::BAD_FCMP_PREDICATE);
  if (!CmpInst::isFPPredicate(Pred))
    return error("invalid floating-point predicate");
} else {
  Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
             .Case("eq", CmpInst::ICMP_EQ)
             .Case("ne", CmpInst::ICMP_NE)
             .Case("sgt", CmpInst::ICMP_SGT)
             .Case("sge", CmpInst::ICMP_SGE)
             .Case("slt", CmpInst::ICMP_SLT)
             .Case("sle", CmpInst::ICMP_SLE)
             .Case("ugt", CmpInst::ICMP_UGT)
             .Case("uge", CmpInst::ICMP_UGE)
             .Case("ult", CmpInst::ICMP_ULT)
             .Case("ule", CmpInst::ICMP_ULE)
             .Default(CmpInst::BAD_ICMP_PREDICATE);
  if (!CmpInst::isIntPredicate(Pred))
    return error("invalid integer predicate");
}

lex();
Dest = MachineOperand::CreatePredicate(Pred);
if (expectAndConsume(MIToken::rparen))
  return error("predicate should be terminated by ')'.");

return false;
2634}

2636bool MIParser::parseShuffleMaskOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::kw_shufflemask))((void)0);

lex();
if (expectAndConsume(MIToken::lparen))
  return error("expected syntax shufflemask(<integer or undef>, ...)");

SmallVector<int, 32> ShufMask;
do {
  if (Token.is(MIToken::kw_undef)) {
    ShufMask.push_back(-1);
  } else if (Token.is(MIToken::IntegerLiteral)) {
    const APSInt &Int = Token.integerValue();
    ShufMask.push_back(Int.getExtValue());
  } else
    return error("expected integer constant");

  lex();
} while (consumeIfPresent(MIToken::comma));

if (expectAndConsume(MIToken::rparen))
  return error("shufflemask should be terminated by ')'.");

ArrayRef<int> MaskAlloc = MF.allocateShuffleMask(ShufMask);
Dest = MachineOperand::CreateShuffleMask(MaskAlloc);
return false;
2662}

2664bool MIParser::parseTargetIndexOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::kw_target_index))((void)0);
lex();
if (expectAndConsume(MIToken::lparen))
  return true;
if (Token.isNot(MIToken::Identifier))
  return error("expected the name of the target index");
int Index = 0;
if (PFS.Target.getTargetIndex(Token.stringValue(), Index))
  return error("use of undefined target index '" + Token.stringValue() + "'");
lex();
if (expectAndConsume(MIToken::rparen))
  return true;
Dest = MachineOperand::CreateTargetIndex(unsigned(Index), /*Offset=*/0);
if (parseOperandsOffset(Dest))
  return true;
return false;
2681}

2683bool MIParser::parseCustomRegisterMaskOperand(MachineOperand &Dest) {
assert(Token.stringValue() == "CustomRegMask" && "Expected a custom RegMask")((void)0);
lex();
if (expectAndConsume(MIToken::lparen))
  return true;

uint32_t *Mask = MF.allocateRegMask();
while (true) {
  if (Token.isNot(MIToken::NamedRegister))
    return error("expected a named register");
  Register Reg;
  if (parseNamedRegister(Reg))
    return true;
  lex();
  Mask[Reg / 32] |= 1U << (Reg % 32);
  // TODO: Report an error if the same register is used more than once.
  if (Token.isNot(MIToken::comma))
    break;
  lex();
}

if (expectAndConsume(MIToken::rparen))
  return true;
Dest = MachineOperand::CreateRegMask(Mask);
return false;
2708}

2710bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
assert(Token.is(MIToken::kw_liveout))((void)0);
uint32_t *Mask = MF.allocateRegMask();
lex();
if (expectAndConsume(MIToken::lparen))
  return true;
while (true) {
  if (Token.isNot(MIToken::NamedRegister))
    return error("expected a named register");
  Register Reg;
  if (parseNamedRegister(Reg))
    return true;
  lex();
  Mask[Reg / 32] |= 1U << (Reg % 32);
  // TODO: Report an error if the same register is used more than once.
  if (Token.isNot(MIToken::comma))
    break;
  lex();
}
if (expectAndConsume(MIToken::rparen))
  return true;
Dest = MachineOperand::CreateRegLiveOut(Mask);
return false;
2733}

2735bool MIParser::parseMachineOperand(const unsigned OpCode, const unsigned OpIdx,
                                 MachineOperand &Dest,
                                 Optional<unsigned> &TiedDefIdx) {
switch (Token.kind()) {
case MIToken::kw_implicit:
case MIToken::kw_implicit_define:
case MIToken::kw_def:
case MIToken::kw_dead:
case MIToken::kw_killed:
case MIToken::kw_undef:
case MIToken::kw_internal:
case MIToken::kw_early_clobber:
case MIToken::kw_debug_use:
case MIToken::kw_renamable:
case MIToken::underscore:
case MIToken::NamedRegister:
case MIToken::VirtualRegister:
case MIToken::NamedVirtualRegister:
  return parseRegisterOperand(Dest, TiedDefIdx);
case MIToken::IntegerLiteral:
  return parseImmediateOperand(Dest);
case MIToken::kw_half:
case MIToken::kw_float:
case MIToken::kw_double:
case MIToken::kw_x86_fp80:
case MIToken::kw_fp128:
case MIToken::kw_ppc_fp128:
  return parseFPImmediateOperand(Dest);
case MIToken::MachineBasicBlock:
  return parseMBBOperand(Dest);
case MIToken::StackObject:
  return parseStackObjectOperand(Dest);
case MIToken::FixedStackObject:
  return parseFixedStackObjectOperand(Dest);
case MIToken::GlobalValue:
case MIToken::NamedGlobalValue:
  return parseGlobalAddressOperand(Dest);
case MIToken::ConstantPoolItem:
  return parseConstantPoolIndexOperand(Dest);
case MIToken::JumpTableIndex:
  return parseJumpTableIndexOperand(Dest);
case MIToken::ExternalSymbol:
  return parseExternalSymbolOperand(Dest);
case MIToken::MCSymbol:
  return parseMCSymbolOperand(Dest);
case MIToken::SubRegisterIndex:
  return parseSubRegisterIndexOperand(Dest);
case MIToken::md_diexpr:
case MIToken::exclaim:
  return parseMetadataOperand(Dest);
case MIToken::kw_cfi_same_value:
case MIToken::kw_cfi_offset:
case MIToken::kw_cfi_rel_offset:
case MIToken::kw_cfi_def_cfa_register:
case MIToken::kw_cfi_def_cfa_offset:
case MIToken::kw_cfi_adjust_cfa_offset:
case MIToken::kw_cfi_escape:
case MIToken::kw_cfi_def_cfa:
case MIToken::kw_cfi_llvm_def_aspace_cfa:
case MIToken::kw_cfi_register:
case MIToken::kw_cfi_remember_state:
case MIToken::kw_cfi_restore:
case MIToken::kw_cfi_restore_state:
case MIToken::kw_cfi_undefined:
case MIToken::kw_cfi_window_save:
case MIToken::kw_cfi_aarch64_negate_ra_sign_state:
  return parseCFIOperand(Dest);
case MIToken::kw_blockaddress:
  return parseBlockAddressOperand(Dest);
case MIToken::kw_intrinsic:
  return parseIntrinsicOperand(Dest);
case MIToken::kw_target_index:
  return parseTargetIndexOperand(Dest);
case MIToken::kw_liveout:
  return parseLiveoutRegisterMaskOperand(Dest);
case MIToken::kw_floatpred:
case MIToken::kw_intpred:
  return parsePredicateOperand(Dest);
case MIToken::kw_shufflemask:
  return parseShuffleMaskOperand(Dest);
case MIToken::Error:
  return true;
case MIToken::Identifier:
  if (const auto *RegMask = PFS.Target.getRegMask(Token.stringValue())) {
    Dest = MachineOperand::CreateRegMask(RegMask);
    lex();
    break;
  } else if (Token.stringValue() == "CustomRegMask") {
    return parseCustomRegisterMaskOperand(Dest);
  } else
    return parseTypedImmediateOperand(Dest);
case MIToken::dot: {
  const auto *TII = MF.getSubtarget().getInstrInfo();
  if (const auto *Formatter = TII->getMIRFormatter()) {
    return parseTargetImmMnemonic(OpCode, OpIdx, Dest, *Formatter);
  }
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
}
default:
  // FIXME: Parse the MCSymbol machine operand.
  return error("expected a machine operand");
}
return false;
2838}

2840bool MIParser::parseMachineOperandAndTargetFlags(
  const unsigned OpCode, const unsigned OpIdx, MachineOperand &Dest,
  Optional<unsigned> &TiedDefIdx) {
unsigned TF = 0;
bool HasTargetFlags = false;
if (Token.is(MIToken::kw_target_flags)) {
  HasTargetFlags = true;
  lex();
  if (expectAndConsume(MIToken::lparen))
    return true;
  if (Token.isNot(MIToken::Identifier))
    return error("expected the name of the target flag");
  if (PFS.Target.getDirectTargetFlag(Token.stringValue(), TF)) {
    if (PFS.Target.getBitmaskTargetFlag(Token.stringValue(), TF))
      return error("use of undefined target flag '" + Token.stringValue() +
                   "'");
  }
  lex();
  while (Token.is(MIToken::comma)) {
    lex();
    if (Token.isNot(MIToken::Identifier))
      return error("expected the name of the target flag");
    unsigned BitFlag = 0;
    if (PFS.Target.getBitmaskTargetFlag(Token.stringValue(), BitFlag))
      return error("use of undefined target flag '" + Token.stringValue() +
                   "'");
    // TODO: Report an error when using a duplicate bit target flag.
    TF |= BitFlag;
    lex();
  }
  if (expectAndConsume(MIToken::rparen))
    return true;
}
auto Loc = Token.location();
if (parseMachineOperand(OpCode, OpIdx, Dest, TiedDefIdx))
  return true;
if (!HasTargetFlags)
  return false;
if (Dest.isReg())
  return error(Loc, "register operands can't have target flags");
Dest.setTargetFlags(TF);
return false;
2882}

2884bool MIParser::parseOffset(int64_t &Offset) {
if (Token.isNot(MIToken::plus) && Token.isNot(MIToken::minus))
  return false;
StringRef Sign = Token.range();
bool IsNegative = Token.is(MIToken::minus);
lex();
if (Token.isNot(MIToken::IntegerLiteral))
  return error("expected an integer literal after '" + Sign + "'");
if (Token.integerValue().getMinSignedBits() > 64)
  return error("expected 64-bit integer (too large)");
Offset = Token.integerValue().getExtValue();
if (IsNegative)
  Offset = -Offset;
lex();
return false;
2899}

2901bool MIParser::parseAlignment(unsigned &Alignment) {
assert(Token.is(MIToken::kw_align) || Token.is(MIToken::kw_basealign))((void)0);
lex();
if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
  return error("expected an integer literal after 'align'");
if (getUnsigned(Alignment))
  return true;
lex();

if (!isPowerOf2_32(Alignment))
  return error("expected a power-of-2 literal after 'align'");

return false;
2914}

2916bool MIParser::parseAddrspace(unsigned &Addrspace) {
assert(Token.is(MIToken::kw_addrspace))((void)0);
lex();
if (Token.isNot(MIToken::IntegerLiteral) || Token.integerValue().isSigned())
  return error("expected an integer literal after 'addrspace'");
if (getUnsigned(Addrspace))
  return true;
lex();
return false;
2925}

2927bool MIParser::parseOperandsOffset(MachineOperand &Op) {
int64_t Offset = 0;
if (parseOffset(Offset))
  return true;
Op.setOffset(Offset);
return false;
2933}

2935static bool parseIRValue(const MIToken &Token, PerFunctionMIParsingState &PFS,
                       const Value *&V, ErrorCallbackType ErrCB) {
switch (Token.kind()) {
case MIToken::NamedIRValue: {
  V = PFS.MF.getFunction().getValueSymbolTable()->lookup(Token.stringValue());
  break;
}
case MIToken::IRValue: {
  unsigned SlotNumber = 0;
  if (getUnsigned(Token, SlotNumber, ErrCB))
    return true;
  V = PFS.getIRValue(SlotNumber);
  break;
}
case MIToken::NamedGlobalValue:
case MIToken::GlobalValue: {
  GlobalValue *GV = nullptr;
  if (parseGlobalValue(Token, PFS, GV, ErrCB))
    return true;
  V = GV;
  break;
}
case MIToken::QuotedIRValue: {
  const Constant *C = nullptr;
  if (parseIRConstant(Token.location(), Token.stringValue(), PFS, C, ErrCB))
    return true;
  V = C;
  break;
}
case MIToken::kw_unknown_address:
  V = nullptr;
  return false;
default:
  llvm_unreachable("The current token should be an IR block reference")__builtin_unreachable();
}
if (!V)
  return ErrCB(Token.location(), Twine("use of undefined IR value '") + Token.range() + "'");
return false;
2973}

2975bool MIParser::parseIRValue(const Value *&V) {
return ::parseIRValue(
    Token, PFS, V, [this](StringRef::iterator Loc, const Twine &Msg) -> bool {
      return error(Loc, Msg);
    });
2980}

2982bool MIParser::getUint64(uint64_t &Result) {
if (Token.hasIntegerValue()) {
  if (Token.integerValue().getActiveBits() > 64)
    return error("expected 64-bit integer (too large)");
  Result = Token.integerValue().getZExtValue();
  return false;
}
if (Token.is(MIToken::HexLiteral)) {
  APInt A;
  if (getHexUint(A))
    return true;
  if (A.getBitWidth() > 64)
    return error("expected 64-bit integer (too large)");
  Result = A.getZExtValue();
  return false;
}
return true;
2999}

3001bool MIParser::getHexUint(APInt &Result) {
return ::getHexUint(Token, Result);
3003}

3005bool MIParser::parseMemoryOperandFlag(MachineMemOperand::Flags &Flags) {
const auto OldFlags = Flags;
switch (Token.kind()) {
case MIToken::kw_volatile:
  Flags |= MachineMemOperand::MOVolatile;
  break;
case MIToken::kw_non_temporal:
  Flags |= MachineMemOperand::MONonTemporal;
  break;
case MIToken::kw_dereferenceable:
  Flags |= MachineMemOperand::MODereferenceable;
  break;
case MIToken::kw_invariant:
  Flags |= MachineMemOperand::MOInvariant;
  break;
case MIToken::StringConstant: {
  MachineMemOperand::Flags TF;
  if (PFS.Target.getMMOTargetFlag(Token.stringValue(), TF))
    return error("use of undefined target MMO flag '" + Token.stringValue() +
                 "'");
  Flags |= TF;
  break;
}
default:
  llvm_unreachable("The current token should be a memory operand flag")__builtin_unreachable();
}
if (OldFlags == Flags)
  // We know that the same flag is specified more than once when the flags
  // weren't modified.
  return error("duplicate '" + Token.stringValue() + "' memory operand flag");
lex();
return false;
3037}

3039bool MIParser::parseMemoryPseudoSourceValue(const PseudoSourceValue *&PSV) {
switch (Token.kind()) {
case MIToken::kw_stack:
  PSV = MF.getPSVManager().getStack();
  break;
case MIToken::kw_got:
  PSV = MF.getPSVManager().getGOT();
  break;
case MIToken::kw_jump_table:
  PSV = MF.getPSVManager().getJumpTable();
  break;
case MIToken::kw_constant_pool:
  PSV = MF.getPSVManager().getConstantPool();
  break;
case MIToken::FixedStackObject: {
  int FI;
  if (parseFixedStackFrameIndex(FI))
    return true;
  PSV = MF.getPSVManager().getFixedStack(FI);
  // The token was already consumed, so use return here instead of break.
  return false;
}
case MIToken::StackObject: {
  int FI;
  if (parseStackFrameIndex(FI))
    return true;
  PSV = MF.getPSVManager().getFixedStack(FI);
  // The token was already consumed, so use return here instead of break.
  return false;
}
case MIToken::kw_call_entry:
  lex();
  switch (Token.kind()) {
  case MIToken::GlobalValue:
  case MIToken::NamedGlobalValue: {
    GlobalValue *GV = nullptr;
    if (parseGlobalValue(GV))
      return true;
    PSV = MF.getPSVManager().getGlobalValueCallEntry(GV);
    break;
  }
  case MIToken::ExternalSymbol:
    PSV = MF.getPSVManager().getExternalSymbolCallEntry(
        MF.createExternalSymbolName(Token.stringValue()));
    break;
  default:
    return error(
        "expected a global value or an external symbol after 'call-entry'");
  }
  break;
case MIToken::kw_custom: {
  lex();
  const auto *TII = MF.getSubtarget().getInstrInfo();
  if (const auto *Formatter = TII->getMIRFormatter()) {
    if (Formatter->parseCustomPseudoSourceValue(
            Token.stringValue(), MF, PFS, PSV,
            [this](StringRef::iterator Loc, const Twine &Msg) -> bool {
              return error(Loc, Msg);
            }))
      return true;
  } else
    return error("unable to parse target custom pseudo source value");
  break;
}
default:
  llvm_unreachable("The current token should be pseudo source value")__builtin_unreachable();
}
lex();
return false;
3108}

3110bool MIParser::parseMachinePointerInfo(MachinePointerInfo &Dest) {
if (Token.is(MIToken::kw_constant_pool) || Token.is(MIToken::kw_stack) ||
    Token.is(MIToken::kw_got) || Token.is(MIToken::kw_jump_table) ||
    Token.is(MIToken::FixedStackObject) || Token.is(MIToken::StackObject) ||
    Token.is(MIToken::kw_call_entry) || Token.is(MIToken::kw_custom)) {
  const PseudoSourceValue *PSV = nullptr;
  if (parseMemoryPseudoSourceValue(PSV))
    return true;
  int64_t Offset = 0;
  if (parseOffset(Offset))
    return true;
  Dest = MachinePointerInfo(PSV, Offset);
  return false;
}
if (Token.isNot(MIToken::NamedIRValue) && Token.isNot(MIToken::IRValue) &&
    Token.isNot(MIToken::GlobalValue) &&
    Token.isNot(MIToken::NamedGlobalValue) &&
    Token.isNot(MIToken::QuotedIRValue) &&
    Token.isNot(MIToken::kw_unknown_address))
  return error("expected an IR value reference");
const Value *V = nullptr;
if (parseIRValue(V))
  return true;
if (V && !V->getType()->isPointerTy())
  return error("expected a pointer IR value");
lex();
int64_t Offset = 0;
if (parseOffset(Offset))
  return true;
Dest = MachinePointerInfo(V, Offset);
return false;
3141}

3143bool MIParser::parseOptionalScope(LLVMContext &Context,
                                SyncScope::ID &SSID) {
SSID = SyncScope::System;
if (Token.is(MIToken::Identifier) && Token.stringValue() == "syncscope") {
  lex();
  if (expectAndConsume(MIToken::lparen))
    return error("expected '(' in syncscope");

  std::string SSN;
  if (parseStringConstant(SSN))
    return true;

  SSID = Context.getOrInsertSyncScopeID(SSN);
  if (expectAndConsume(MIToken::rparen))
    return error("expected ')' in syncscope");
}

return false;
3161}

3163bool MIParser::parseOptionalAtomicOrdering(AtomicOrdering &Order) {
Order = AtomicOrdering::NotAtomic;
if (Token.isNot(MIToken::Identifier))
  return false;

Order = StringSwitch<AtomicOrdering>(Token.stringValue())
            .Case("unordered", AtomicOrdering::Unordered)
            .Case("monotonic", AtomicOrdering::Monotonic)
            .Case("acquire", AtomicOrdering::Acquire)
            .Case("release", AtomicOrdering::Release)
            .Case("acq_rel", AtomicOrdering::AcquireRelease)
            .Case("seq_cst", AtomicOrdering::SequentiallyConsistent)
            .Default(AtomicOrdering::NotAtomic);

if (Order != AtomicOrdering::NotAtomic) {
  lex();
  return false;
}

return error("expected an atomic scope, ordering or a size specification");
3183}

3185bool MIParser::parseMachineMemoryOperand(MachineMemOperand *&Dest) {
if (expectAndConsume(MIToken::lparen))
  return true;
MachineMemOperand::Flags Flags = MachineMemOperand::MONone;
while (Token.isMemoryOperandFlag()) {
  if (parseMemoryOperandFlag(Flags))
    return true;
}
if (Token.isNot(MIToken::Identifier) ||
    (Token.stringValue() != "load" && Token.stringValue() != "store"))
  return error("expected 'load' or 'store' memory operation");
if (Token.stringValue() == "load")
  Flags |= MachineMemOperand::MOLoad;
else
  Flags |= MachineMemOperand::MOStore;
lex();

// Optional 'store' for operands that both load and store.
if (Token.is(MIToken::Identifier) && Token.stringValue() == "store") {
  Flags |= MachineMemOperand::MOStore;
  lex();
}

// Optional synchronization scope.
SyncScope::ID SSID;
if (parseOptionalScope(MF.getFunction().getContext(), SSID))
  return true;

// Up to two atomic orderings (cmpxchg provides guarantees on failure).
AtomicOrdering Order, FailureOrder;
if (parseOptionalAtomicOrdering(Order))
  return true;

if (parseOptionalAtomicOrdering(FailureOrder))
  return true;

LLT MemoryType;
if (Token.isNot(MIToken::IntegerLiteral) &&
    Token.isNot(MIToken::kw_unknown_size) &&
    Token.isNot(MIToken::lparen))
  return error("expected memory LLT, the size integer literal or 'unknown-size' after "
               "memory operation");

uint64_t Size = MemoryLocation::UnknownSize;
if (Token.is(MIToken::IntegerLiteral)) {
  if (getUint64(Size))
    return true;

  // Convert from bytes to bits for storage.
  MemoryType = LLT::scalar(8 * Size);
  lex();
} else if (Token.is(MIToken::kw_unknown_size)) {
  Size = MemoryLocation::UnknownSize;
  lex();
} else {
  if (expectAndConsume(MIToken::lparen))
    return true;
  if (parseLowLevelType(Token.location(), MemoryType))
    return true;
  if (expectAndConsume(MIToken::rparen))
    return true;

  Size = MemoryType.getSizeInBytes();
}

MachinePointerInfo Ptr = MachinePointerInfo();
if (Token.is(MIToken::Identifier)) {
  const char *Word =
      ((Flags & MachineMemOperand::MOLoad) &&
       (Flags & MachineMemOperand::MOStore))
          ? "on"
          : Flags & MachineMemOperand::MOLoad ? "from" : "into";
  if (Token.stringValue() != Word)
    return error(Twine("expected '") + Word + "'");
  lex();

  if (parseMachinePointerInfo(Ptr))
    return true;
}
unsigned BaseAlignment =
    (Size != MemoryLocation::UnknownSize ? PowerOf2Ceil(Size) : 1);
AAMDNodes AAInfo;
MDNode *Range = nullptr;
while (consumeIfPresent(MIToken::comma)) {
  switch (Token.kind()) {
  case MIToken::kw_align:
    // align is printed if it is different than size.
    if (parseAlignment(BaseAlignment))
      return true;
    break;
  case MIToken::kw_basealign:
    // basealign is printed if it is different than align.
    if (parseAlignment(BaseAlignment))
      return true;
    break;
  case MIToken::kw_addrspace:
    if (parseAddrspace(Ptr.AddrSpace))
      return true;
    break;
  case MIToken::md_tbaa:
    lex();
    if (parseMDNode(AAInfo.TBAA))
      return true;
    break;
  case MIToken::md_alias_scope:
    lex();
    if (parseMDNode(AAInfo.Scope))
      return true;
    break;
  case MIToken::md_noalias:
    lex();
    if (parseMDNode(AAInfo.NoAlias))
      return true;
    break;
  case MIToken::md_range:
    lex();
    if (parseMDNode(Range))
      return true;
    break;
  // TODO: Report an error on duplicate metadata nodes.
  default:
    return error("expected 'align' or '!tbaa' or '!alias.scope' or "
                 "'!noalias' or '!range'");
  }
}
if (expectAndConsume(MIToken::rparen))
  return true;
Dest = MF.getMachineMemOperand(Ptr, Flags, MemoryType, Align(BaseAlignment),
                               AAInfo, Range, SSID, Order, FailureOrder);
return false;
3315}

3317bool MIParser::parsePreOrPostInstrSymbol(MCSymbol *&Symbol) {
assert((Token.is(MIToken::kw_pre_instr_symbol) ||((void)0)
        Token.is(MIToken::kw_post_instr_symbol)) &&((void)0)
       "Invalid token for a pre- post-instruction symbol!")((void)0);
lex();
if (Token.isNot(MIToken::MCSymbol))
  return error("expected a symbol after 'pre-instr-symbol'");
Symbol = getOrCreateMCSymbol(Token.stringValue());
lex();
if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
    Token.is(MIToken::lbrace))
  return false;
if (Token.isNot(MIToken::comma))
  return error("expected ',' before the next machine operand");
lex();
return false;
3333}

3335bool MIParser::parseHeapAllocMarker(MDNode *&Node) {
assert(Token.is(MIToken::kw_heap_alloc_marker) &&((void)0)
       "Invalid token for a heap alloc marker!")((void)0);
lex();
parseMDNode(Node);
if (!Node)
  return error("expected a MDNode after 'heap-alloc-marker'");
if (Token.isNewlineOrEOF() || Token.is(MIToken::coloncolon) ||
    Token.is(MIToken::lbrace))
  return false;
if (Token.isNot(MIToken::comma))
  return error("expected ',' before the next machine operand");
lex();
return false;
3349}

3351static void initSlots2BasicBlocks(
  const Function &F,
  DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
ModuleSlotTracker MST(F.getParent(), /*ShouldInitializeAllMetadata=*/false);
MST.incorporateFunction(F);
for (auto &BB : F) {
  if (BB.hasName())
    continue;
  int Slot = MST.getLocalSlot(&BB);
  if (Slot == -1)
    continue;
  Slots2BasicBlocks.insert(std::make_pair(unsigned(Slot), &BB));
}
3364}

3366static const BasicBlock *getIRBlockFromSlot(
  unsigned Slot,
  const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
return Slots2BasicBlocks.lookup(Slot);
3370}

3372const BasicBlock *MIParser::getIRBlock(unsigned Slot) {
if (Slots2BasicBlocks.empty())
  initSlots2BasicBlocks(MF.getFunction(), Slots2BasicBlocks);
return getIRBlockFromSlot(Slot, Slots2BasicBlocks);
3376}

3378const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
if (&F == &MF.getFunction())
  return getIRBlock(Slot);
DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
initSlots2BasicBlocks(F, CustomSlots2BasicBlocks);
return getIRBlockFromSlot(Slot, CustomSlots2BasicBlocks);
3384}

3386MCSymbol *MIParser::getOrCreateMCSymbol(StringRef Name) {
// FIXME: Currently we can't recognize temporary or local symbols and call all
// of the appropriate forms to create them. However, this handles basic cases
// well as most of the special aspects are recognized by a prefix on their
// name, and the input names should already be unique. For test cases, keeping
// the symbol name out of the symbol table isn't terribly important.
return MF.getContext().getOrCreateSymbol(Name);
3393}

3395bool MIParser::parseStringConstant(std::string &Result) {
if (Token.isNot(MIToken::StringConstant))
  return error("expected string constant");
Result = std::string(Token.stringValue());
lex();
return false;
3401}

3403bool llvm::parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS,
                                           StringRef Src,
                                           SMDiagnostic &Error) {
return MIParser(PFS, Error, Src).parseBasicBlockDefinitions(PFS.MBBSlots);
3407}

3409bool llvm::parseMachineInstructions(PerFunctionMIParsingState &PFS,
                                  StringRef Src, SMDiagnostic &Error) {
return MIParser(PFS, Error, Src).parseBasicBlocks();
3412}

3414bool llvm::parseMBBReference(PerFunctionMIParsingState &PFS,
                           MachineBasicBlock *&MBB, StringRef Src,
                           SMDiagnostic &Error) {
return MIParser(PFS, Error, Src).parseStandaloneMBB(MBB);
3418}

3420bool llvm::parseRegisterReference(PerFunctionMIParsingState &PFS,
                                Register &Reg, StringRef Src,
                                SMDiagnostic &Error) {
return MIParser(PFS, Error, Src).parseStandaloneRegister(Reg);
3424}

3426bool llvm::parseNamedRegisterReference(PerFunctionMIParsingState &PFS,
                                     Register &Reg, StringRef Src,
                                     SMDiagnostic &Error) {
return MIParser(PFS, Error, Src).parseStandaloneNamedRegister(Reg);
3430}

3432bool llvm::parseVirtualRegisterReference(PerFunctionMIParsingState &PFS,
                                       VRegInfo *&Info, StringRef Src,
                                       SMDiagnostic &Error) {
return MIParser(PFS, Error, Src).parseStandaloneVirtualRegister(Info);
3436}

3438bool llvm::parseStackObjectReference(PerFunctionMIParsingState &PFS,
                                   int &FI, StringRef Src,
                                   SMDiagnostic &Error) {
return MIParser(PFS, Error, Src).parseStandaloneStackObject(FI);
3442}

3444bool llvm::parseMDNode(PerFunctionMIParsingState &PFS,
                     MDNode *&Node, StringRef Src, SMDiagnostic &Error) {
return MIParser(PFS, Error, Src).parseStandaloneMDNode(Node);
3447}

3449bool llvm::parseMachineMetadata(PerFunctionMIParsingState &PFS, StringRef Src,
                              SMRange SrcRange, SMDiagnostic &Error) {
return MIParser(PFS, Error, Src, SrcRange).parseMachineMetadata();
3452}

3454bool MIRFormatter::parseIRValue(StringRef Src, MachineFunction &MF,
                              PerFunctionMIParsingState &PFS, const Value *&V,
                              ErrorCallbackType ErrorCallback) {
MIToken Token;
Src = lexMIToken(Src, Token, [&](StringRef::iterator Loc, const Twine &Msg) {
  ErrorCallback(Loc, Msg);
});
V = nullptr;

return ::parseIRValue(Token, PFS, V, ErrorCallback);
3464}

←

/usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support/Allocator.h

→

1//===- Allocator.h - Simple memory allocation abstraction -------*- 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/// \file
9///
10/// This file defines the BumpPtrAllocator interface. BumpPtrAllocator conforms
11/// to the LLVM "Allocator" concept and is similar to MallocAllocator, but
12/// objects cannot be deallocated. Their lifetime is tied to the lifetime of the
13/// allocator.
14///
15//===----------------------------------------------------------------------===//

17#ifndef LLVM_SUPPORT_ALLOCATOR_H
18#define LLVM_SUPPORT_ALLOCATOR_H

20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/Support/Alignment.h"
23#include "llvm/Support/AllocatorBase.h"
24#include "llvm/Support/Compiler.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/MathExtras.h"
27#include "llvm/Support/MemAlloc.h"
28#include <algorithm>
29#include <cassert>
30#include <cstddef>
31#include <cstdint>
32#include <cstdlib>
33#include <iterator>
34#include <type_traits>
35#include <utility>

37namespace llvm {

39namespace detail {

41// We call out to an external function to actually print the message as the
42// printing code uses Allocator.h in its implementation.
43void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated,
                              size_t TotalMemory);

46} // end namespace detail

48/// Allocate memory in an ever growing pool, as if by bump-pointer.
49///
50/// This isn't strictly a bump-pointer allocator as it uses backing slabs of
51/// memory rather than relying on a boundless contiguous heap. However, it has
52/// bump-pointer semantics in that it is a monotonically growing pool of memory
53/// where every allocation is found by merely allocating the next N bytes in
54/// the slab, or the next N bytes in the next slab.
55///
56/// Note that this also has a threshold for forcing allocations above a certain
57/// size into their own slab.
58///
59/// The BumpPtrAllocatorImpl template defaults to using a MallocAllocator
60/// object, which wraps malloc, to allocate memory, but it can be changed to
61/// use a custom allocator.
62///
63/// The GrowthDelay specifies after how many allocated slabs the allocator
64/// increases the size of the slabs.
65template <typename AllocatorT = MallocAllocator, size_t SlabSize = 4096,
        size_t SizeThreshold = SlabSize, size_t GrowthDelay = 128>
67class BumpPtrAllocatorImpl
  : public AllocatorBase<BumpPtrAllocatorImpl<AllocatorT, SlabSize,
                                              SizeThreshold, GrowthDelay>>,
    private AllocatorT {
71public:
static_assert(SizeThreshold <= SlabSize,
              "The SizeThreshold must be at most the SlabSize to ensure "
              "that objects larger than a slab go into their own memory "
              "allocation.");
static_assert(GrowthDelay > 0,
              "GrowthDelay must be at least 1 which already increases the"
              "slab size after each allocated slab.");

BumpPtrAllocatorImpl() = default;

template <typename T>
BumpPtrAllocatorImpl(T &&Allocator)
    : AllocatorT(std::forward<T &&>(Allocator)) {}

// Manually implement a move constructor as we must clear the old allocator's
// slabs as a matter of correctness.
BumpPtrAllocatorImpl(BumpPtrAllocatorImpl &&Old)
    : AllocatorT(static_cast<AllocatorT &&>(Old)), CurPtr(Old.CurPtr),
      End(Old.End), Slabs(std::move(Old.Slabs)),
      CustomSizedSlabs(std::move(Old.CustomSizedSlabs)),
      BytesAllocated(Old.BytesAllocated), RedZoneSize(Old.RedZoneSize) {
  Old.CurPtr = Old.End = nullptr;
  Old.BytesAllocated = 0;
  Old.Slabs.clear();
  Old.CustomSizedSlabs.clear();
}

~BumpPtrAllocatorImpl() {
  DeallocateSlabs(Slabs.begin(), Slabs.end());
  DeallocateCustomSizedSlabs();
}

BumpPtrAllocatorImpl &operator=(BumpPtrAllocatorImpl &&RHS) {
  DeallocateSlabs(Slabs.begin(), Slabs.end());
  DeallocateCustomSizedSlabs();

  CurPtr = RHS.CurPtr;
  End = RHS.End;
  BytesAllocated = RHS.BytesAllocated;
  RedZoneSize = RHS.RedZoneSize;
  Slabs = std::move(RHS.Slabs);
  CustomSizedSlabs = std::move(RHS.CustomSizedSlabs);
  AllocatorT::operator=(static_cast<AllocatorT &&>(RHS));

  RHS.CurPtr = RHS.End = nullptr;
  RHS.BytesAllocated = 0;
  RHS.Slabs.clear();
  RHS.CustomSizedSlabs.clear();
  return *this;
}

/// Deallocate all but the current slab and reset the current pointer
/// to the beginning of it, freeing all memory allocated so far.
void Reset() {
  // Deallocate all but the first slab, and deallocate all custom-sized slabs.
  DeallocateCustomSizedSlabs();
  CustomSizedSlabs.clear();

  if (Slabs.empty())
    return;

  // Reset the state.
  BytesAllocated = 0;
  CurPtr = (char *)Slabs.front();
  End = CurPtr + SlabSize;

  __asan_poison_memory_region(*Slabs.begin(), computeSlabSize(0));
  DeallocateSlabs(std::next(Slabs.begin()), Slabs.end());
  Slabs.erase(std::next(Slabs.begin()), Slabs.end());
}

/// Allocate space at the specified alignment.
LLVM_ATTRIBUTE_RETURNS_NONNULL__attribute__((returns_nonnull)) LLVM_ATTRIBUTE_RETURNS_NOALIAS__attribute__((__malloc__)) void *
Allocate(size_t Size, Align Alignment) {
  // Keep track of how many bytes we've allocated.
  BytesAllocated += Size;

  size_t Adjustment = offsetToAlignedAddr(CurPtr, Alignment);
7
←
Calling 'offsetToAlignedAddr'→
  assert(Adjustment + Size >= Size && "Adjustment + Size must not overflow")((void)0);

  size_t SizeToAllocate = Size;
153#if LLVM_ADDRESS_SANITIZER_BUILD0
  // Add trailing bytes as a "red zone" under ASan.
  SizeToAllocate += RedZoneSize;
156#endif

  // Check if we have enough space.
  if (Adjustment + SizeToAllocate <= size_t(End - CurPtr)) {
    char *AlignedPtr = CurPtr + Adjustment;
    CurPtr = AlignedPtr + SizeToAllocate;
    // Update the allocation point of this memory block in MemorySanitizer.
    // Without this, MemorySanitizer messages for values originated from here
    // will point to the allocation of the entire slab.
    __msan_allocated_memory(AlignedPtr, Size);
    // Similarly, tell ASan about this space.
    __asan_unpoison_memory_region(AlignedPtr, Size);
    return AlignedPtr;
  }

  // If Size is really big, allocate a separate slab for it.
  size_t PaddedSize = SizeToAllocate + Alignment.value() - 1;
  if (PaddedSize > SizeThreshold) {
    void *NewSlab =
        AllocatorT::Allocate(PaddedSize, alignof(std::max_align_t));
    // We own the new slab and don't want anyone reading anyting other than
    // pieces returned from this method.  So poison the whole slab.
    __asan_poison_memory_region(NewSlab, PaddedSize);
    CustomSizedSlabs.push_back(std::make_pair(NewSlab, PaddedSize));

    uintptr_t AlignedAddr = alignAddr(NewSlab, Alignment);
    assert(AlignedAddr + Size <= (uintptr_t)NewSlab + PaddedSize)((void)0);
    char *AlignedPtr = (char*)AlignedAddr;
    __msan_allocated_memory(AlignedPtr, Size);
    __asan_unpoison_memory_region(AlignedPtr, Size);
    return AlignedPtr;
  }

  // Otherwise, start a new slab and try again.
  StartNewSlab();
  uintptr_t AlignedAddr = alignAddr(CurPtr, Alignment);
  assert(AlignedAddr + SizeToAllocate <= (uintptr_t)End &&((void)0)
         "Unable to allocate memory!")((void)0);
  char *AlignedPtr = (char*)AlignedAddr;
  CurPtr = AlignedPtr + SizeToAllocate;
  __msan_allocated_memory(AlignedPtr, Size);
  __asan_unpoison_memory_region(AlignedPtr, Size);
  return AlignedPtr;
}

inline LLVM_ATTRIBUTE_RETURNS_NONNULL__attribute__((returns_nonnull)) LLVM_ATTRIBUTE_RETURNS_NOALIAS__attribute__((__malloc__)) void *
Allocate(size_t Size, size_t Alignment) {
  assert(Alignment > 0 && "0-byte alignment is not allowed. Use 1 instead.")((void)0);
  return Allocate(Size, Align(Alignment));
6
←
Calling 'BumpPtrAllocatorImpl::Allocate'→
}

// Pull in base class overloads.
using AllocatorBase<BumpPtrAllocatorImpl>::Allocate;

// Bump pointer allocators are expected to never free their storage; and
// clients expect pointers to remain valid for non-dereferencing uses even
// after deallocation.
void Deallocate(const void *Ptr, size_t Size, size_t /*Alignment*/) {
  __asan_poison_memory_region(Ptr, Size);
}

// Pull in base class overloads.
using AllocatorBase<BumpPtrAllocatorImpl>::Deallocate;

size_t GetNumSlabs() const { return Slabs.size() + CustomSizedSlabs.size(); }

/// \return An index uniquely and reproducibly identifying
/// an input pointer \p Ptr in the given allocator.
/// The returned value is negative iff the object is inside a custom-size
/// slab.
/// Returns an empty optional if the pointer is not found in the allocator.
llvm::Optional<int64_t> identifyObject(const void *Ptr) {
  const char *P = static_cast<const char *>(Ptr);
  int64_t InSlabIdx = 0;
  for (size_t Idx = 0, E = Slabs.size(); Idx < E; Idx++) {
    const char *S = static_cast<const char *>(Slabs[Idx]);
    if (P >= S && P < S + computeSlabSize(Idx))
      return InSlabIdx + static_cast<int64_t>(P - S);
    InSlabIdx += static_cast<int64_t>(computeSlabSize(Idx));
  }

  // Use negative index to denote custom sized slabs.
  int64_t InCustomSizedSlabIdx = -1;
  for (size_t Idx = 0, E = CustomSizedSlabs.size(); Idx < E; Idx++) {
    const char *S = static_cast<const char *>(CustomSizedSlabs[Idx].first);
    size_t Size = CustomSizedSlabs[Idx].second;
    if (P >= S && P < S + Size)
      return InCustomSizedSlabIdx - static_cast<int64_t>(P - S);
    InCustomSizedSlabIdx -= static_cast<int64_t>(Size);
  }
  return None;
}

/// A wrapper around identifyObject that additionally asserts that
/// the object is indeed within the allocator.
/// \return An index uniquely and reproducibly identifying
/// an input pointer \p Ptr in the given allocator.
int64_t identifyKnownObject(const void *Ptr) {
  Optional<int64_t> Out = identifyObject(Ptr);
  assert(Out && "Wrong allocator used")((void)0);
  return *Out;
}

/// A wrapper around identifyKnownObject. Accepts type information
/// about the object and produces a smaller identifier by relying on
/// the alignment information. Note that sub-classes may have different
/// alignment, so the most base class should be passed as template parameter
/// in order to obtain correct results. For that reason automatic template
/// parameter deduction is disabled.
/// \return An index uniquely and reproducibly identifying
/// an input pointer \p Ptr in the given allocator. This identifier is
/// different from the ones produced by identifyObject and
/// identifyAlignedObject.
template <typename T>
int64_t identifyKnownAlignedObject(const void *Ptr) {
  int64_t Out = identifyKnownObject(Ptr);
  assert(Out % alignof(T) == 0 && "Wrong alignment information")((void)0);
  return Out / alignof(T);
}

size_t getTotalMemory() const {
  size_t TotalMemory = 0;
  for (auto I = Slabs.begin(), E = Slabs.end(); I != E; ++I)
    TotalMemory += computeSlabSize(std::distance(Slabs.begin(), I));
  for (auto &PtrAndSize : CustomSizedSlabs)
    TotalMemory += PtrAndSize.second;
  return TotalMemory;
}

size_t getBytesAllocated() const { return BytesAllocated; }

void setRedZoneSize(size_t NewSize) {
  RedZoneSize = NewSize;
}

void PrintStats() const {
  detail::printBumpPtrAllocatorStats(Slabs.size(), BytesAllocated,
                                     getTotalMemory());
}

296private:
/// The current pointer into the current slab.
///
/// This points to the next free byte in the slab.
char *CurPtr = nullptr;

/// The end of the current slab.
char *End = nullptr;

/// The slabs allocated so far.
SmallVector<void *, 4> Slabs;

/// Custom-sized slabs allocated for too-large allocation requests.
SmallVector<std::pair<void *, size_t>, 0> CustomSizedSlabs;

/// How many bytes we've allocated.
///
/// Used so that we can compute how much space was wasted.
size_t BytesAllocated = 0;

/// The number of bytes to put between allocations when running under
/// a sanitizer.
size_t RedZoneSize = 1;

static size_t computeSlabSize(unsigned SlabIdx) {
  // Scale the actual allocated slab size based on the number of slabs
  // allocated. Every GrowthDelay slabs allocated, we double
  // the allocated size to reduce allocation frequency, but saturate at
  // multiplying the slab size by 2^30.
  return SlabSize *
         ((size_t)1 << std::min<size_t>(30, SlabIdx / GrowthDelay));
}

/// Allocate a new slab and move the bump pointers over into the new
/// slab, modifying CurPtr and End.
void StartNewSlab() {
  size_t AllocatedSlabSize = computeSlabSize(Slabs.size());

  void *NewSlab =
      AllocatorT::Allocate(AllocatedSlabSize, alignof(std::max_align_t));
  // We own the new slab and don't want anyone reading anything other than
  // pieces returned from this method.  So poison the whole slab.
  __asan_poison_memory_region(NewSlab, AllocatedSlabSize);

  Slabs.push_back(NewSlab);
  CurPtr = (char *)(NewSlab);
  End = ((char *)NewSlab) + AllocatedSlabSize;
}

/// Deallocate a sequence of slabs.
void DeallocateSlabs(SmallVectorImpl<void *>::iterator I,
                     SmallVectorImpl<void *>::iterator E) {
  for (; I != E; ++I) {
    size_t AllocatedSlabSize =
        computeSlabSize(std::distance(Slabs.begin(), I));
    AllocatorT::Deallocate(*I, AllocatedSlabSize, alignof(std::max_align_t));
  }
}

/// Deallocate all memory for custom sized slabs.
void DeallocateCustomSizedSlabs() {
  for (auto &PtrAndSize : CustomSizedSlabs) {
    void *Ptr = PtrAndSize.first;
    size_t Size = PtrAndSize.second;
    AllocatorT::Deallocate(Ptr, Size, alignof(std::max_align_t));
  }
}

template <typename T> friend class SpecificBumpPtrAllocator;
365};

367/// The standard BumpPtrAllocator which just uses the default template
368/// parameters.
369typedef BumpPtrAllocatorImpl<> BumpPtrAllocator;

371/// A BumpPtrAllocator that allows only elements of a specific type to be
372/// allocated.
373///
374/// This allows calling the destructor in DestroyAll() and when the allocator is
375/// destroyed.
376template <typename T> class SpecificBumpPtrAllocator {
BumpPtrAllocator Allocator;

379public:
SpecificBumpPtrAllocator() {
  // Because SpecificBumpPtrAllocator walks the memory to call destructors,
  // it can't have red zones between allocations.
  Allocator.setRedZoneSize(0);
}
SpecificBumpPtrAllocator(SpecificBumpPtrAllocator &&Old)
    : Allocator(std::move(Old.Allocator)) {}
~SpecificBumpPtrAllocator() { DestroyAll(); }

SpecificBumpPtrAllocator &operator=(SpecificBumpPtrAllocator &&RHS) {
  Allocator = std::move(RHS.Allocator);
  return *this;
}

/// Call the destructor of each allocated object and deallocate all but the
/// current slab and reset the current pointer to the beginning of it, freeing
/// all memory allocated so far.
void DestroyAll() {
  auto DestroyElements = [](char *Begin, char *End) {
    assert(Begin == (char *)alignAddr(Begin, Align::Of<T>()))((void)0);
    for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
      reinterpret_cast<T *>(Ptr)->~T();
  };

  for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
       ++I) {
    size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
        std::distance(Allocator.Slabs.begin(), I));
    char *Begin = (char *)alignAddr(*I, Align::Of<T>());
    char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
                                             : (char *)*I + AllocatedSlabSize;

    DestroyElements(Begin, End);
  }

  for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
    void *Ptr = PtrAndSize.first;
    size_t Size = PtrAndSize.second;
    DestroyElements((char *)alignAddr(Ptr, Align::Of<T>()),
                    (char *)Ptr + Size);
  }

  Allocator.Reset();
}

/// Allocate space for an array of objects without constructing them.
T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
427};

429} // end namespace llvm

431template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold,
        size_t GrowthDelay>
433void *
434operator new(size_t Size,
           llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold,
                                      GrowthDelay> &Allocator) {
return Allocator.Allocate(Size, std::min((size_t)llvm::NextPowerOf2(Size),
5
←
Calling 'BumpPtrAllocatorImpl::Allocate'→
                                         alignof(std::max_align_t)));
439}

441template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold,
        size_t GrowthDelay>
443void operator delete(void *,
                   llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize,
                                              SizeThreshold, GrowthDelay> &) {
446}

448#endif // LLVM_SUPPORT_ALLOCATOR_H

←

/usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support/Alignment.h

1//===-- llvm/Support/Alignment.h - Useful alignment functions ---*- 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 contains types to represent alignments.
10// They are instrumented to guarantee some invariants are preserved and prevent
11// invalid manipulations.
12//
13// - Align represents an alignment in bytes, it is always set and always a valid
14// power of two, its minimum value is 1 which means no alignment requirements.
15//
16// - MaybeAlign is an optional type, it may be undefined or set. When it's set
17// you can get the underlying Align type by using the getValue() method.
18//
19//===----------------------------------------------------------------------===//
20 
21#ifndef LLVM_SUPPORT_ALIGNMENT_H_
22#define LLVM_SUPPORT_ALIGNMENT_H_
23 
24#include "llvm/ADT/Optional.h"
25#include "llvm/Support/MathExtras.h"
26#include <cassert>
27#ifndef NDEBUG1
28#include <string>
29#endif // NDEBUG
30 
31namespace llvm {
32 
33#define ALIGN_CHECK_ISPOSITIVE(decl)                                           \
34  assert(decl > 0 && (#decl " should be defined"))((void)0)
35 
36/// This struct is a compact representation of a valid (non-zero power of two)
37/// alignment.
38/// It is suitable for use as static global constants.
39struct Align {
40private:
41  uint8_t ShiftValue = 0; /// The log2 of the required alignment.
42                          /// ShiftValue is less than 64 by construction.
43 
44  friend struct MaybeAlign;
45  friend unsigned Log2(Align);
46  friend bool operator==(Align Lhs, Align Rhs);
47  friend bool operator!=(Align Lhs, Align Rhs);
48  friend bool operator<=(Align Lhs, Align Rhs);
49  friend bool operator>=(Align Lhs, Align Rhs);
50  friend bool operator<(Align Lhs, Align Rhs);
51  friend bool operator>(Align Lhs, Align Rhs);
52  friend unsigned encode(struct MaybeAlign A);
53  friend struct MaybeAlign decodeMaybeAlign(unsigned Value);
54 
55  /// A trivial type to allow construction of constexpr Align.
56  /// This is currently needed to workaround a bug in GCC 5.3 which prevents
57  /// definition of constexpr assign operators.
58  /// https://stackoverflow.com/questions/46756288/explicitly-defaulted-function-cannot-be-declared-as-constexpr-because-the-implic
59  /// FIXME: Remove this, make all assign operators constexpr and introduce user
60  /// defined literals when we don't have to support GCC 5.3 anymore.
61  /// https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain
62  struct LogValue {
63    uint8_t Log;
64  };
65 
66public:
67  /// Default is byte-aligned.
68  constexpr Align() = default;
69  /// Do not perform checks in case of copy/move construct/assign, because the
70  /// checks have been performed when building `Other`.
71  constexpr Align(const Align &Other) = default;
72  constexpr Align(Align &&Other) = default;
73  Align &operator=(const Align &Other) = default;
74  Align &operator=(Align &&Other) = default;
75 
76  explicit Align(uint64_t Value) {
77    assert(Value > 0 && "Value must not be 0")((void)0);
78    assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2")((void)0);
79    ShiftValue = Log2_64(Value);
80    assert(ShiftValue < 64 && "Broken invariant")((void)0);
81  }
82 
83  /// This is a hole in the type system and should not be abused.
84  /// Needed to interact with C for instance.
85  uint64_t value() const { return uint64_t(1) << ShiftValue; }
12
←
The result of the left shift is undefined due to shifting by '255', which is greater or equal to the width of type 'uint64_t'
86 
87  /// Allow constructions of constexpr Align.
88  template <size_t kValue> constexpr static LogValue Constant() {
89    return LogValue{static_cast<uint8_t>(CTLog2<kValue>())};
90  }
91 
92  /// Allow constructions of constexpr Align from types.
93  /// Compile time equivalent to Align(alignof(T)).
94  template <typename T> constexpr static LogValue Of() {
95    return Constant<std::alignment_of<T>::value>();
96  }
97 
98  /// Constexpr constructor from LogValue type.
99  constexpr Align(LogValue CA) : ShiftValue(CA.Log) {}
100};
101 
102/// Treats the value 0 as a 1, so Align is always at least 1.
103inline Align assumeAligned(uint64_t Value) {
104  return Value ? Align(Value) : Align();
105}
106 
107/// This struct is a compact representation of a valid (power of two) or
108/// undefined (0) alignment.
109struct MaybeAlign : public llvm::Optional<Align> {
110private:
111  using UP = llvm::Optional<Align>;
112 
113public:
114  /// Default is undefined.
115  MaybeAlign() = default;
116  /// Do not perform checks in case of copy/move construct/assign, because the
117  /// checks have been performed when building `Other`.
118  MaybeAlign(const MaybeAlign &Other) = default;
119  MaybeAlign &operator=(const MaybeAlign &Other) = default;
120  MaybeAlign(MaybeAlign &&Other) = default;
121  MaybeAlign &operator=(MaybeAlign &&Other) = default;
122 
123  /// Use llvm::Optional<Align> constructor.
124  using UP::UP;
125 
126  explicit MaybeAlign(uint64_t Value) {
127    assert((Value == 0 || llvm::isPowerOf2_64(Value)) &&((void)0)
128           "Alignment is neither 0 nor a power of 2")((void)0);
129    if (Value)
130      emplace(Value);
131  }
132 
133  /// For convenience, returns a valid alignment or 1 if undefined.
134  Align valueOrOne() const { return hasValue() ? getValue() : Align(); }
135};
136 
137/// Checks that SizeInBytes is a multiple of the alignment.
138inline bool isAligned(Align Lhs, uint64_t SizeInBytes) {
139  return SizeInBytes % Lhs.value() == 0;
140}
141 
142/// Checks that Addr is a multiple of the alignment.
143inline bool isAddrAligned(Align Lhs, const void *Addr) {
144  return isAligned(Lhs, reinterpret_cast<uintptr_t>(Addr));
145}
146 
147/// Returns a multiple of A needed to store `Size` bytes.
148inline uint64_t alignTo(uint64_t Size, Align A) {
149  const uint64_t Value = A.value();
11
←
Calling 'Align::value'→
150  // The following line is equivalent to `(Size + Value - 1) / Value * Value`.
151 
152  // The division followed by a multiplication can be thought of as a right
153  // shift followed by a left shift which zeros out the extra bits produced in
154  // the bump; `~(Value - 1)` is a mask where all those bits being zeroed out
155  // are just zero.
156 
157  // Most compilers can generate this code but the pattern may be missed when
158  // multiple functions gets inlined.
159  return (Size + Value - 1) & ~(Value - 1U);
160}
161 
162/// If non-zero \p Skew is specified, the return value will be a minimal integer
163/// that is greater than or equal to \p Size and equal to \p A * N + \p Skew for
164/// some integer N. If \p Skew is larger than \p A, its value is adjusted to '\p
165/// Skew mod \p A'.
166///
167/// Examples:
168/// \code
169///   alignTo(5, Align(8), 7) = 7
170///   alignTo(17, Align(8), 1) = 17
171///   alignTo(~0LL, Align(8), 3) = 3
172/// \endcode
173inline uint64_t alignTo(uint64_t Size, Align A, uint64_t Skew) {
174  const uint64_t Value = A.value();
175  Skew %= Value;
176  return ((Size + Value - 1 - Skew) & ~(Value - 1U)) + Skew;
177}
178 
179/// Returns a multiple of A needed to store `Size` bytes.
180/// Returns `Size` if current alignment is undefined.
181inline uint64_t alignTo(uint64_t Size, MaybeAlign A) {
182  return A ? alignTo(Size, A.getValue()) : Size;
183}
184 
185/// Aligns `Addr` to `Alignment` bytes, rounding up.
186inline uintptr_t alignAddr(const void *Addr, Align Alignment) {
187  uintptr_t ArithAddr = reinterpret_cast<uintptr_t>(Addr);
188  assert(static_cast<uintptr_t>(ArithAddr + Alignment.value() - 1) >=((void)0)
189             ArithAddr &&((void)0)
190         "Overflow")((void)0);
191  return alignTo(ArithAddr, Alignment);
192}
193 
194/// Returns the offset to the next integer (mod 2**64) that is greater than
195/// or equal to \p Value and is a multiple of \p Align.
196inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) {
197  return alignTo(Value, Alignment) - Value;
9
←
The value 255 is assigned to 'A.ShiftValue'→
10
←
Calling 'alignTo'→
198}
199 
200/// Returns the necessary adjustment for aligning `Addr` to `Alignment`
201/// bytes, rounding up.
202inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) {
203  return offsetToAlignment(reinterpret_cast<uintptr_t>(Addr), Alignment);
8
←
Calling 'offsetToAlignment'→
204}
205 
206/// Returns the log2 of the alignment.
207inline unsigned Log2(Align A) { return A.ShiftValue; }
208 
209/// Returns the alignment that satisfies both alignments.
210/// Same semantic as MinAlign.
211inline Align commonAlignment(Align A, Align B) { return std::min(A, B); }
212 
213/// Returns the alignment that satisfies both alignments.
214/// Same semantic as MinAlign.
215inline Align commonAlignment(Align A, uint64_t Offset) {
216  return Align(MinAlign(A.value(), Offset));
217}
218 
219/// Returns the alignment that satisfies both alignments.
220/// Same semantic as MinAlign.
221inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) {
222  return A && B ? commonAlignment(*A, *B) : A ? A : B;
223}
224 
225/// Returns the alignment that satisfies both alignments.
226/// Same semantic as MinAlign.
227inline MaybeAlign commonAlignment(MaybeAlign A, uint64_t Offset) {
228  return MaybeAlign(MinAlign((*A).value(), Offset));
229}
230 
231/// Returns a representation of the alignment that encodes undefined as 0.
232inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; }
233 
234/// Dual operation of the encode function above.
235inline MaybeAlign decodeMaybeAlign(unsigned Value) {
236  if (Value == 0)
237    return MaybeAlign();
238  Align Out;
239  Out.ShiftValue = Value - 1;
240  return Out;
241}
242 
243/// Returns a representation of the alignment, the encoded value is positive by
244/// definition.
245inline unsigned encode(Align A) { return encode(MaybeAlign(A)); }
246 
247/// Comparisons between Align and scalars. Rhs must be positive.
248inline bool operator==(Align Lhs, uint64_t Rhs) {
249  ALIGN_CHECK_ISPOSITIVE(Rhs);
250  return Lhs.value() == Rhs;
251}
252inline bool operator!=(Align Lhs, uint64_t Rhs) {
253  ALIGN_CHECK_ISPOSITIVE(Rhs);
254  return Lhs.value() != Rhs;
255}
256inline bool operator<=(Align Lhs, uint64_t Rhs) {
257  ALIGN_CHECK_ISPOSITIVE(Rhs);
258  return Lhs.value() <= Rhs;
259}
260inline bool operator>=(Align Lhs, uint64_t Rhs) {
261  ALIGN_CHECK_ISPOSITIVE(Rhs);
262  return Lhs.value() >= Rhs;
263}
264inline bool operator<(Align Lhs, uint64_t Rhs) {
265  ALIGN_CHECK_ISPOSITIVE(Rhs);
266  return Lhs.value() < Rhs;
267}
268inline bool operator>(Align Lhs, uint64_t Rhs) {
269  ALIGN_CHECK_ISPOSITIVE(Rhs);
270  return Lhs.value() > Rhs;
271}
272 
273/// Comparisons between MaybeAlign and scalars.
274inline bool operator==(MaybeAlign Lhs, uint64_t Rhs) {
275  return Lhs ? (*Lhs).value() == Rhs : Rhs == 0;
276}
277inline bool operator!=(MaybeAlign Lhs, uint64_t Rhs) {
278  return Lhs ? (*Lhs).value() != Rhs : Rhs != 0;
279}
280 
281/// Comparisons operators between Align.
282inline bool operator==(Align Lhs, Align Rhs) {
283  return Lhs.ShiftValue == Rhs.ShiftValue;
284}
285inline bool operator!=(Align Lhs, Align Rhs) {
286  return Lhs.ShiftValue != Rhs.ShiftValue;
287}
288inline bool operator<=(Align Lhs, Align Rhs) {
289  return Lhs.ShiftValue <= Rhs.ShiftValue;
290}
291inline bool operator>=(Align Lhs, Align Rhs) {
292  return Lhs.ShiftValue >= Rhs.ShiftValue;
293}
294inline bool operator<(Align Lhs, Align Rhs) {
295  return Lhs.ShiftValue < Rhs.ShiftValue;
296}
297inline bool operator>(Align Lhs, Align Rhs) {
298  return Lhs.ShiftValue > Rhs.ShiftValue;
299}
300 
301// Don't allow relational comparisons with MaybeAlign.
302bool operator<=(Align Lhs, MaybeAlign Rhs) = delete;
303bool operator>=(Align Lhs, MaybeAlign Rhs) = delete;
304bool operator<(Align Lhs, MaybeAlign Rhs) = delete;
305bool operator>(Align Lhs, MaybeAlign Rhs) = delete;
306 
307bool operator<=(MaybeAlign Lhs, Align Rhs) = delete;
308bool operator>=(MaybeAlign Lhs, Align Rhs) = delete;
309bool operator<(MaybeAlign Lhs, Align Rhs) = delete;
310bool operator>(MaybeAlign Lhs, Align Rhs) = delete;
311 
312bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
313bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
314bool operator<(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
315bool operator>(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
316 
317inline Align operator*(Align Lhs, uint64_t Rhs) {
318  assert(Rhs > 0 && "Rhs must be positive")((void)0);
319  return Align(Lhs.value() * Rhs);
320}
321 
322inline MaybeAlign operator*(MaybeAlign Lhs, uint64_t Rhs) {
323  assert(Rhs > 0 && "Rhs must be positive")((void)0);
324  return Lhs ? Lhs.getValue() * Rhs : MaybeAlign();
325}
326 
327inline Align operator/(Align Lhs, uint64_t Divisor) {
328  assert(llvm::isPowerOf2_64(Divisor) &&((void)0)
329         "Divisor must be positive and a power of 2")((void)0);
330  assert(Lhs != 1 && "Can't halve byte alignment")((void)0);
331  return Align(Lhs.value() / Divisor);
332}
333 
334inline MaybeAlign operator/(MaybeAlign Lhs, uint64_t Divisor) {
335  assert(llvm::isPowerOf2_64(Divisor) &&((void)0)
336         "Divisor must be positive and a power of 2")((void)0);
337  return Lhs ? Lhs.getValue() / Divisor : MaybeAlign();
338}
339 
340inline Align max(MaybeAlign Lhs, Align Rhs) {
341  return Lhs && *Lhs > Rhs ? *Lhs : Rhs;
342}
343 
344inline Align max(Align Lhs, MaybeAlign Rhs) {
345  return Rhs && *Rhs > Lhs ? *Rhs : Lhs;
346}
347 
348#ifndef NDEBUG1
349// For usage in LLVM_DEBUG macros.
350inline std::string DebugStr(const Align &A) {
351  return std::to_string(A.value());
352}
353// For usage in LLVM_DEBUG macros.
354inline std::string DebugStr(const MaybeAlign &MA) {
355  if (MA)
356    return std::to_string(MA->value());
357  return "None";
358}
359#endif // NDEBUG
360 
361#undef ALIGN_CHECK_ISPOSITIVE
362 
363} // namespace llvm
364 
365#endif // LLVM_SUPPORT_ALIGNMENT_H_