Home | History | Annotate | Download | only in MIRParser
      1 //===- MIRParser.cpp - MIR serialization format parser implementation -----===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file implements the class that parses the optional LLVM IR and machine
     11 // functions that are stored in MIR files.
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #include "llvm/CodeGen/MIRParser/MIRParser.h"
     16 #include "MIParser.h"
     17 #include "llvm/ADT/DenseMap.h"
     18 #include "llvm/ADT/STLExtras.h"
     19 #include "llvm/ADT/StringMap.h"
     20 #include "llvm/ADT/StringRef.h"
     21 #include "llvm/AsmParser/Parser.h"
     22 #include "llvm/AsmParser/SlotMapping.h"
     23 #include "llvm/CodeGen/GlobalISel/RegisterBank.h"
     24 #include "llvm/CodeGen/GlobalISel/RegisterBankInfo.h"
     25 #include "llvm/CodeGen/MIRYamlMapping.h"
     26 #include "llvm/CodeGen/MachineConstantPool.h"
     27 #include "llvm/CodeGen/MachineFrameInfo.h"
     28 #include "llvm/CodeGen/MachineFunction.h"
     29 #include "llvm/CodeGen/MachineModuleInfo.h"
     30 #include "llvm/CodeGen/MachineRegisterInfo.h"
     31 #include "llvm/IR/BasicBlock.h"
     32 #include "llvm/IR/DebugInfo.h"
     33 #include "llvm/IR/DiagnosticInfo.h"
     34 #include "llvm/IR/Instructions.h"
     35 #include "llvm/IR/LLVMContext.h"
     36 #include "llvm/IR/Module.h"
     37 #include "llvm/IR/ValueSymbolTable.h"
     38 #include "llvm/Support/LineIterator.h"
     39 #include "llvm/Support/MemoryBuffer.h"
     40 #include "llvm/Support/SMLoc.h"
     41 #include "llvm/Support/SourceMgr.h"
     42 #include "llvm/Support/YAMLTraits.h"
     43 #include <memory>
     44 
     45 using namespace llvm;
     46 
     47 namespace llvm {
     48 
     49 /// This class implements the parsing of LLVM IR that's embedded inside a MIR
     50 /// file.
     51 class MIRParserImpl {
     52   SourceMgr SM;
     53   StringRef Filename;
     54   LLVMContext &Context;
     55   StringMap<std::unique_ptr<yaml::MachineFunction>> Functions;
     56   SlotMapping IRSlots;
     57   /// Maps from register class names to register classes.
     58   StringMap<const TargetRegisterClass *> Names2RegClasses;
     59   /// Maps from register bank names to register banks.
     60   StringMap<const RegisterBank *> Names2RegBanks;
     61 
     62 public:
     63   MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents, StringRef Filename,
     64                 LLVMContext &Context);
     65 
     66   void reportDiagnostic(const SMDiagnostic &Diag);
     67 
     68   /// Report an error with the given message at unknown location.
     69   ///
     70   /// Always returns true.
     71   bool error(const Twine &Message);
     72 
     73   /// Report an error with the given message at the given location.
     74   ///
     75   /// Always returns true.
     76   bool error(SMLoc Loc, const Twine &Message);
     77 
     78   /// Report a given error with the location translated from the location in an
     79   /// embedded string literal to a location in the MIR file.
     80   ///
     81   /// Always returns true.
     82   bool error(const SMDiagnostic &Error, SMRange SourceRange);
     83 
     84   /// Try to parse the optional LLVM module and the machine functions in the MIR
     85   /// file.
     86   ///
     87   /// Return null if an error occurred.
     88   std::unique_ptr<Module> parse();
     89 
     90   /// Parse the machine function in the current YAML document.
     91   ///
     92   /// \param NoLLVMIR - set to true when the MIR file doesn't have LLVM IR.
     93   /// A dummy IR function is created and inserted into the given module when
     94   /// this parameter is true.
     95   ///
     96   /// Return true if an error occurred.
     97   bool parseMachineFunction(yaml::Input &In, Module &M, bool NoLLVMIR);
     98 
     99   /// Initialize the machine function to the state that's described in the MIR
    100   /// file.
    101   ///
    102   /// Return true if error occurred.
    103   bool initializeMachineFunction(MachineFunction &MF);
    104 
    105   bool initializeRegisterInfo(PerFunctionMIParsingState &PFS,
    106                               const yaml::MachineFunction &YamlMF);
    107 
    108   void inferRegisterInfo(const PerFunctionMIParsingState &PFS,
    109                          const yaml::MachineFunction &YamlMF);
    110 
    111   bool initializeFrameInfo(PerFunctionMIParsingState &PFS,
    112                            const yaml::MachineFunction &YamlMF);
    113 
    114   bool parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
    115                                 std::vector<CalleeSavedInfo> &CSIInfo,
    116                                 const yaml::StringValue &RegisterSource,
    117                                 int FrameIdx);
    118 
    119   bool parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
    120                                   const yaml::MachineStackObject &Object,
    121                                   int FrameIdx);
    122 
    123   bool initializeConstantPool(PerFunctionMIParsingState &PFS,
    124                               MachineConstantPool &ConstantPool,
    125                               const yaml::MachineFunction &YamlMF);
    126 
    127   bool initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
    128                                const yaml::MachineJumpTable &YamlJTI);
    129 
    130 private:
    131   bool parseMDNode(const PerFunctionMIParsingState &PFS, MDNode *&Node,
    132                    const yaml::StringValue &Source);
    133 
    134   bool parseMBBReference(const PerFunctionMIParsingState &PFS,
    135                          MachineBasicBlock *&MBB,
    136                          const yaml::StringValue &Source);
    137 
    138   /// Return a MIR diagnostic converted from an MI string diagnostic.
    139   SMDiagnostic diagFromMIStringDiag(const SMDiagnostic &Error,
    140                                     SMRange SourceRange);
    141 
    142   /// Return a MIR diagnostic converted from a diagnostic located in a YAML
    143   /// block scalar string.
    144   SMDiagnostic diagFromBlockStringDiag(const SMDiagnostic &Error,
    145                                        SMRange SourceRange);
    146 
    147   /// Create an empty function with the given name.
    148   void createDummyFunction(StringRef Name, Module &M);
    149 
    150   void initNames2RegClasses(const MachineFunction &MF);
    151   void initNames2RegBanks(const MachineFunction &MF);
    152 
    153   /// Check if the given identifier is a name of a register class.
    154   ///
    155   /// Return null if the name isn't a register class.
    156   const TargetRegisterClass *getRegClass(const MachineFunction &MF,
    157                                          StringRef Name);
    158 
    159   /// Check if the given identifier is a name of a register bank.
    160   ///
    161   /// Return null if the name isn't a register bank.
    162   const RegisterBank *getRegBank(const MachineFunction &MF, StringRef Name);
    163 };
    164 
    165 } // end namespace llvm
    166 
    167 MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
    168                              StringRef Filename, LLVMContext &Context)
    169     : SM(), Filename(Filename), Context(Context) {
    170   SM.AddNewSourceBuffer(std::move(Contents), SMLoc());
    171 }
    172 
    173 bool MIRParserImpl::error(const Twine &Message) {
    174   Context.diagnose(DiagnosticInfoMIRParser(
    175       DS_Error, SMDiagnostic(Filename, SourceMgr::DK_Error, Message.str())));
    176   return true;
    177 }
    178 
    179 bool MIRParserImpl::error(SMLoc Loc, const Twine &Message) {
    180   Context.diagnose(DiagnosticInfoMIRParser(
    181       DS_Error, SM.GetMessage(Loc, SourceMgr::DK_Error, Message)));
    182   return true;
    183 }
    184 
    185 bool MIRParserImpl::error(const SMDiagnostic &Error, SMRange SourceRange) {
    186   assert(Error.getKind() == SourceMgr::DK_Error && "Expected an error");
    187   reportDiagnostic(diagFromMIStringDiag(Error, SourceRange));
    188   return true;
    189 }
    190 
    191 void MIRParserImpl::reportDiagnostic(const SMDiagnostic &Diag) {
    192   DiagnosticSeverity Kind;
    193   switch (Diag.getKind()) {
    194   case SourceMgr::DK_Error:
    195     Kind = DS_Error;
    196     break;
    197   case SourceMgr::DK_Warning:
    198     Kind = DS_Warning;
    199     break;
    200   case SourceMgr::DK_Note:
    201     Kind = DS_Note;
    202     break;
    203   }
    204   Context.diagnose(DiagnosticInfoMIRParser(Kind, Diag));
    205 }
    206 
    207 static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) {
    208   reinterpret_cast<MIRParserImpl *>(Context)->reportDiagnostic(Diag);
    209 }
    210 
    211 std::unique_ptr<Module> MIRParserImpl::parse() {
    212   yaml::Input In(SM.getMemoryBuffer(SM.getMainFileID())->getBuffer(),
    213                  /*Ctxt=*/nullptr, handleYAMLDiag, this);
    214   In.setContext(&In);
    215 
    216   if (!In.setCurrentDocument()) {
    217     if (In.error())
    218       return nullptr;
    219     // Create an empty module when the MIR file is empty.
    220     return llvm::make_unique<Module>(Filename, Context);
    221   }
    222 
    223   std::unique_ptr<Module> M;
    224   bool NoLLVMIR = false;
    225   // Parse the block scalar manually so that we can return unique pointer
    226   // without having to go trough YAML traits.
    227   if (const auto *BSN =
    228           dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
    229     SMDiagnostic Error;
    230     M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
    231                       Context, &IRSlots);
    232     if (!M) {
    233       reportDiagnostic(diagFromBlockStringDiag(Error, BSN->getSourceRange()));
    234       return nullptr;
    235     }
    236     In.nextDocument();
    237     if (!In.setCurrentDocument())
    238       return M;
    239   } else {
    240     // Create an new, empty module.
    241     M = llvm::make_unique<Module>(Filename, Context);
    242     NoLLVMIR = true;
    243   }
    244 
    245   // Parse the machine functions.
    246   do {
    247     if (parseMachineFunction(In, *M, NoLLVMIR))
    248       return nullptr;
    249     In.nextDocument();
    250   } while (In.setCurrentDocument());
    251 
    252   return M;
    253 }
    254 
    255 bool MIRParserImpl::parseMachineFunction(yaml::Input &In, Module &M,
    256                                          bool NoLLVMIR) {
    257   auto MF = llvm::make_unique<yaml::MachineFunction>();
    258   yaml::yamlize(In, *MF, false);
    259   if (In.error())
    260     return true;
    261   auto FunctionName = MF->Name;
    262   if (Functions.find(FunctionName) != Functions.end())
    263     return error(Twine("redefinition of machine function '") + FunctionName +
    264                  "'");
    265   Functions.insert(std::make_pair(FunctionName, std::move(MF)));
    266   if (NoLLVMIR)
    267     createDummyFunction(FunctionName, M);
    268   else if (!M.getFunction(FunctionName))
    269     return error(Twine("function '") + FunctionName +
    270                  "' isn't defined in the provided LLVM IR");
    271   return false;
    272 }
    273 
    274 void MIRParserImpl::createDummyFunction(StringRef Name, Module &M) {
    275   auto &Context = M.getContext();
    276   Function *F = cast<Function>(M.getOrInsertFunction(
    277       Name, FunctionType::get(Type::getVoidTy(Context), false)));
    278   BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
    279   new UnreachableInst(Context, BB);
    280 }
    281 
    282 bool MIRParserImpl::initializeMachineFunction(MachineFunction &MF) {
    283   auto It = Functions.find(MF.getName());
    284   if (It == Functions.end())
    285     return error(Twine("no machine function information for function '") +
    286                  MF.getName() + "' in the MIR file");
    287   // TODO: Recreate the machine function.
    288   const yaml::MachineFunction &YamlMF = *It->getValue();
    289   if (YamlMF.Alignment)
    290     MF.setAlignment(YamlMF.Alignment);
    291   MF.setExposesReturnsTwice(YamlMF.ExposesReturnsTwice);
    292   MF.setHasInlineAsm(YamlMF.HasInlineAsm);
    293   if (YamlMF.AllVRegsAllocated)
    294     MF.getProperties().set(MachineFunctionProperties::Property::AllVRegsAllocated);
    295   PerFunctionMIParsingState PFS(MF, SM, IRSlots);
    296   if (initializeRegisterInfo(PFS, YamlMF))
    297     return true;
    298   if (!YamlMF.Constants.empty()) {
    299     auto *ConstantPool = MF.getConstantPool();
    300     assert(ConstantPool && "Constant pool must be created");
    301     if (initializeConstantPool(PFS, *ConstantPool, YamlMF))
    302       return true;
    303   }
    304 
    305   StringRef BlockStr = YamlMF.Body.Value.Value;
    306   SMDiagnostic Error;
    307   SourceMgr BlockSM;
    308   BlockSM.AddNewSourceBuffer(
    309       MemoryBuffer::getMemBuffer(BlockStr, "",/*RequiresNullTerminator=*/false),
    310       SMLoc());
    311   PFS.SM = &BlockSM;
    312   if (parseMachineBasicBlockDefinitions(PFS, BlockStr, Error)) {
    313     reportDiagnostic(
    314         diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
    315     return true;
    316   }
    317   PFS.SM = &SM;
    318 
    319   if (MF.empty())
    320     return error(Twine("machine function '") + Twine(MF.getName()) +
    321                  "' requires at least one machine basic block in its body");
    322   // Initialize the frame information after creating all the MBBs so that the
    323   // MBB references in the frame information can be resolved.
    324   if (initializeFrameInfo(PFS, YamlMF))
    325     return true;
    326   // Initialize the jump table after creating all the MBBs so that the MBB
    327   // references can be resolved.
    328   if (!YamlMF.JumpTableInfo.Entries.empty() &&
    329       initializeJumpTableInfo(PFS, YamlMF.JumpTableInfo))
    330     return true;
    331   // Parse the machine instructions after creating all of the MBBs so that the
    332   // parser can resolve the MBB references.
    333   StringRef InsnStr = YamlMF.Body.Value.Value;
    334   SourceMgr InsnSM;
    335   InsnSM.AddNewSourceBuffer(
    336       MemoryBuffer::getMemBuffer(InsnStr, "", /*RequiresNullTerminator=*/false),
    337       SMLoc());
    338   PFS.SM = &InsnSM;
    339   if (parseMachineInstructions(PFS, InsnStr, Error)) {
    340     reportDiagnostic(
    341         diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
    342     return true;
    343   }
    344   PFS.SM = &SM;
    345 
    346   inferRegisterInfo(PFS, YamlMF);
    347   // FIXME: This is a temporary workaround until the reserved registers can be
    348   // serialized.
    349   MF.getRegInfo().freezeReservedRegs(MF);
    350   MF.verify();
    351   return false;
    352 }
    353 
    354 bool MIRParserImpl::initializeRegisterInfo(PerFunctionMIParsingState &PFS,
    355     const yaml::MachineFunction &YamlMF) {
    356   MachineFunction &MF = PFS.MF;
    357   MachineRegisterInfo &RegInfo = MF.getRegInfo();
    358   assert(RegInfo.isSSA());
    359   if (!YamlMF.IsSSA)
    360     RegInfo.leaveSSA();
    361   assert(RegInfo.tracksLiveness());
    362   if (!YamlMF.TracksRegLiveness)
    363     RegInfo.invalidateLiveness();
    364   RegInfo.enableSubRegLiveness(YamlMF.TracksSubRegLiveness);
    365 
    366   SMDiagnostic Error;
    367   // Parse the virtual register information.
    368   for (const auto &VReg : YamlMF.VirtualRegisters) {
    369     unsigned Reg;
    370     if (StringRef(VReg.Class.Value).equals("_")) {
    371       // This is a generic virtual register.
    372       // The size will be set appropriately when we reach the definition.
    373       Reg = RegInfo.createGenericVirtualRegister(/*Size*/ 1);
    374       PFS.GenericVRegs.insert(Reg);
    375     } else {
    376       const auto *RC = getRegClass(MF, VReg.Class.Value);
    377       if (RC) {
    378         Reg = RegInfo.createVirtualRegister(RC);
    379       } else {
    380         const auto *RegBank = getRegBank(MF, VReg.Class.Value);
    381         if (!RegBank)
    382           return error(
    383               VReg.Class.SourceRange.Start,
    384               Twine("use of undefined register class or register bank '") +
    385                   VReg.Class.Value + "'");
    386         Reg = RegInfo.createGenericVirtualRegister(/*Size*/ 1);
    387         RegInfo.setRegBank(Reg, *RegBank);
    388         PFS.GenericVRegs.insert(Reg);
    389       }
    390     }
    391     if (!PFS.VirtualRegisterSlots.insert(std::make_pair(VReg.ID.Value, Reg))
    392              .second)
    393       return error(VReg.ID.SourceRange.Start,
    394                    Twine("redefinition of virtual register '%") +
    395                        Twine(VReg.ID.Value) + "'");
    396     if (!VReg.PreferredRegister.Value.empty()) {
    397       unsigned PreferredReg = 0;
    398       if (parseNamedRegisterReference(PFS, PreferredReg,
    399                                       VReg.PreferredRegister.Value, Error))
    400         return error(Error, VReg.PreferredRegister.SourceRange);
    401       RegInfo.setSimpleHint(Reg, PreferredReg);
    402     }
    403   }
    404 
    405   // Parse the liveins.
    406   for (const auto &LiveIn : YamlMF.LiveIns) {
    407     unsigned Reg = 0;
    408     if (parseNamedRegisterReference(PFS, Reg, LiveIn.Register.Value, Error))
    409       return error(Error, LiveIn.Register.SourceRange);
    410     unsigned VReg = 0;
    411     if (!LiveIn.VirtualRegister.Value.empty()) {
    412       if (parseVirtualRegisterReference(PFS, VReg, LiveIn.VirtualRegister.Value,
    413                                         Error))
    414         return error(Error, LiveIn.VirtualRegister.SourceRange);
    415     }
    416     RegInfo.addLiveIn(Reg, VReg);
    417   }
    418 
    419   // Parse the callee saved register mask.
    420   BitVector CalleeSavedRegisterMask(RegInfo.getUsedPhysRegsMask().size());
    421   if (!YamlMF.CalleeSavedRegisters)
    422     return false;
    423   for (const auto &RegSource : YamlMF.CalleeSavedRegisters.getValue()) {
    424     unsigned Reg = 0;
    425     if (parseNamedRegisterReference(PFS, Reg, RegSource.Value, Error))
    426       return error(Error, RegSource.SourceRange);
    427     CalleeSavedRegisterMask[Reg] = true;
    428   }
    429   RegInfo.setUsedPhysRegMask(CalleeSavedRegisterMask.flip());
    430   return false;
    431 }
    432 
    433 void MIRParserImpl::inferRegisterInfo(const PerFunctionMIParsingState &PFS,
    434                                       const yaml::MachineFunction &YamlMF) {
    435   if (YamlMF.CalleeSavedRegisters)
    436     return;
    437   MachineRegisterInfo &MRI = PFS.MF.getRegInfo();
    438   for (const MachineBasicBlock &MBB : PFS.MF) {
    439     for (const MachineInstr &MI : MBB) {
    440       for (const MachineOperand &MO : MI.operands()) {
    441         if (!MO.isRegMask())
    442           continue;
    443         MRI.addPhysRegsUsedFromRegMask(MO.getRegMask());
    444       }
    445     }
    446   }
    447 }
    448 
    449 bool MIRParserImpl::initializeFrameInfo(PerFunctionMIParsingState &PFS,
    450                                         const yaml::MachineFunction &YamlMF) {
    451   MachineFunction &MF = PFS.MF;
    452   MachineFrameInfo &MFI = *MF.getFrameInfo();
    453   const Function &F = *MF.getFunction();
    454   const yaml::MachineFrameInfo &YamlMFI = YamlMF.FrameInfo;
    455   MFI.setFrameAddressIsTaken(YamlMFI.IsFrameAddressTaken);
    456   MFI.setReturnAddressIsTaken(YamlMFI.IsReturnAddressTaken);
    457   MFI.setHasStackMap(YamlMFI.HasStackMap);
    458   MFI.setHasPatchPoint(YamlMFI.HasPatchPoint);
    459   MFI.setStackSize(YamlMFI.StackSize);
    460   MFI.setOffsetAdjustment(YamlMFI.OffsetAdjustment);
    461   if (YamlMFI.MaxAlignment)
    462     MFI.ensureMaxAlignment(YamlMFI.MaxAlignment);
    463   MFI.setAdjustsStack(YamlMFI.AdjustsStack);
    464   MFI.setHasCalls(YamlMFI.HasCalls);
    465   MFI.setMaxCallFrameSize(YamlMFI.MaxCallFrameSize);
    466   MFI.setHasOpaqueSPAdjustment(YamlMFI.HasOpaqueSPAdjustment);
    467   MFI.setHasVAStart(YamlMFI.HasVAStart);
    468   MFI.setHasMustTailInVarArgFunc(YamlMFI.HasMustTailInVarArgFunc);
    469   if (!YamlMFI.SavePoint.Value.empty()) {
    470     MachineBasicBlock *MBB = nullptr;
    471     if (parseMBBReference(PFS, MBB, YamlMFI.SavePoint))
    472       return true;
    473     MFI.setSavePoint(MBB);
    474   }
    475   if (!YamlMFI.RestorePoint.Value.empty()) {
    476     MachineBasicBlock *MBB = nullptr;
    477     if (parseMBBReference(PFS, MBB, YamlMFI.RestorePoint))
    478       return true;
    479     MFI.setRestorePoint(MBB);
    480   }
    481 
    482   std::vector<CalleeSavedInfo> CSIInfo;
    483   // Initialize the fixed frame objects.
    484   for (const auto &Object : YamlMF.FixedStackObjects) {
    485     int ObjectIdx;
    486     if (Object.Type != yaml::FixedMachineStackObject::SpillSlot)
    487       ObjectIdx = MFI.CreateFixedObject(Object.Size, Object.Offset,
    488                                         Object.IsImmutable, Object.IsAliased);
    489     else
    490       ObjectIdx = MFI.CreateFixedSpillStackObject(Object.Size, Object.Offset);
    491     MFI.setObjectAlignment(ObjectIdx, Object.Alignment);
    492     if (!PFS.FixedStackObjectSlots.insert(std::make_pair(Object.ID.Value,
    493                                                          ObjectIdx))
    494              .second)
    495       return error(Object.ID.SourceRange.Start,
    496                    Twine("redefinition of fixed stack object '%fixed-stack.") +
    497                        Twine(Object.ID.Value) + "'");
    498     if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
    499                                  ObjectIdx))
    500       return true;
    501   }
    502 
    503   // Initialize the ordinary frame objects.
    504   for (const auto &Object : YamlMF.StackObjects) {
    505     int ObjectIdx;
    506     const AllocaInst *Alloca = nullptr;
    507     const yaml::StringValue &Name = Object.Name;
    508     if (!Name.Value.empty()) {
    509       Alloca = dyn_cast_or_null<AllocaInst>(
    510           F.getValueSymbolTable().lookup(Name.Value));
    511       if (!Alloca)
    512         return error(Name.SourceRange.Start,
    513                      "alloca instruction named '" + Name.Value +
    514                          "' isn't defined in the function '" + F.getName() +
    515                          "'");
    516     }
    517     if (Object.Type == yaml::MachineStackObject::VariableSized)
    518       ObjectIdx = MFI.CreateVariableSizedObject(Object.Alignment, Alloca);
    519     else
    520       ObjectIdx = MFI.CreateStackObject(
    521           Object.Size, Object.Alignment,
    522           Object.Type == yaml::MachineStackObject::SpillSlot, Alloca);
    523     MFI.setObjectOffset(ObjectIdx, Object.Offset);
    524     if (!PFS.StackObjectSlots.insert(std::make_pair(Object.ID.Value, ObjectIdx))
    525              .second)
    526       return error(Object.ID.SourceRange.Start,
    527                    Twine("redefinition of stack object '%stack.") +
    528                        Twine(Object.ID.Value) + "'");
    529     if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
    530                                  ObjectIdx))
    531       return true;
    532     if (Object.LocalOffset)
    533       MFI.mapLocalFrameObject(ObjectIdx, Object.LocalOffset.getValue());
    534     if (parseStackObjectsDebugInfo(PFS, Object, ObjectIdx))
    535       return true;
    536   }
    537   MFI.setCalleeSavedInfo(CSIInfo);
    538   if (!CSIInfo.empty())
    539     MFI.setCalleeSavedInfoValid(true);
    540 
    541   // Initialize the various stack object references after initializing the
    542   // stack objects.
    543   if (!YamlMFI.StackProtector.Value.empty()) {
    544     SMDiagnostic Error;
    545     int FI;
    546     if (parseStackObjectReference(PFS, FI, YamlMFI.StackProtector.Value, Error))
    547       return error(Error, YamlMFI.StackProtector.SourceRange);
    548     MFI.setStackProtectorIndex(FI);
    549   }
    550   return false;
    551 }
    552 
    553 bool MIRParserImpl::parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
    554     std::vector<CalleeSavedInfo> &CSIInfo,
    555     const yaml::StringValue &RegisterSource, int FrameIdx) {
    556   if (RegisterSource.Value.empty())
    557     return false;
    558   unsigned Reg = 0;
    559   SMDiagnostic Error;
    560   if (parseNamedRegisterReference(PFS, Reg, RegisterSource.Value, Error))
    561     return error(Error, RegisterSource.SourceRange);
    562   CSIInfo.push_back(CalleeSavedInfo(Reg, FrameIdx));
    563   return false;
    564 }
    565 
    566 /// Verify that given node is of a certain type. Return true on error.
    567 template <typename T>
    568 static bool typecheckMDNode(T *&Result, MDNode *Node,
    569                             const yaml::StringValue &Source,
    570                             StringRef TypeString, MIRParserImpl &Parser) {
    571   if (!Node)
    572     return false;
    573   Result = dyn_cast<T>(Node);
    574   if (!Result)
    575     return Parser.error(Source.SourceRange.Start,
    576                         "expected a reference to a '" + TypeString +
    577                             "' metadata node");
    578   return false;
    579 }
    580 
    581 bool MIRParserImpl::parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
    582     const yaml::MachineStackObject &Object, int FrameIdx) {
    583   // Debug information can only be attached to stack objects; Fixed stack
    584   // objects aren't supported.
    585   assert(FrameIdx >= 0 && "Expected a stack object frame index");
    586   MDNode *Var = nullptr, *Expr = nullptr, *Loc = nullptr;
    587   if (parseMDNode(PFS, Var, Object.DebugVar) ||
    588       parseMDNode(PFS, Expr, Object.DebugExpr) ||
    589       parseMDNode(PFS, Loc, Object.DebugLoc))
    590     return true;
    591   if (!Var && !Expr && !Loc)
    592     return false;
    593   DILocalVariable *DIVar = nullptr;
    594   DIExpression *DIExpr = nullptr;
    595   DILocation *DILoc = nullptr;
    596   if (typecheckMDNode(DIVar, Var, Object.DebugVar, "DILocalVariable", *this) ||
    597       typecheckMDNode(DIExpr, Expr, Object.DebugExpr, "DIExpression", *this) ||
    598       typecheckMDNode(DILoc, Loc, Object.DebugLoc, "DILocation", *this))
    599     return true;
    600   PFS.MF.getMMI().setVariableDbgInfo(DIVar, DIExpr, unsigned(FrameIdx), DILoc);
    601   return false;
    602 }
    603 
    604 bool MIRParserImpl::parseMDNode(const PerFunctionMIParsingState &PFS,
    605     MDNode *&Node, const yaml::StringValue &Source) {
    606   if (Source.Value.empty())
    607     return false;
    608   SMDiagnostic Error;
    609   if (llvm::parseMDNode(PFS, Node, Source.Value, Error))
    610     return error(Error, Source.SourceRange);
    611   return false;
    612 }
    613 
    614 bool MIRParserImpl::initializeConstantPool(PerFunctionMIParsingState &PFS,
    615     MachineConstantPool &ConstantPool, const yaml::MachineFunction &YamlMF) {
    616   DenseMap<unsigned, unsigned> &ConstantPoolSlots = PFS.ConstantPoolSlots;
    617   const MachineFunction &MF = PFS.MF;
    618   const auto &M = *MF.getFunction()->getParent();
    619   SMDiagnostic Error;
    620   for (const auto &YamlConstant : YamlMF.Constants) {
    621     const Constant *Value = dyn_cast_or_null<Constant>(
    622         parseConstantValue(YamlConstant.Value.Value, Error, M));
    623     if (!Value)
    624       return error(Error, YamlConstant.Value.SourceRange);
    625     unsigned Alignment =
    626         YamlConstant.Alignment
    627             ? YamlConstant.Alignment
    628             : M.getDataLayout().getPrefTypeAlignment(Value->getType());
    629     unsigned Index = ConstantPool.getConstantPoolIndex(Value, Alignment);
    630     if (!ConstantPoolSlots.insert(std::make_pair(YamlConstant.ID.Value, Index))
    631              .second)
    632       return error(YamlConstant.ID.SourceRange.Start,
    633                    Twine("redefinition of constant pool item '%const.") +
    634                        Twine(YamlConstant.ID.Value) + "'");
    635   }
    636   return false;
    637 }
    638 
    639 bool MIRParserImpl::initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
    640     const yaml::MachineJumpTable &YamlJTI) {
    641   MachineJumpTableInfo *JTI = PFS.MF.getOrCreateJumpTableInfo(YamlJTI.Kind);
    642   for (const auto &Entry : YamlJTI.Entries) {
    643     std::vector<MachineBasicBlock *> Blocks;
    644     for (const auto &MBBSource : Entry.Blocks) {
    645       MachineBasicBlock *MBB = nullptr;
    646       if (parseMBBReference(PFS, MBB, MBBSource.Value))
    647         return true;
    648       Blocks.push_back(MBB);
    649     }
    650     unsigned Index = JTI->createJumpTableIndex(Blocks);
    651     if (!PFS.JumpTableSlots.insert(std::make_pair(Entry.ID.Value, Index))
    652              .second)
    653       return error(Entry.ID.SourceRange.Start,
    654                    Twine("redefinition of jump table entry '%jump-table.") +
    655                        Twine(Entry.ID.Value) + "'");
    656   }
    657   return false;
    658 }
    659 
    660 bool MIRParserImpl::parseMBBReference(const PerFunctionMIParsingState &PFS,
    661                                       MachineBasicBlock *&MBB,
    662                                       const yaml::StringValue &Source) {
    663   SMDiagnostic Error;
    664   if (llvm::parseMBBReference(PFS, MBB, Source.Value, Error))
    665     return error(Error, Source.SourceRange);
    666   return false;
    667 }
    668 
    669 SMDiagnostic MIRParserImpl::diagFromMIStringDiag(const SMDiagnostic &Error,
    670                                                  SMRange SourceRange) {
    671   assert(SourceRange.isValid() && "Invalid source range");
    672   SMLoc Loc = SourceRange.Start;
    673   bool HasQuote = Loc.getPointer() < SourceRange.End.getPointer() &&
    674                   *Loc.getPointer() == '\'';
    675   // Translate the location of the error from the location in the MI string to
    676   // the corresponding location in the MIR file.
    677   Loc = Loc.getFromPointer(Loc.getPointer() + Error.getColumnNo() +
    678                            (HasQuote ? 1 : 0));
    679 
    680   // TODO: Translate any source ranges as well.
    681   return SM.GetMessage(Loc, Error.getKind(), Error.getMessage(), None,
    682                        Error.getFixIts());
    683 }
    684 
    685 SMDiagnostic MIRParserImpl::diagFromBlockStringDiag(const SMDiagnostic &Error,
    686                                                     SMRange SourceRange) {
    687   assert(SourceRange.isValid());
    688 
    689   // Translate the location of the error from the location in the llvm IR string
    690   // to the corresponding location in the MIR file.
    691   auto LineAndColumn = SM.getLineAndColumn(SourceRange.Start);
    692   unsigned Line = LineAndColumn.first + Error.getLineNo() - 1;
    693   unsigned Column = Error.getColumnNo();
    694   StringRef LineStr = Error.getLineContents();
    695   SMLoc Loc = Error.getLoc();
    696 
    697   // Get the full line and adjust the column number by taking the indentation of
    698   // LLVM IR into account.
    699   for (line_iterator L(*SM.getMemoryBuffer(SM.getMainFileID()), false), E;
    700        L != E; ++L) {
    701     if (L.line_number() == Line) {
    702       LineStr = *L;
    703       Loc = SMLoc::getFromPointer(LineStr.data());
    704       auto Indent = LineStr.find(Error.getLineContents());
    705       if (Indent != StringRef::npos)
    706         Column += Indent;
    707       break;
    708     }
    709   }
    710 
    711   return SMDiagnostic(SM, Loc, Filename, Line, Column, Error.getKind(),
    712                       Error.getMessage(), LineStr, Error.getRanges(),
    713                       Error.getFixIts());
    714 }
    715 
    716 void MIRParserImpl::initNames2RegClasses(const MachineFunction &MF) {
    717   if (!Names2RegClasses.empty())
    718     return;
    719   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
    720   for (unsigned I = 0, E = TRI->getNumRegClasses(); I < E; ++I) {
    721     const auto *RC = TRI->getRegClass(I);
    722     Names2RegClasses.insert(
    723         std::make_pair(StringRef(TRI->getRegClassName(RC)).lower(), RC));
    724   }
    725 }
    726 
    727 void MIRParserImpl::initNames2RegBanks(const MachineFunction &MF) {
    728   if (!Names2RegBanks.empty())
    729     return;
    730   const RegisterBankInfo *RBI = MF.getSubtarget().getRegBankInfo();
    731   // If the target does not support GlobalISel, we may not have a
    732   // register bank info.
    733   if (!RBI)
    734     return;
    735   for (unsigned I = 0, E = RBI->getNumRegBanks(); I < E; ++I) {
    736     const auto &RegBank = RBI->getRegBank(I);
    737     Names2RegBanks.insert(
    738         std::make_pair(StringRef(RegBank.getName()).lower(), &RegBank));
    739   }
    740 }
    741 
    742 const TargetRegisterClass *MIRParserImpl::getRegClass(const MachineFunction &MF,
    743                                                       StringRef Name) {
    744   initNames2RegClasses(MF);
    745   auto RegClassInfo = Names2RegClasses.find(Name);
    746   if (RegClassInfo == Names2RegClasses.end())
    747     return nullptr;
    748   return RegClassInfo->getValue();
    749 }
    750 
    751 const RegisterBank *MIRParserImpl::getRegBank(const MachineFunction &MF,
    752                                               StringRef Name) {
    753   initNames2RegBanks(MF);
    754   auto RegBankInfo = Names2RegBanks.find(Name);
    755   if (RegBankInfo == Names2RegBanks.end())
    756     return nullptr;
    757   return RegBankInfo->getValue();
    758 }
    759 
    760 MIRParser::MIRParser(std::unique_ptr<MIRParserImpl> Impl)
    761     : Impl(std::move(Impl)) {}
    762 
    763 MIRParser::~MIRParser() {}
    764 
    765 std::unique_ptr<Module> MIRParser::parseLLVMModule() { return Impl->parse(); }
    766 
    767 bool MIRParser::initializeMachineFunction(MachineFunction &MF) {
    768   return Impl->initializeMachineFunction(MF);
    769 }
    770 
    771 std::unique_ptr<MIRParser> llvm::createMIRParserFromFile(StringRef Filename,
    772                                                          SMDiagnostic &Error,
    773                                                          LLVMContext &Context) {
    774   auto FileOrErr = MemoryBuffer::getFile(Filename);
    775   if (std::error_code EC = FileOrErr.getError()) {
    776     Error = SMDiagnostic(Filename, SourceMgr::DK_Error,
    777                          "Could not open input file: " + EC.message());
    778     return nullptr;
    779   }
    780   return createMIRParser(std::move(FileOrErr.get()), Context);
    781 }
    782 
    783 std::unique_ptr<MIRParser>
    784 llvm::createMIRParser(std::unique_ptr<MemoryBuffer> Contents,
    785                       LLVMContext &Context) {
    786   auto Filename = Contents->getBufferIdentifier();
    787   return llvm::make_unique<MIRParser>(
    788       llvm::make_unique<MIRParserImpl>(std::move(Contents), Filename, Context));
    789 }
    790