lib/CodeGen/MIRParser/MIRParser.cpp

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