contrib/llvm/lib/CodeGen/MIRParser/MIRParser.cpp

   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   yaml::Input In;
  54   StringRef Filename;
  55   LLVMContext &Context;
  56   SlotMapping IRSlots;
  57   /// Maps from register class names to register classes.
  58   Name2RegClassMap Names2RegClasses;
  59   /// Maps from register bank names to register banks.
  60   Name2RegBankMap Names2RegBanks;
  61   /// True when the MIR file doesn't have LLVM IR. Dummy IR functions are
  62   /// created and inserted into the given module when this is true.
  63   bool NoLLVMIR = false;
  64   /// True when a well formed MIR file does not contain any MIR/machine function
  65   /// parts.
  66   bool NoMIRDocuments = false;
  67
  68 public:
  69   MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
  70                 StringRef Filename, LLVMContext &Context);
  71
  72   void reportDiagnostic(const SMDiagnostic &Diag);
  73
  74   /// Report an error with the given message at unknown location.
  75   ///
  76   /// Always returns true.
  77   bool error(const Twine &Message);
  78
  79   /// Report an error with the given message at the given location.
  80   ///
  81   /// Always returns true.
  82   bool error(SMLoc Loc, const Twine &Message);
  83
  84   /// Report a given error with the location translated from the location in an
  85   /// embedded string literal to a location in the MIR file.
  86   ///
  87   /// Always returns true.
  88   bool error(const SMDiagnostic &Error, SMRange SourceRange);
  89
  90   /// Try to parse the optional LLVM module and the machine functions in the MIR
  91   /// file.
  92   ///
  93   /// Return null if an error occurred.
  94   std::unique_ptr<Module> parseIRModule();
  95
  96   bool parseMachineFunctions(Module &M, MachineModuleInfo &MMI);
  97
  98   /// Parse the machine function in the current YAML document.
  99   ///
 100   ///
 101   /// Return true if an error occurred.
 102   bool parseMachineFunction(Module &M, MachineModuleInfo &MMI);
 103
 104   /// Initialize the machine function to the state that's described in the MIR
 105   /// file.
 106   ///
 107   /// Return true if error occurred.
 108   bool initializeMachineFunction(const yaml::MachineFunction &YamlMF,
 109                                  MachineFunction &MF);
 110
 111   bool parseRegisterInfo(PerFunctionMIParsingState &PFS,
 112                          const yaml::MachineFunction &YamlMF);
 113
 114   bool setupRegisterInfo(const PerFunctionMIParsingState &PFS,
 115                          const yaml::MachineFunction &YamlMF);
 116
 117   bool initializeFrameInfo(PerFunctionMIParsingState &PFS,
 118                            const yaml::MachineFunction &YamlMF);
 119
 120   bool parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
 121                                 std::vector<CalleeSavedInfo> &CSIInfo,
 122                                 const yaml::StringValue &RegisterSource,
 123                                 bool IsRestored, int FrameIdx);
 124
 125   template <typename T>
 126   bool parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
 127                                   const T &Object,
 128                                   int FrameIdx);
 129
 130   bool initializeConstantPool(PerFunctionMIParsingState &PFS,
 131                               MachineConstantPool &ConstantPool,
 132                               const yaml::MachineFunction &YamlMF);
 133
 134   bool initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
 135                                const yaml::MachineJumpTable &YamlJTI);
 136
 137 private:
 138   bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node,
 139                    const yaml::StringValue &Source);
 140
 141   bool parseMBBReference(PerFunctionMIParsingState &PFS,
 142                          MachineBasicBlock *&MBB,
 143                          const yaml::StringValue &Source);
 144
 145   /// Return a MIR diagnostic converted from an MI string diagnostic.
 146   SMDiagnostic diagFromMIStringDiag(const SMDiagnostic &Error,
 147                                     SMRange SourceRange);
 148
 149   /// Return a MIR diagnostic converted from a diagnostic located in a YAML
 150   /// block scalar string.
 151   SMDiagnostic diagFromBlockStringDiag(const SMDiagnostic &Error,
 152                                        SMRange SourceRange);
 153
 154   void initNames2RegClasses(const MachineFunction &MF);
 155   void initNames2RegBanks(const MachineFunction &MF);
 156
 157   /// Check if the given identifier is a name of a register class.
 158   ///
 159   /// Return null if the name isn't a register class.
 160   const TargetRegisterClass *getRegClass(const MachineFunction &MF,
 161                                          StringRef Name);
 162
 163   /// Check if the given identifier is a name of a register bank.
 164   ///
 165   /// Return null if the name isn't a register bank.
 166   const RegisterBank *getRegBank(const MachineFunction &MF, StringRef Name);
 167
 168   void computeFunctionProperties(MachineFunction &MF);
 169 };
 170
 171 } // end namespace llvm
 172
 173 static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) {
 174   reinterpret_cast<MIRParserImpl *>(Context)->reportDiagnostic(Diag);
 175 }
 176
 177 MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
 178                              StringRef Filename, LLVMContext &Context)
 179     : SM(),
 180       In(SM.getMemoryBuffer(
 181             SM.AddNewSourceBuffer(std::move(Contents), SMLoc()))->getBuffer(),
 182             nullptr, handleYAMLDiag, this),
 183       Filename(Filename),
 184       Context(Context) {
 185   In.setContext(&In);
 186 }
 187
 188 bool MIRParserImpl::error(const Twine &Message) {
 189   Context.diagnose(DiagnosticInfoMIRParser(
 190       DS_Error, SMDiagnostic(Filename, SourceMgr::DK_Error, Message.str())));
 191   return true;
 192 }
 193
 194 bool MIRParserImpl::error(SMLoc Loc, const Twine &Message) {
 195   Context.diagnose(DiagnosticInfoMIRParser(
 196       DS_Error, SM.GetMessage(Loc, SourceMgr::DK_Error, Message)));
 197   return true;
 198 }
 199
 200 bool MIRParserImpl::error(const SMDiagnostic &Error, SMRange SourceRange) {
 201   assert(Error.getKind() == SourceMgr::DK_Error && "Expected an error");
 202   reportDiagnostic(diagFromMIStringDiag(Error, SourceRange));
 203   return true;
 204 }
 205
 206 void MIRParserImpl::reportDiagnostic(const SMDiagnostic &Diag) {
 207   DiagnosticSeverity Kind;
 208   switch (Diag.getKind()) {
 209   case SourceMgr::DK_Error:
 210     Kind = DS_Error;
 211     break;
 212   case SourceMgr::DK_Warning:
 213     Kind = DS_Warning;
 214     break;
 215   case SourceMgr::DK_Note:
 216     Kind = DS_Note;
 217     break;
 218   case SourceMgr::DK_Remark:
 219     llvm_unreachable("remark unexpected");
 220     break;
 221   }
 222   Context.diagnose(DiagnosticInfoMIRParser(Kind, Diag));
 223 }
 224
 225 std::unique_ptr<Module> MIRParserImpl::parseIRModule() {
 226   if (!In.setCurrentDocument()) {
 227     if (In.error())
 228       return nullptr;
 229     // Create an empty module when the MIR file is empty.
 230     NoMIRDocuments = true;
 231     return llvm::make_unique<Module>(Filename, Context);
 232   }
 233
 234   std::unique_ptr<Module> M;
 235   // Parse the block scalar manually so that we can return unique pointer
 236   // without having to go trough YAML traits.
 237   if (const auto *BSN =
 238           dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
 239     SMDiagnostic Error;
 240     M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
 241                       Context, &IRSlots, /*UpgradeDebugInfo=*/false);
 242     if (!M) {
 243       reportDiagnostic(diagFromBlockStringDiag(Error, BSN->getSourceRange()));
 244       return nullptr;
 245     }
 246     In.nextDocument();
 247     if (!In.setCurrentDocument())
 248       NoMIRDocuments = true;
 249   } else {
 250     // Create an new, empty module.
 251     M = llvm::make_unique<Module>(Filename, Context);
 252     NoLLVMIR = true;
 253   }
 254   return M;
 255 }
 256
 257 bool MIRParserImpl::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
 258   if (NoMIRDocuments)
 259     return false;
 260
 261   // Parse the machine functions.
 262   do {
 263     if (parseMachineFunction(M, MMI))
 264       return true;
 265     In.nextDocument();
 266   } while (In.setCurrentDocument());
 267
 268   return false;
 269 }
 270
 271 /// Create an empty function with the given name.
 272 static Function *createDummyFunction(StringRef Name, Module &M) {
 273   auto &Context = M.getContext();
 274   Function *F = cast<Function>(M.getOrInsertFunction(
 275       Name, FunctionType::get(Type::getVoidTy(Context), false)));
 276   BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
 277   new UnreachableInst(Context, BB);
 278   return F;
 279 }
 280
 281 bool MIRParserImpl::parseMachineFunction(Module &M, MachineModuleInfo &MMI) {
 282   // Parse the yaml.
 283   yaml::MachineFunction YamlMF;
 284   yaml::EmptyContext Ctx;
 285   yaml::yamlize(In, YamlMF, false, Ctx);
 286   if (In.error())
 287     return true;
 288
 289   // Search for the corresponding IR function.
 290   StringRef FunctionName = YamlMF.Name;
 291   Function *F = M.getFunction(FunctionName);
 292   if (!F) {
 293     if (NoLLVMIR) {
 294       F = createDummyFunction(FunctionName, M);
 295     } else {
 296       return error(Twine("function '") + FunctionName +
 297                    "' isn't defined in the provided LLVM IR");
 298     }
 299   }
 300   if (MMI.getMachineFunction(*F) != nullptr)
 301     return error(Twine("redefinition of machine function '") + FunctionName +
 302                  "'");
 303
 304   // Create the MachineFunction.
 305   MachineFunction &MF = MMI.getOrCreateMachineFunction(*F);
 306   if (initializeMachineFunction(YamlMF, MF))
 307     return true;
 308
 309   return false;
 310 }
 311
 312 static bool isSSA(const MachineFunction &MF) {
 313   const MachineRegisterInfo &MRI = MF.getRegInfo();
 314   for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
 315     unsigned Reg = TargetRegisterInfo::index2VirtReg(I);
 316     if (!MRI.hasOneDef(Reg) && !MRI.def_empty(Reg))
 317       return false;
 318   }
 319   return true;
 320 }
 321
 322 void MIRParserImpl::computeFunctionProperties(MachineFunction &MF) {
 323   MachineFunctionProperties &Properties = MF.getProperties();
 324
 325   bool HasPHI = false;
 326   bool HasInlineAsm = false;
 327   for (const MachineBasicBlock &MBB : MF) {
 328     for (const MachineInstr &MI : MBB) {
 329       if (MI.isPHI())
 330         HasPHI = true;
 331       if (MI.isInlineAsm())
 332         HasInlineAsm = true;
 333     }
 334   }
 335   if (!HasPHI)
 336     Properties.set(MachineFunctionProperties::Property::NoPHIs);
 337   MF.setHasInlineAsm(HasInlineAsm);
 338
 339   if (isSSA(MF))
 340     Properties.set(MachineFunctionProperties::Property::IsSSA);
 341   else
 342     Properties.reset(MachineFunctionProperties::Property::IsSSA);
 343
 344   const MachineRegisterInfo &MRI = MF.getRegInfo();
 345   if (MRI.getNumVirtRegs() == 0)
 346     Properties.set(MachineFunctionProperties::Property::NoVRegs);
 347 }
 348
 349 bool
 350 MIRParserImpl::initializeMachineFunction(const yaml::MachineFunction &YamlMF,
 351                                          MachineFunction &MF) {
 352   // TODO: Recreate the machine function.
 353   initNames2RegClasses(MF);
 354   initNames2RegBanks(MF);
 355   if (YamlMF.Alignment)
 356     MF.setAlignment(YamlMF.Alignment);
 357   MF.setExposesReturnsTwice(YamlMF.ExposesReturnsTwice);
 358
 359   if (YamlMF.Legalized)
 360     MF.getProperties().set(MachineFunctionProperties::Property::Legalized);
 361   if (YamlMF.RegBankSelected)
 362     MF.getProperties().set(
 363         MachineFunctionProperties::Property::RegBankSelected);
 364   if (YamlMF.Selected)
 365     MF.getProperties().set(MachineFunctionProperties::Property::Selected);
 366   if (YamlMF.FailedISel)
 367     MF.getProperties().set(MachineFunctionProperties::Property::FailedISel);
 368
 369   PerFunctionMIParsingState PFS(MF, SM, IRSlots, Names2RegClasses,
 370                                 Names2RegBanks);
 371   if (parseRegisterInfo(PFS, YamlMF))
 372     return true;
 373   if (!YamlMF.Constants.empty()) {
 374     auto *ConstantPool = MF.getConstantPool();
 375     assert(ConstantPool && "Constant pool must be created");
 376     if (initializeConstantPool(PFS, *ConstantPool, YamlMF))
 377       return true;
 378   }
 379
 380   StringRef BlockStr = YamlMF.Body.Value.Value;
 381   SMDiagnostic Error;
 382   SourceMgr BlockSM;
 383   BlockSM.AddNewSourceBuffer(
 384       MemoryBuffer::getMemBuffer(BlockStr, "",/*RequiresNullTerminator=*/false),
 385       SMLoc());
 386   PFS.SM = &BlockSM;
 387   if (parseMachineBasicBlockDefinitions(PFS, BlockStr, Error)) {
 388     reportDiagnostic(
 389         diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
 390     return true;
 391   }
 392   PFS.SM = &SM;
 393
 394   // Initialize the frame information after creating all the MBBs so that the
 395   // MBB references in the frame information can be resolved.
 396   if (initializeFrameInfo(PFS, YamlMF))
 397     return true;
 398   // Initialize the jump table after creating all the MBBs so that the MBB
 399   // references can be resolved.
 400   if (!YamlMF.JumpTableInfo.Entries.empty() &&
 401       initializeJumpTableInfo(PFS, YamlMF.JumpTableInfo))
 402     return true;
 403   // Parse the machine instructions after creating all of the MBBs so that the
 404   // parser can resolve the MBB references.
 405   StringRef InsnStr = YamlMF.Body.Value.Value;
 406   SourceMgr InsnSM;
 407   InsnSM.AddNewSourceBuffer(
 408       MemoryBuffer::getMemBuffer(InsnStr, "", /*RequiresNullTerminator=*/false),
 409       SMLoc());
 410   PFS.SM = &InsnSM;
 411   if (parseMachineInstructions(PFS, InsnStr, Error)) {
 412     reportDiagnostic(
 413         diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
 414     return true;
 415   }
 416   PFS.SM = &SM;
 417
 418   if (setupRegisterInfo(PFS, YamlMF))
 419     return true;
 420
 421   computeFunctionProperties(MF);
 422
 423   MF.getSubtarget().mirFileLoaded(MF);
 424
 425   MF.verify();
 426   return false;
 427 }
 428
 429 bool MIRParserImpl::parseRegisterInfo(PerFunctionMIParsingState &PFS,
 430                                       const yaml::MachineFunction &YamlMF) {
 431   MachineFunction &MF = PFS.MF;
 432   MachineRegisterInfo &RegInfo = MF.getRegInfo();
 433   assert(RegInfo.tracksLiveness());
 434   if (!YamlMF.TracksRegLiveness)
 435     RegInfo.invalidateLiveness();
 436
 437   SMDiagnostic Error;
 438   // Parse the virtual register information.
 439   for (const auto &VReg : YamlMF.VirtualRegisters) {
 440     VRegInfo &Info = PFS.getVRegInfo(VReg.ID.Value);
 441     if (Info.Explicit)
 442       return error(VReg.ID.SourceRange.Start,
 443                    Twine("redefinition of virtual register '%") +
 444                        Twine(VReg.ID.Value) + "'");
 445     Info.Explicit = true;
 446
 447     if (StringRef(VReg.Class.Value).equals("_")) {
 448       Info.Kind = VRegInfo::GENERIC;
 449       Info.D.RegBank = nullptr;
 450     } else {
 451       const auto *RC = getRegClass(MF, VReg.Class.Value);
 452       if (RC) {
 453         Info.Kind = VRegInfo::NORMAL;
 454         Info.D.RC = RC;
 455       } else {
 456         const RegisterBank *RegBank = getRegBank(MF, VReg.Class.Value);
 457         if (!RegBank)
 458           return error(
 459               VReg.Class.SourceRange.Start,
 460               Twine("use of undefined register class or register bank '") +
 461                   VReg.Class.Value + "'");
 462         Info.Kind = VRegInfo::REGBANK;
 463         Info.D.RegBank = RegBank;
 464       }
 465     }
 466
 467     if (!VReg.PreferredRegister.Value.empty()) {
 468       if (Info.Kind != VRegInfo::NORMAL)
 469         return error(VReg.Class.SourceRange.Start,
 470               Twine("preferred register can only be set for normal vregs"));
 471
 472       if (parseRegisterReference(PFS, Info.PreferredReg,
 473                                  VReg.PreferredRegister.Value, Error))
 474         return error(Error, VReg.PreferredRegister.SourceRange);
 475     }
 476   }
 477
 478   // Parse the liveins.
 479   for (const auto &LiveIn : YamlMF.LiveIns) {
 480     unsigned Reg = 0;
 481     if (parseNamedRegisterReference(PFS, Reg, LiveIn.Register.Value, Error))
 482       return error(Error, LiveIn.Register.SourceRange);
 483     unsigned VReg = 0;
 484     if (!LiveIn.VirtualRegister.Value.empty()) {
 485       VRegInfo *Info;
 486       if (parseVirtualRegisterReference(PFS, Info, LiveIn.VirtualRegister.Value,
 487                                         Error))
 488         return error(Error, LiveIn.VirtualRegister.SourceRange);
 489       VReg = Info->VReg;
 490     }
 491     RegInfo.addLiveIn(Reg, VReg);
 492   }
 493
 494   // Parse the callee saved registers (Registers that will
 495   // be saved for the caller).
 496   if (YamlMF.CalleeSavedRegisters) {
 497     SmallVector<MCPhysReg, 16> CalleeSavedRegisters;
 498     for (const auto &RegSource : YamlMF.CalleeSavedRegisters.getValue()) {
 499       unsigned Reg = 0;
 500       if (parseNamedRegisterReference(PFS, Reg, RegSource.Value, Error))
 501         return error(Error, RegSource.SourceRange);
 502       CalleeSavedRegisters.push_back(Reg);
 503     }
 504     RegInfo.setCalleeSavedRegs(CalleeSavedRegisters);
 505   }
 506
 507   return false;
 508 }
 509
 510 bool MIRParserImpl::setupRegisterInfo(const PerFunctionMIParsingState &PFS,
 511                                       const yaml::MachineFunction &YamlMF) {
 512   MachineFunction &MF = PFS.MF;
 513   MachineRegisterInfo &MRI = MF.getRegInfo();
 514   bool Error = false;
 515   // Create VRegs
 516   auto populateVRegInfo = [&] (const VRegInfo &Info, Twine Name) {
 517     unsigned Reg = Info.VReg;
 518     switch (Info.Kind) {
 519     case VRegInfo::UNKNOWN:
 520       error(Twine("Cannot determine class/bank of virtual register ") +
 521             Name + " in function '" + MF.getName() + "'");
 522       Error = true;
 523       break;
 524     case VRegInfo::NORMAL:
 525       MRI.setRegClass(Reg, Info.D.RC);
 526       if (Info.PreferredReg != 0)
 527         MRI.setSimpleHint(Reg, Info.PreferredReg);
 528       break;
 529     case VRegInfo::GENERIC:
 530       break;
 531     case VRegInfo::REGBANK:
 532       MRI.setRegBank(Reg, *Info.D.RegBank);
 533       break;
 534     }
 535   };
 536
 537   for (auto I = PFS.VRegInfosNamed.begin(), E = PFS.VRegInfosNamed.end();
 538        I != E; I++) {
 539     const VRegInfo &Info = *I->second;
 540     populateVRegInfo(Info, Twine(I->first()));
 541   }
 542
 543   for (auto P : PFS.VRegInfos) {
 544     const VRegInfo &Info = *P.second;
 545     populateVRegInfo(Info, Twine(P.first));
 546   }
 547
 548   // Compute MachineRegisterInfo::UsedPhysRegMask
 549   for (const MachineBasicBlock &MBB : MF) {
 550     for (const MachineInstr &MI : MBB) {
 551       for (const MachineOperand &MO : MI.operands()) {
 552         if (!MO.isRegMask())
 553           continue;
 554         MRI.addPhysRegsUsedFromRegMask(MO.getRegMask());
 555       }
 556     }
 557   }
 558
 559   // FIXME: This is a temporary workaround until the reserved registers can be
 560   // serialized.
 561   MRI.freezeReservedRegs(MF);
 562   return Error;
 563 }
 564
 565 bool MIRParserImpl::initializeFrameInfo(PerFunctionMIParsingState &PFS,
 566                                         const yaml::MachineFunction &YamlMF) {
 567   MachineFunction &MF = PFS.MF;
 568   MachineFrameInfo &MFI = MF.getFrameInfo();
 569   const Function &F = MF.getFunction();
 570   const yaml::MachineFrameInfo &YamlMFI = YamlMF.FrameInfo;
 571   MFI.setFrameAddressIsTaken(YamlMFI.IsFrameAddressTaken);
 572   MFI.setReturnAddressIsTaken(YamlMFI.IsReturnAddressTaken);
 573   MFI.setHasStackMap(YamlMFI.HasStackMap);
 574   MFI.setHasPatchPoint(YamlMFI.HasPatchPoint);
 575   MFI.setStackSize(YamlMFI.StackSize);
 576   MFI.setOffsetAdjustment(YamlMFI.OffsetAdjustment);
 577   if (YamlMFI.MaxAlignment)
 578     MFI.ensureMaxAlignment(YamlMFI.MaxAlignment);
 579   MFI.setAdjustsStack(YamlMFI.AdjustsStack);
 580   MFI.setHasCalls(YamlMFI.HasCalls);
 581   if (YamlMFI.MaxCallFrameSize != ~0u)
 582     MFI.setMaxCallFrameSize(YamlMFI.MaxCallFrameSize);
 583   MFI.setHasOpaqueSPAdjustment(YamlMFI.HasOpaqueSPAdjustment);
 584   MFI.setHasVAStart(YamlMFI.HasVAStart);
 585   MFI.setHasMustTailInVarArgFunc(YamlMFI.HasMustTailInVarArgFunc);
 586   MFI.setLocalFrameSize(YamlMFI.LocalFrameSize);
 587   if (!YamlMFI.SavePoint.Value.empty()) {
 588     MachineBasicBlock *MBB = nullptr;
 589     if (parseMBBReference(PFS, MBB, YamlMFI.SavePoint))
 590       return true;
 591     MFI.setSavePoint(MBB);
 592   }
 593   if (!YamlMFI.RestorePoint.Value.empty()) {
 594     MachineBasicBlock *MBB = nullptr;
 595     if (parseMBBReference(PFS, MBB, YamlMFI.RestorePoint))
 596       return true;
 597     MFI.setRestorePoint(MBB);
 598   }
 599
 600   std::vector<CalleeSavedInfo> CSIInfo;
 601   // Initialize the fixed frame objects.
 602   for (const auto &Object : YamlMF.FixedStackObjects) {
 603     int ObjectIdx;
 604     if (Object.Type != yaml::FixedMachineStackObject::SpillSlot)
 605       ObjectIdx = MFI.CreateFixedObject(Object.Size, Object.Offset,
 606                                         Object.IsImmutable, Object.IsAliased);
 607     else
 608       ObjectIdx = MFI.CreateFixedSpillStackObject(Object.Size, Object.Offset);
 609     MFI.setObjectAlignment(ObjectIdx, Object.Alignment);
 610     MFI.setStackID(ObjectIdx, Object.StackID);
 611     if (!PFS.FixedStackObjectSlots.insert(std::make_pair(Object.ID.Value,
 612                                                          ObjectIdx))
 613              .second)
 614       return error(Object.ID.SourceRange.Start,
 615                    Twine("redefinition of fixed stack object '%fixed-stack.") +
 616                        Twine(Object.ID.Value) + "'");
 617     if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
 618                                  Object.CalleeSavedRestored, ObjectIdx))
 619       return true;
 620     if (parseStackObjectsDebugInfo(PFS, Object, ObjectIdx))
 621       return true;
 622   }
 623
 624   // Initialize the ordinary frame objects.
 625   for (const auto &Object : YamlMF.StackObjects) {
 626     int ObjectIdx;
 627     const AllocaInst *Alloca = nullptr;
 628     const yaml::StringValue &Name = Object.Name;
 629     if (!Name.Value.empty()) {
 630       Alloca = dyn_cast_or_null<AllocaInst>(
 631           F.getValueSymbolTable()->lookup(Name.Value));
 632       if (!Alloca)
 633         return error(Name.SourceRange.Start,
 634                      "alloca instruction named '" + Name.Value +
 635                          "' isn't defined in the function '" + F.getName() +
 636                          "'");
 637     }
 638     if (Object.Type == yaml::MachineStackObject::VariableSized)
 639       ObjectIdx = MFI.CreateVariableSizedObject(Object.Alignment, Alloca);
 640     else
 641       ObjectIdx = MFI.CreateStackObject(
 642           Object.Size, Object.Alignment,
 643           Object.Type == yaml::MachineStackObject::SpillSlot, Alloca);
 644     MFI.setObjectOffset(ObjectIdx, Object.Offset);
 645     MFI.setStackID(ObjectIdx, Object.StackID);
 646
 647     if (!PFS.StackObjectSlots.insert(std::make_pair(Object.ID.Value, ObjectIdx))
 648              .second)
 649       return error(Object.ID.SourceRange.Start,
 650                    Twine("redefinition of stack object '%stack.") +
 651                        Twine(Object.ID.Value) + "'");
 652     if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
 653                                  Object.CalleeSavedRestored, ObjectIdx))
 654       return true;
 655     if (Object.LocalOffset)
 656       MFI.mapLocalFrameObject(ObjectIdx, Object.LocalOffset.getValue());
 657     if (parseStackObjectsDebugInfo(PFS, Object, ObjectIdx))
 658       return true;
 659   }
 660   MFI.setCalleeSavedInfo(CSIInfo);
 661   if (!CSIInfo.empty())
 662     MFI.setCalleeSavedInfoValid(true);
 663
 664   // Initialize the various stack object references after initializing the
 665   // stack objects.
 666   if (!YamlMFI.StackProtector.Value.empty()) {
 667     SMDiagnostic Error;
 668     int FI;
 669     if (parseStackObjectReference(PFS, FI, YamlMFI.StackProtector.Value, Error))
 670       return error(Error, YamlMFI.StackProtector.SourceRange);
 671     MFI.setStackProtectorIndex(FI);
 672   }
 673   return false;
 674 }
 675
 676 bool MIRParserImpl::parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
 677     std::vector<CalleeSavedInfo> &CSIInfo,
 678     const yaml::StringValue &RegisterSource, bool IsRestored, int FrameIdx) {
 679   if (RegisterSource.Value.empty())
 680     return false;
 681   unsigned Reg = 0;
 682   SMDiagnostic Error;
 683   if (parseNamedRegisterReference(PFS, Reg, RegisterSource.Value, Error))
 684     return error(Error, RegisterSource.SourceRange);
 685   CalleeSavedInfo CSI(Reg, FrameIdx);
 686   CSI.setRestored(IsRestored);
 687   CSIInfo.push_back(CSI);
 688   return false;
 689 }
 690
 691 /// Verify that given node is of a certain type. Return true on error.
 692 template <typename T>
 693 static bool typecheckMDNode(T *&Result, MDNode *Node,
 694                             const yaml::StringValue &Source,
 695                             StringRef TypeString, MIRParserImpl &Parser) {
 696   if (!Node)
 697     return false;
 698   Result = dyn_cast<T>(Node);
 699   if (!Result)
 700     return Parser.error(Source.SourceRange.Start,
 701                         "expected a reference to a '" + TypeString +
 702                             "' metadata node");
 703   return false;
 704 }
 705
 706 template <typename T>
 707 bool MIRParserImpl::parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
 708     const T &Object, int FrameIdx) {
 709   // Debug information can only be attached to stack objects; Fixed stack
 710   // objects aren't supported.
 711   MDNode *Var = nullptr, *Expr = nullptr, *Loc = nullptr;
 712   if (parseMDNode(PFS, Var, Object.DebugVar) ||
 713       parseMDNode(PFS, Expr, Object.DebugExpr) ||
 714       parseMDNode(PFS, Loc, Object.DebugLoc))
 715     return true;
 716   if (!Var && !Expr && !Loc)
 717     return false;
 718   DILocalVariable *DIVar = nullptr;
 719   DIExpression *DIExpr = nullptr;
 720   DILocation *DILoc = nullptr;
 721   if (typecheckMDNode(DIVar, Var, Object.DebugVar, "DILocalVariable", *this) ||
 722       typecheckMDNode(DIExpr, Expr, Object.DebugExpr, "DIExpression", *this) ||
 723       typecheckMDNode(DILoc, Loc, Object.DebugLoc, "DILocation", *this))
 724     return true;
 725   PFS.MF.setVariableDbgInfo(DIVar, DIExpr, FrameIdx, DILoc);
 726   return false;
 727 }
 728
 729 bool MIRParserImpl::parseMDNode(PerFunctionMIParsingState &PFS,
 730     MDNode *&Node, const yaml::StringValue &Source) {
 731   if (Source.Value.empty())
 732     return false;
 733   SMDiagnostic Error;
 734   if (llvm::parseMDNode(PFS, Node, Source.Value, Error))
 735     return error(Error, Source.SourceRange);
 736   return false;
 737 }
 738
 739 bool MIRParserImpl::initializeConstantPool(PerFunctionMIParsingState &PFS,
 740     MachineConstantPool &ConstantPool, const yaml::MachineFunction &YamlMF) {
 741   DenseMap<unsigned, unsigned> &ConstantPoolSlots = PFS.ConstantPoolSlots;
 742   const MachineFunction &MF = PFS.MF;
 743   const auto &M = *MF.getFunction().getParent();
 744   SMDiagnostic Error;
 745   for (const auto &YamlConstant : YamlMF.Constants) {
 746     if (YamlConstant.IsTargetSpecific)
 747       // FIXME: Support target-specific constant pools
 748       return error(YamlConstant.Value.SourceRange.Start,
 749                    "Can't parse target-specific constant pool entries yet");
 750     const Constant *Value = dyn_cast_or_null<Constant>(
 751         parseConstantValue(YamlConstant.Value.Value, Error, M));
 752     if (!Value)
 753       return error(Error, YamlConstant.Value.SourceRange);
 754     unsigned Alignment =
 755         YamlConstant.Alignment
 756             ? YamlConstant.Alignment
 757             : M.getDataLayout().getPrefTypeAlignment(Value->getType());
 758     unsigned Index = ConstantPool.getConstantPoolIndex(Value, Alignment);
 759     if (!ConstantPoolSlots.insert(std::make_pair(YamlConstant.ID.Value, Index))
 760              .second)
 761       return error(YamlConstant.ID.SourceRange.Start,
 762                    Twine("redefinition of constant pool item '%const.") +
 763                        Twine(YamlConstant.ID.Value) + "'");
 764   }
 765   return false;
 766 }
 767
 768 bool MIRParserImpl::initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
 769     const yaml::MachineJumpTable &YamlJTI) {
 770   MachineJumpTableInfo *JTI = PFS.MF.getOrCreateJumpTableInfo(YamlJTI.Kind);
 771   for (const auto &Entry : YamlJTI.Entries) {
 772     std::vector<MachineBasicBlock *> Blocks;
 773     for (const auto &MBBSource : Entry.Blocks) {
 774       MachineBasicBlock *MBB = nullptr;
 775       if (parseMBBReference(PFS, MBB, MBBSource.Value))
 776         return true;
 777       Blocks.push_back(MBB);
 778     }
 779     unsigned Index = JTI->createJumpTableIndex(Blocks);
 780     if (!PFS.JumpTableSlots.insert(std::make_pair(Entry.ID.Value, Index))
 781              .second)
 782       return error(Entry.ID.SourceRange.Start,
 783                    Twine("redefinition of jump table entry '%jump-table.") +
 784                        Twine(Entry.ID.Value) + "'");
 785   }
 786   return false;
 787 }
 788
 789 bool MIRParserImpl::parseMBBReference(PerFunctionMIParsingState &PFS,
 790                                       MachineBasicBlock *&MBB,
 791                                       const yaml::StringValue &Source) {
 792   SMDiagnostic Error;
 793   if (llvm::parseMBBReference(PFS, MBB, Source.Value, Error))
 794     return error(Error, Source.SourceRange);
 795   return false;
 796 }
 797
 798 SMDiagnostic MIRParserImpl::diagFromMIStringDiag(const SMDiagnostic &Error,
 799                                                  SMRange SourceRange) {
 800   assert(SourceRange.isValid() && "Invalid source range");
 801   SMLoc Loc = SourceRange.Start;
 802   bool HasQuote = Loc.getPointer() < SourceRange.End.getPointer() &&
 803                   *Loc.getPointer() == '\'';
 804   // Translate the location of the error from the location in the MI string to
 805   // the corresponding location in the MIR file.
 806   Loc = Loc.getFromPointer(Loc.getPointer() + Error.getColumnNo() +
 807                            (HasQuote ? 1 : 0));
 808
 809   // TODO: Translate any source ranges as well.
 810   return SM.GetMessage(Loc, Error.getKind(), Error.getMessage(), None,
 811                        Error.getFixIts());
 812 }
 813
 814 SMDiagnostic MIRParserImpl::diagFromBlockStringDiag(const SMDiagnostic &Error,
 815                                                     SMRange SourceRange) {
 816   assert(SourceRange.isValid());
 817
 818   // Translate the location of the error from the location in the llvm IR string
 819   // to the corresponding location in the MIR file.
 820   auto LineAndColumn = SM.getLineAndColumn(SourceRange.Start);
 821   unsigned Line = LineAndColumn.first + Error.getLineNo() - 1;
 822   unsigned Column = Error.getColumnNo();
 823   StringRef LineStr = Error.getLineContents();
 824   SMLoc Loc = Error.getLoc();
 825
 826   // Get the full line and adjust the column number by taking the indentation of
 827   // LLVM IR into account.
 828   for (line_iterator L(*SM.getMemoryBuffer(SM.getMainFileID()), false), E;
 829        L != E; ++L) {
 830     if (L.line_number() == Line) {
 831       LineStr = *L;
 832       Loc = SMLoc::getFromPointer(LineStr.data());
 833       auto Indent = LineStr.find(Error.getLineContents());
 834       if (Indent != StringRef::npos)
 835         Column += Indent;
 836       break;
 837     }
 838   }
 839
 840   return SMDiagnostic(SM, Loc, Filename, Line, Column, Error.getKind(),
 841                       Error.getMessage(), LineStr, Error.getRanges(),
 842                       Error.getFixIts());
 843 }
 844
 845 void MIRParserImpl::initNames2RegClasses(const MachineFunction &MF) {
 846   if (!Names2RegClasses.empty())
 847     return;
 848   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
 849   for (unsigned I = 0, E = TRI->getNumRegClasses(); I < E; ++I) {
 850     const auto *RC = TRI->getRegClass(I);
 851     Names2RegClasses.insert(
 852         std::make_pair(StringRef(TRI->getRegClassName(RC)).lower(), RC));
 853   }
 854 }
 855
 856 void MIRParserImpl::initNames2RegBanks(const MachineFunction &MF) {
 857   if (!Names2RegBanks.empty())
 858     return;
 859   const RegisterBankInfo *RBI = MF.getSubtarget().getRegBankInfo();
 860   // If the target does not support GlobalISel, we may not have a
 861   // register bank info.
 862   if (!RBI)
 863     return;
 864   for (unsigned I = 0, E = RBI->getNumRegBanks(); I < E; ++I) {
 865     const auto &RegBank = RBI->getRegBank(I);
 866     Names2RegBanks.insert(
 867         std::make_pair(StringRef(RegBank.getName()).lower(), &RegBank));
 868   }
 869 }
 870
 871 const TargetRegisterClass *MIRParserImpl::getRegClass(const MachineFunction &MF,
 872                                                       StringRef Name) {
 873   auto RegClassInfo = Names2RegClasses.find(Name);
 874   if (RegClassInfo == Names2RegClasses.end())
 875     return nullptr;
 876   return RegClassInfo->getValue();
 877 }
 878
 879 const RegisterBank *MIRParserImpl::getRegBank(const MachineFunction &MF,
 880                                               StringRef Name) {
 881   auto RegBankInfo = Names2RegBanks.find(Name);
 882   if (RegBankInfo == Names2RegBanks.end())
 883     return nullptr;
 884   return RegBankInfo->getValue();
 885 }
 886
 887 MIRParser::MIRParser(std::unique_ptr<MIRParserImpl> Impl)
 888     : Impl(std::move(Impl)) {}
 889
 890 MIRParser::~MIRParser() {}
 891
 892 std::unique_ptr<Module> MIRParser::parseIRModule() {
 893   return Impl->parseIRModule();
 894 }
 895
 896 bool MIRParser::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
 897   return Impl->parseMachineFunctions(M, MMI);
 898 }
 899
 900 std::unique_ptr<MIRParser> llvm::createMIRParserFromFile(StringRef Filename,
 901                                                          SMDiagnostic &Error,
 902                                                          LLVMContext &Context) {
 903   auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
 904   if (std::error_code EC = FileOrErr.getError()) {
 905     Error = SMDiagnostic(Filename, SourceMgr::DK_Error,
 906                          "Could not open input file: " + EC.message());
 907     return nullptr;
 908   }
 909   return createMIRParser(std::move(FileOrErr.get()), Context);
 910 }
 911
 912 std::unique_ptr<MIRParser>
 913 llvm::createMIRParser(std::unique_ptr<MemoryBuffer> Contents,
 914                       LLVMContext &Context) {
 915   auto Filename = Contents->getBufferIdentifier();
 916   if (Context.shouldDiscardValueNames()) {
 917     Context.diagnose(DiagnosticInfoMIRParser(
 918         DS_Error,
 919         SMDiagnostic(
 920             Filename, SourceMgr::DK_Error,
 921             "Can't read MIR with a Context that discards named Values")));
 922     return nullptr;
 923   }
 924   return llvm::make_unique<MIRParser>(
 925       llvm::make_unique<MIRParserImpl>(std::move(Contents), Filename, Context));
 926 }