llvm/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 "llvm/ADT/DenseMap.h"
  16 #include "llvm/ADT/StringMap.h"
  17 #include "llvm/ADT/StringRef.h"
  18 #include "llvm/AsmParser/Parser.h"
  19 #include "llvm/AsmParser/SlotMapping.h"
  20 #include "llvm/CodeGen/MIRParser/MIParser.h"
  21 #include "llvm/CodeGen/MIRYamlMapping.h"
  22 #include "llvm/CodeGen/MachineConstantPool.h"
  23 #include "llvm/CodeGen/MachineFrameInfo.h"
  24 #include "llvm/CodeGen/MachineFunction.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26 #include "llvm/CodeGen/MachineRegisterInfo.h"
  27 #include "llvm/CodeGen/TargetFrameLowering.h"
  28 #include "llvm/IR/BasicBlock.h"
  29 #include "llvm/IR/DebugInfoMetadata.h"
  30 #include "llvm/IR/DiagnosticInfo.h"
  31 #include "llvm/IR/Instructions.h"
  32 #include "llvm/IR/LLVMContext.h"
  33 #include "llvm/IR/Module.h"
  34 #include "llvm/IR/ValueSymbolTable.h"
  35 #include "llvm/Support/LineIterator.h"
  36 #include "llvm/Support/MemoryBuffer.h"
  37 #include "llvm/Support/SMLoc.h"
  38 #include "llvm/Support/SourceMgr.h"
  39 #include "llvm/Support/YAMLTraits.h"
  40 #include "llvm/Target/TargetMachine.h"
  41 #include <memory>
  42
  43 using namespace llvm;
  44
  45 namespace llvm {
  46 class MDNode;
  47 class RegisterBank;
  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   LLVMContext &Context;
  54   yaml::Input In;
  55   StringRef Filename;
  56   SlotMapping IRSlots;
  57   std::unique_ptr<PerTargetMIParsingState> Target;
  58
  59   /// True when the MIR file doesn't have LLVM IR. Dummy IR functions are
  60   /// created and inserted into the given module when this is true.
  61   bool NoLLVMIR = false;
  62   /// True when a well formed MIR file does not contain any MIR/machine function
  63   /// parts.
  64   bool NoMIRDocuments = false;
  65
  66   std::function<void(Function &)> ProcessIRFunction;
  67
  68 public:
  69   MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents, StringRef Filename,
  70                 LLVMContext &Context,
  71                 std::function<void(Function &)> ProcessIRFunction);
  72
  73   void reportDiagnostic(const SMDiagnostic &Diag);
  74
  75   /// Report an error with the given message at unknown location.
  76   ///
  77   /// Always returns true.
  78   bool error(const Twine &Message);
  79
  80   /// Report an error with the given message at the given location.
  81   ///
  82   /// Always returns true.
  83   bool error(SMLoc Loc, const Twine &Message);
  84
  85   /// Report a given error with the location translated from the location in an
  86   /// embedded string literal to a location in the MIR file.
  87   ///
  88   /// Always returns true.
  89   bool error(const SMDiagnostic &Error, SMRange SourceRange);
  90
  91   /// Try to parse the optional LLVM module and the machine functions in the MIR
  92   /// file.
  93   ///
  94   /// Return null if an error occurred.
  95   std::unique_ptr<Module>
  96   parseIRModule(DataLayoutCallbackTy DataLayoutCallback);
  97
  98   /// Create an empty function with the given name.
  99   Function *createDummyFunction(StringRef Name, Module &M);
 100
 101   bool parseMachineFunctions(Module &M, MachineModuleInfo &MMI);
 102
 103   /// Parse the machine function in the current YAML document.
 104   ///
 105   ///
 106   /// Return true if an error occurred.
 107   bool parseMachineFunction(Module &M, MachineModuleInfo &MMI);
 108
 109   /// Initialize the machine function to the state that's described in the MIR
 110   /// file.
 111   ///
 112   /// Return true if error occurred.
 113   bool initializeMachineFunction(const yaml::MachineFunction &YamlMF,
 114                                  MachineFunction &MF);
 115
 116   bool parseRegisterInfo(PerFunctionMIParsingState &PFS,
 117                          const yaml::MachineFunction &YamlMF);
 118
 119   bool setupRegisterInfo(const PerFunctionMIParsingState &PFS,
 120                          const yaml::MachineFunction &YamlMF);
 121
 122   bool initializeFrameInfo(PerFunctionMIParsingState &PFS,
 123                            const yaml::MachineFunction &YamlMF);
 124
 125   bool initializeCallSiteInfo(PerFunctionMIParsingState &PFS,
 126                               const yaml::MachineFunction &YamlMF);
 127
 128   bool parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
 129                                 std::vector<CalleeSavedInfo> &CSIInfo,
 130                                 const yaml::StringValue &RegisterSource,
 131                                 bool IsRestored, int FrameIdx);
 132
 133   template <typename T>
 134   bool parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
 135                                   const T &Object,
 136                                   int FrameIdx);
 137
 138   bool initializeConstantPool(PerFunctionMIParsingState &PFS,
 139                               MachineConstantPool &ConstantPool,
 140                               const yaml::MachineFunction &YamlMF);
 141
 142   bool initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
 143                                const yaml::MachineJumpTable &YamlJTI);
 144
 145   bool parseMachineMetadataNodes(PerFunctionMIParsingState &PFS,
 146                                  MachineFunction &MF,
 147                                  const yaml::MachineFunction &YMF);
 148
 149 private:
 150   bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node,
 151                    const yaml::StringValue &Source);
 152
 153   bool parseMBBReference(PerFunctionMIParsingState &PFS,
 154                          MachineBasicBlock *&MBB,
 155                          const yaml::StringValue &Source);
 156
 157   bool parseMachineMetadata(PerFunctionMIParsingState &PFS,
 158                             const yaml::StringValue &Source);
 159
 160   /// Return a MIR diagnostic converted from an MI string diagnostic.
 161   SMDiagnostic diagFromMIStringDiag(const SMDiagnostic &Error,
 162                                     SMRange SourceRange);
 163
 164   /// Return a MIR diagnostic converted from a diagnostic located in a YAML
 165   /// block scalar string.
 166   SMDiagnostic diagFromBlockStringDiag(const SMDiagnostic &Error,
 167                                        SMRange SourceRange);
 168
 169   void computeFunctionProperties(MachineFunction &MF);
 170
 171   void setupDebugValueTracking(MachineFunction &MF,
 172     PerFunctionMIParsingState &PFS, const yaml::MachineFunction &YamlMF);
 173 };
 174
 175 } // end namespace llvm
 176
 177 static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) {
 178   reinterpret_cast<MIRParserImpl *>(Context)->reportDiagnostic(Diag);
 179 }
 180
 181 MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
 182                              StringRef Filename, LLVMContext &Context,
 183                              std::function<void(Function &)> Callback)
 184     : Context(Context),
 185       In(SM.getMemoryBuffer(SM.AddNewSourceBuffer(std::move(Contents), SMLoc()))
 186              ->getBuffer(),
 187          nullptr, handleYAMLDiag, this),
 188       Filename(Filename), ProcessIRFunction(Callback) {
 189   In.setContext(&In);
 190 }
 191
 192 bool MIRParserImpl::error(const Twine &Message) {
 193   Context.diagnose(DiagnosticInfoMIRParser(
 194       DS_Error, SMDiagnostic(Filename, SourceMgr::DK_Error, Message.str())));
 195   return true;
 196 }
 197
 198 bool MIRParserImpl::error(SMLoc Loc, const Twine &Message) {
 199   Context.diagnose(DiagnosticInfoMIRParser(
 200       DS_Error, SM.GetMessage(Loc, SourceMgr::DK_Error, Message)));
 201   return true;
 202 }
 203
 204 bool MIRParserImpl::error(const SMDiagnostic &Error, SMRange SourceRange) {
 205   assert(Error.getKind() == SourceMgr::DK_Error && "Expected an error");
 206   reportDiagnostic(diagFromMIStringDiag(Error, SourceRange));
 207   return true;
 208 }
 209
 210 void MIRParserImpl::reportDiagnostic(const SMDiagnostic &Diag) {
 211   DiagnosticSeverity Kind;
 212   switch (Diag.getKind()) {
 213   case SourceMgr::DK_Error:
 214     Kind = DS_Error;
 215     break;
 216   case SourceMgr::DK_Warning:
 217     Kind = DS_Warning;
 218     break;
 219   case SourceMgr::DK_Note:
 220     Kind = DS_Note;
 221     break;
 222   case SourceMgr::DK_Remark:
 223     llvm_unreachable("remark unexpected");
 224     break;
 225   }
 226   Context.diagnose(DiagnosticInfoMIRParser(Kind, Diag));
 227 }
 228
 229 std::unique_ptr<Module>
 230 MIRParserImpl::parseIRModule(DataLayoutCallbackTy DataLayoutCallback) {
 231   if (!In.setCurrentDocument()) {
 232     if (In.error())
 233       return nullptr;
 234     // Create an empty module when the MIR file is empty.
 235     NoMIRDocuments = true;
 236     auto M = std::make_unique<Module>(Filename, Context);
 237     if (auto LayoutOverride = DataLayoutCallback(M->getTargetTriple()))
 238       M->setDataLayout(*LayoutOverride);
 239     return M;
 240   }
 241
 242   std::unique_ptr<Module> M;
 243   // Parse the block scalar manually so that we can return unique pointer
 244   // without having to go trough YAML traits.
 245   if (const auto *BSN =
 246           dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
 247     SMDiagnostic Error;
 248     M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
 249                       Context, &IRSlots, DataLayoutCallback);
 250     if (!M) {
 251       reportDiagnostic(diagFromBlockStringDiag(Error, BSN->getSourceRange()));
 252       return nullptr;
 253     }
 254     In.nextDocument();
 255     if (!In.setCurrentDocument())
 256       NoMIRDocuments = true;
 257   } else {
 258     // Create an new, empty module.
 259     M = std::make_unique<Module>(Filename, Context);
 260     if (auto LayoutOverride = DataLayoutCallback(M->getTargetTriple()))
 261       M->setDataLayout(*LayoutOverride);
 262     NoLLVMIR = true;
 263   }
 264   return M;
 265 }
 266
 267 bool MIRParserImpl::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
 268   if (NoMIRDocuments)
 269     return false;
 270
 271   // Parse the machine functions.
 272   do {
 273     if (parseMachineFunction(M, MMI))
 274       return true;
 275     In.nextDocument();
 276   } while (In.setCurrentDocument());
 277
 278   return false;
 279 }
 280
 281 Function *MIRParserImpl::createDummyFunction(StringRef Name, Module &M) {
 282   auto &Context = M.getContext();
 283   Function *F =
 284       Function::Create(FunctionType::get(Type::getVoidTy(Context), false),
 285                        Function::ExternalLinkage, Name, M);
 286   BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
 287   new UnreachableInst(Context, BB);
 288
 289   if (ProcessIRFunction)
 290     ProcessIRFunction(*F);
 291
 292   return F;
 293 }
 294
 295 bool MIRParserImpl::parseMachineFunction(Module &M, MachineModuleInfo &MMI) {
 296   // Parse the yaml.
 297   yaml::MachineFunction YamlMF;
 298   yaml::EmptyContext Ctx;
 299
 300   const LLVMTargetMachine &TM = MMI.getTarget();
 301   YamlMF.MachineFuncInfo = std::unique_ptr<yaml::MachineFunctionInfo>(
 302       TM.createDefaultFuncInfoYAML());
 303
 304   yaml::yamlize(In, YamlMF, false, Ctx);
 305   if (In.error())
 306     return true;
 307
 308   // Search for the corresponding IR function.
 309   StringRef FunctionName = YamlMF.Name;
 310   Function *F = M.getFunction(FunctionName);
 311   if (!F) {
 312     if (NoLLVMIR) {
 313       F = createDummyFunction(FunctionName, M);
 314     } else {
 315       return error(Twine("function '") + FunctionName +
 316                    "' isn't defined in the provided LLVM IR");
 317     }
 318   }
 319   if (MMI.getMachineFunction(*F) != nullptr)
 320     return error(Twine("redefinition of machine function '") + FunctionName +
 321                  "'");
 322
 323   // Create the MachineFunction.
 324   MachineFunction &MF = MMI.getOrCreateMachineFunction(*F);
 325   if (initializeMachineFunction(YamlMF, MF))
 326     return true;
 327
 328   return false;
 329 }
 330
 331 static bool isSSA(const MachineFunction &MF) {
 332   const MachineRegisterInfo &MRI = MF.getRegInfo();
 333   for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
 334     Register Reg = Register::index2VirtReg(I);
 335     if (!MRI.hasOneDef(Reg) && !MRI.def_empty(Reg))
 336       return false;
 337
 338     // Subregister defs are invalid in SSA.
 339     const MachineOperand *RegDef = MRI.getOneDef(Reg);
 340     if (RegDef && RegDef->getSubReg() != 0)
 341       return false;
 342   }
 343   return true;
 344 }
 345
 346 void MIRParserImpl::computeFunctionProperties(MachineFunction &MF) {
 347   MachineFunctionProperties &Properties = MF.getProperties();
 348
 349   bool HasPHI = false;
 350   bool HasInlineAsm = false;
 351   bool AllTiedOpsRewritten = true, HasTiedOps = false;
 352   for (const MachineBasicBlock &MBB : MF) {
 353     for (const MachineInstr &MI : MBB) {
 354       if (MI.isPHI())
 355         HasPHI = true;
 356       if (MI.isInlineAsm())
 357         HasInlineAsm = true;
 358       for (unsigned I = 0; I < MI.getNumOperands(); ++I) {
 359         const MachineOperand &MO = MI.getOperand(I);
 360         if (!MO.isReg() || !MO.getReg())
 361           continue;
 362         unsigned DefIdx;
 363         if (MO.isUse() && MI.isRegTiedToDefOperand(I, &DefIdx)) {
 364           HasTiedOps = true;
 365           if (MO.getReg() != MI.getOperand(DefIdx).getReg())
 366             AllTiedOpsRewritten = false;
 367         }
 368       }
 369     }
 370   }
 371   if (!HasPHI)
 372     Properties.set(MachineFunctionProperties::Property::NoPHIs);
 373   MF.setHasInlineAsm(HasInlineAsm);
 374
 375   if (HasTiedOps && AllTiedOpsRewritten)
 376     Properties.set(MachineFunctionProperties::Property::TiedOpsRewritten);
 377
 378   if (isSSA(MF))
 379     Properties.set(MachineFunctionProperties::Property::IsSSA);
 380   else
 381     Properties.reset(MachineFunctionProperties::Property::IsSSA);
 382
 383   const MachineRegisterInfo &MRI = MF.getRegInfo();
 384   if (MRI.getNumVirtRegs() == 0)
 385     Properties.set(MachineFunctionProperties::Property::NoVRegs);
 386 }
 387
 388 bool MIRParserImpl::initializeCallSiteInfo(
 389     PerFunctionMIParsingState &PFS, const yaml::MachineFunction &YamlMF) {
 390   MachineFunction &MF = PFS.MF;
 391   SMDiagnostic Error;
 392   const LLVMTargetMachine &TM = MF.getTarget();
 393   for (auto YamlCSInfo : YamlMF.CallSitesInfo) {
 394     yaml::CallSiteInfo::MachineInstrLoc MILoc = YamlCSInfo.CallLocation;
 395     if (MILoc.BlockNum >= MF.size())
 396       return error(Twine(MF.getName()) +
 397                    Twine(" call instruction block out of range.") +
 398                    " Unable to reference bb:" + Twine(MILoc.BlockNum));
 399     auto CallB = std::next(MF.begin(), MILoc.BlockNum);
 400     if (MILoc.Offset >= CallB->size())
 401       return error(Twine(MF.getName()) +
 402                    Twine(" call instruction offset out of range.") +
 403                    " Unable to reference instruction at bb: " +
 404                    Twine(MILoc.BlockNum) + " at offset:" + Twine(MILoc.Offset));
 405     auto CallI = std::next(CallB->instr_begin(), MILoc.Offset);
 406     if (!CallI->isCall(MachineInstr::IgnoreBundle))
 407       return error(Twine(MF.getName()) +
 408                    Twine(" call site info should reference call "
 409                          "instruction. Instruction at bb:") +
 410                    Twine(MILoc.BlockNum) + " at offset:" + Twine(MILoc.Offset) +
 411                    " is not a call instruction");
 412     MachineFunction::CallSiteInfo CSInfo;
 413     for (auto ArgRegPair : YamlCSInfo.ArgForwardingRegs) {
 414       Register Reg;
 415       if (parseNamedRegisterReference(PFS, Reg, ArgRegPair.Reg.Value, Error))
 416         return error(Error, ArgRegPair.Reg.SourceRange);
 417       CSInfo.emplace_back(Reg, ArgRegPair.ArgNo);
 418     }
 419
 420     if (TM.Options.EmitCallSiteInfo)
 421       MF.addCallArgsForwardingRegs(&*CallI, std::move(CSInfo));
 422   }
 423
 424   if (YamlMF.CallSitesInfo.size() && !TM.Options.EmitCallSiteInfo)
 425     return error(Twine("Call site info provided but not used"));
 426   return false;
 427 }
 428
 429 void MIRParserImpl::setupDebugValueTracking(
 430     MachineFunction &MF, PerFunctionMIParsingState &PFS,
 431     const yaml::MachineFunction &YamlMF) {
 432   // Compute the value of the "next instruction number" field.
 433   unsigned MaxInstrNum = 0;
 434   for (auto &MBB : MF)
 435     for (auto &MI : MBB)
 436       MaxInstrNum = std::max((unsigned)MI.peekDebugInstrNum(), MaxInstrNum);
 437   MF.setDebugInstrNumberingCount(MaxInstrNum);
 438
 439   // Load any substitutions.
 440   for (const auto &Sub : YamlMF.DebugValueSubstitutions) {
 441     MF.makeDebugValueSubstitution({Sub.SrcInst, Sub.SrcOp},
 442                                   {Sub.DstInst, Sub.DstOp}, Sub.Subreg);
 443   }
 444 }
 445
 446 bool
 447 MIRParserImpl::initializeMachineFunction(const yaml::MachineFunction &YamlMF,
 448                                          MachineFunction &MF) {
 449   // TODO: Recreate the machine function.
 450   if (Target) {
 451     // Avoid clearing state if we're using the same subtarget again.
 452     Target->setTarget(MF.getSubtarget());
 453   } else {
 454     Target.reset(new PerTargetMIParsingState(MF.getSubtarget()));
 455   }
 456
 457   MF.setAlignment(YamlMF.Alignment.valueOrOne());
 458   MF.setExposesReturnsTwice(YamlMF.ExposesReturnsTwice);
 459   MF.setHasWinCFI(YamlMF.HasWinCFI);
 460
 461   MF.setCallsEHReturn(YamlMF.CallsEHReturn);
 462   MF.setCallsUnwindInit(YamlMF.CallsUnwindInit);
 463   MF.setHasEHCatchret(YamlMF.HasEHCatchret);
 464   MF.setHasEHScopes(YamlMF.HasEHScopes);
 465   MF.setHasEHFunclets(YamlMF.HasEHFunclets);
 466
 467   if (YamlMF.Legalized)
 468     MF.getProperties().set(MachineFunctionProperties::Property::Legalized);
 469   if (YamlMF.RegBankSelected)
 470     MF.getProperties().set(
 471         MachineFunctionProperties::Property::RegBankSelected);
 472   if (YamlMF.Selected)
 473     MF.getProperties().set(MachineFunctionProperties::Property::Selected);
 474   if (YamlMF.FailedISel)
 475     MF.getProperties().set(MachineFunctionProperties::Property::FailedISel);
 476   if (YamlMF.FailsVerification)
 477     MF.getProperties().set(
 478         MachineFunctionProperties::Property::FailsVerification);
 479   if (YamlMF.TracksDebugUserValues)
 480     MF.getProperties().set(
 481         MachineFunctionProperties::Property::TracksDebugUserValues);
 482
 483   PerFunctionMIParsingState PFS(MF, SM, IRSlots, *Target);
 484   if (parseRegisterInfo(PFS, YamlMF))
 485     return true;
 486   if (!YamlMF.Constants.empty()) {
 487     auto *ConstantPool = MF.getConstantPool();
 488     assert(ConstantPool && "Constant pool must be created");
 489     if (initializeConstantPool(PFS, *ConstantPool, YamlMF))
 490       return true;
 491   }
 492   if (!YamlMF.MachineMetadataNodes.empty() &&
 493       parseMachineMetadataNodes(PFS, MF, YamlMF))
 494     return true;
 495
 496   StringRef BlockStr = YamlMF.Body.Value.Value;
 497   SMDiagnostic Error;
 498   SourceMgr BlockSM;
 499   BlockSM.AddNewSourceBuffer(
 500       MemoryBuffer::getMemBuffer(BlockStr, "",/*RequiresNullTerminator=*/false),
 501       SMLoc());
 502   PFS.SM = &BlockSM;
 503   if (parseMachineBasicBlockDefinitions(PFS, BlockStr, Error)) {
 504     reportDiagnostic(
 505         diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
 506     return true;
 507   }
 508   // Check Basic Block Section Flags.
 509   if (MF.getTarget().getBBSectionsType() == BasicBlockSection::Labels) {
 510     MF.setBBSectionsType(BasicBlockSection::Labels);
 511   } else if (MF.hasBBSections()) {
 512     MF.assignBeginEndSections();
 513   }
 514   PFS.SM = &SM;
 515
 516   // Initialize the frame information after creating all the MBBs so that the
 517   // MBB references in the frame information can be resolved.
 518   if (initializeFrameInfo(PFS, YamlMF))
 519     return true;
 520   // Initialize the jump table after creating all the MBBs so that the MBB
 521   // references can be resolved.
 522   if (!YamlMF.JumpTableInfo.Entries.empty() &&
 523       initializeJumpTableInfo(PFS, YamlMF.JumpTableInfo))
 524     return true;
 525   // Parse the machine instructions after creating all of the MBBs so that the
 526   // parser can resolve the MBB references.
 527   StringRef InsnStr = YamlMF.Body.Value.Value;
 528   SourceMgr InsnSM;
 529   InsnSM.AddNewSourceBuffer(
 530       MemoryBuffer::getMemBuffer(InsnStr, "", /*RequiresNullTerminator=*/false),
 531       SMLoc());
 532   PFS.SM = &InsnSM;
 533   if (parseMachineInstructions(PFS, InsnStr, Error)) {
 534     reportDiagnostic(
 535         diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
 536     return true;
 537   }
 538   PFS.SM = &SM;
 539
 540   if (setupRegisterInfo(PFS, YamlMF))
 541     return true;
 542
 543   if (YamlMF.MachineFuncInfo) {
 544     const LLVMTargetMachine &TM = MF.getTarget();
 545     // Note this is called after the initial constructor of the
 546     // MachineFunctionInfo based on the MachineFunction, which may depend on the
 547     // IR.
 548
 549     SMRange SrcRange;
 550     if (TM.parseMachineFunctionInfo(*YamlMF.MachineFuncInfo, PFS, Error,
 551                                     SrcRange)) {
 552       return error(Error, SrcRange);
 553     }
 554   }
 555
 556   // Set the reserved registers after parsing MachineFuncInfo. The target may
 557   // have been recording information used to select the reserved registers
 558   // there.
 559   // FIXME: This is a temporary workaround until the reserved registers can be
 560   // serialized.
 561   MachineRegisterInfo &MRI = MF.getRegInfo();
 562   MRI.freezeReservedRegs(MF);
 563
 564   computeFunctionProperties(MF);
 565
 566   if (initializeCallSiteInfo(PFS, YamlMF))
 567     return false;
 568
 569   setupDebugValueTracking(MF, PFS, YamlMF);
 570
 571   MF.getSubtarget().mirFileLoaded(MF);
 572
 573   MF.verify();
 574   return false;
 575 }
 576
 577 bool MIRParserImpl::parseRegisterInfo(PerFunctionMIParsingState &PFS,
 578                                       const yaml::MachineFunction &YamlMF) {
 579   MachineFunction &MF = PFS.MF;
 580   MachineRegisterInfo &RegInfo = MF.getRegInfo();
 581   assert(RegInfo.tracksLiveness());
 582   if (!YamlMF.TracksRegLiveness)
 583     RegInfo.invalidateLiveness();
 584
 585   SMDiagnostic Error;
 586   // Parse the virtual register information.
 587   for (const auto &VReg : YamlMF.VirtualRegisters) {
 588     VRegInfo &Info = PFS.getVRegInfo(VReg.ID.Value);
 589     if (Info.Explicit)
 590       return error(VReg.ID.SourceRange.Start,
 591                    Twine("redefinition of virtual register '%") +
 592                        Twine(VReg.ID.Value) + "'");
 593     Info.Explicit = true;
 594
 595     if (StringRef(VReg.Class.Value).equals("_")) {
 596       Info.Kind = VRegInfo::GENERIC;
 597       Info.D.RegBank = nullptr;
 598     } else {
 599       const auto *RC = Target->getRegClass(VReg.Class.Value);
 600       if (RC) {
 601         Info.Kind = VRegInfo::NORMAL;
 602         Info.D.RC = RC;
 603       } else {
 604         const RegisterBank *RegBank = Target->getRegBank(VReg.Class.Value);
 605         if (!RegBank)
 606           return error(
 607               VReg.Class.SourceRange.Start,
 608               Twine("use of undefined register class or register bank '") +
 609                   VReg.Class.Value + "'");
 610         Info.Kind = VRegInfo::REGBANK;
 611         Info.D.RegBank = RegBank;
 612       }
 613     }
 614
 615     if (!VReg.PreferredRegister.Value.empty()) {
 616       if (Info.Kind != VRegInfo::NORMAL)
 617         return error(VReg.Class.SourceRange.Start,
 618               Twine("preferred register can only be set for normal vregs"));
 619
 620       if (parseRegisterReference(PFS, Info.PreferredReg,
 621                                  VReg.PreferredRegister.Value, Error))
 622         return error(Error, VReg.PreferredRegister.SourceRange);
 623     }
 624   }
 625
 626   // Parse the liveins.
 627   for (const auto &LiveIn : YamlMF.LiveIns) {
 628     Register Reg;
 629     if (parseNamedRegisterReference(PFS, Reg, LiveIn.Register.Value, Error))
 630       return error(Error, LiveIn.Register.SourceRange);
 631     Register VReg;
 632     if (!LiveIn.VirtualRegister.Value.empty()) {
 633       VRegInfo *Info;
 634       if (parseVirtualRegisterReference(PFS, Info, LiveIn.VirtualRegister.Value,
 635                                         Error))
 636         return error(Error, LiveIn.VirtualRegister.SourceRange);
 637       VReg = Info->VReg;
 638     }
 639     RegInfo.addLiveIn(Reg, VReg);
 640   }
 641
 642   // Parse the callee saved registers (Registers that will
 643   // be saved for the caller).
 644   if (YamlMF.CalleeSavedRegisters) {
 645     SmallVector<MCPhysReg, 16> CalleeSavedRegisters;
 646     for (const auto &RegSource : *YamlMF.CalleeSavedRegisters) {
 647       Register Reg;
 648       if (parseNamedRegisterReference(PFS, Reg, RegSource.Value, Error))
 649         return error(Error, RegSource.SourceRange);
 650       CalleeSavedRegisters.push_back(Reg);
 651     }
 652     RegInfo.setCalleeSavedRegs(CalleeSavedRegisters);
 653   }
 654
 655   return false;
 656 }
 657
 658 bool MIRParserImpl::setupRegisterInfo(const PerFunctionMIParsingState &PFS,
 659                                       const yaml::MachineFunction &YamlMF) {
 660   MachineFunction &MF = PFS.MF;
 661   MachineRegisterInfo &MRI = MF.getRegInfo();
 662   bool Error = false;
 663   // Create VRegs
 664   auto populateVRegInfo = [&] (const VRegInfo &Info, Twine Name) {
 665     Register Reg = Info.VReg;
 666     switch (Info.Kind) {
 667     case VRegInfo::UNKNOWN:
 668       error(Twine("Cannot determine class/bank of virtual register ") +
 669             Name + " in function '" + MF.getName() + "'");
 670       Error = true;
 671       break;
 672     case VRegInfo::NORMAL:
 673       MRI.setRegClass(Reg, Info.D.RC);
 674       if (Info.PreferredReg != 0)
 675         MRI.setSimpleHint(Reg, Info.PreferredReg);
 676       break;
 677     case VRegInfo::GENERIC:
 678       break;
 679     case VRegInfo::REGBANK:
 680       MRI.setRegBank(Reg, *Info.D.RegBank);
 681       break;
 682     }
 683   };
 684
 685   for (const auto &P : PFS.VRegInfosNamed) {
 686     const VRegInfo &Info = *P.second;
 687     populateVRegInfo(Info, Twine(P.first()));
 688   }
 689
 690   for (auto P : PFS.VRegInfos) {
 691     const VRegInfo &Info = *P.second;
 692     populateVRegInfo(Info, Twine(P.first));
 693   }
 694
 695   // Compute MachineRegisterInfo::UsedPhysRegMask
 696   for (const MachineBasicBlock &MBB : MF) {
 697     // Make sure MRI knows about registers clobbered by unwinder.
 698     const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
 699     if (MBB.isEHPad())
 700       if (auto *RegMask = TRI->getCustomEHPadPreservedMask(MF))
 701         MRI.addPhysRegsUsedFromRegMask(RegMask);
 702
 703     for (const MachineInstr &MI : MBB) {
 704       for (const MachineOperand &MO : MI.operands()) {
 705         if (!MO.isRegMask())
 706           continue;
 707         MRI.addPhysRegsUsedFromRegMask(MO.getRegMask());
 708       }
 709     }
 710   }
 711
 712   return Error;
 713 }
 714
 715 bool MIRParserImpl::initializeFrameInfo(PerFunctionMIParsingState &PFS,
 716                                         const yaml::MachineFunction &YamlMF) {
 717   MachineFunction &MF = PFS.MF;
 718   MachineFrameInfo &MFI = MF.getFrameInfo();
 719   const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
 720   const Function &F = MF.getFunction();
 721   const yaml::MachineFrameInfo &YamlMFI = YamlMF.FrameInfo;
 722   MFI.setFrameAddressIsTaken(YamlMFI.IsFrameAddressTaken);
 723   MFI.setReturnAddressIsTaken(YamlMFI.IsReturnAddressTaken);
 724   MFI.setHasStackMap(YamlMFI.HasStackMap);
 725   MFI.setHasPatchPoint(YamlMFI.HasPatchPoint);
 726   MFI.setStackSize(YamlMFI.StackSize);
 727   MFI.setOffsetAdjustment(YamlMFI.OffsetAdjustment);
 728   if (YamlMFI.MaxAlignment)
 729     MFI.ensureMaxAlignment(Align(YamlMFI.MaxAlignment));
 730   MFI.setAdjustsStack(YamlMFI.AdjustsStack);
 731   MFI.setHasCalls(YamlMFI.HasCalls);
 732   if (YamlMFI.MaxCallFrameSize != ~0u)
 733     MFI.setMaxCallFrameSize(YamlMFI.MaxCallFrameSize);
 734   MFI.setCVBytesOfCalleeSavedRegisters(YamlMFI.CVBytesOfCalleeSavedRegisters);
 735   MFI.setHasOpaqueSPAdjustment(YamlMFI.HasOpaqueSPAdjustment);
 736   MFI.setHasVAStart(YamlMFI.HasVAStart);
 737   MFI.setHasMustTailInVarArgFunc(YamlMFI.HasMustTailInVarArgFunc);
 738   MFI.setHasTailCall(YamlMFI.HasTailCall);
 739   MFI.setLocalFrameSize(YamlMFI.LocalFrameSize);
 740   if (!YamlMFI.SavePoint.Value.empty()) {
 741     MachineBasicBlock *MBB = nullptr;
 742     if (parseMBBReference(PFS, MBB, YamlMFI.SavePoint))
 743       return true;
 744     MFI.setSavePoint(MBB);
 745   }
 746   if (!YamlMFI.RestorePoint.Value.empty()) {
 747     MachineBasicBlock *MBB = nullptr;
 748     if (parseMBBReference(PFS, MBB, YamlMFI.RestorePoint))
 749       return true;
 750     MFI.setRestorePoint(MBB);
 751   }
 752
 753   std::vector<CalleeSavedInfo> CSIInfo;
 754   // Initialize the fixed frame objects.
 755   for (const auto &Object : YamlMF.FixedStackObjects) {
 756     int ObjectIdx;
 757     if (Object.Type != yaml::FixedMachineStackObject::SpillSlot)
 758       ObjectIdx = MFI.CreateFixedObject(Object.Size, Object.Offset,
 759                                         Object.IsImmutable, Object.IsAliased);
 760     else
 761       ObjectIdx = MFI.CreateFixedSpillStackObject(Object.Size, Object.Offset);
 762
 763     if (!TFI->isSupportedStackID(Object.StackID))
 764       return error(Object.ID.SourceRange.Start,
 765                    Twine("StackID is not supported by target"));
 766     MFI.setStackID(ObjectIdx, Object.StackID);
 767     MFI.setObjectAlignment(ObjectIdx, Object.Alignment.valueOrOne());
 768     if (!PFS.FixedStackObjectSlots.insert(std::make_pair(Object.ID.Value,
 769                                                          ObjectIdx))
 770              .second)
 771       return error(Object.ID.SourceRange.Start,
 772                    Twine("redefinition of fixed stack object '%fixed-stack.") +
 773                        Twine(Object.ID.Value) + "'");
 774     if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
 775                                  Object.CalleeSavedRestored, ObjectIdx))
 776       return true;
 777     if (parseStackObjectsDebugInfo(PFS, Object, ObjectIdx))
 778       return true;
 779   }
 780
 781   // Initialize the ordinary frame objects.
 782   for (const auto &Object : YamlMF.StackObjects) {
 783     int ObjectIdx;
 784     const AllocaInst *Alloca = nullptr;
 785     const yaml::StringValue &Name = Object.Name;
 786     if (!Name.Value.empty()) {
 787       Alloca = dyn_cast_or_null<AllocaInst>(
 788           F.getValueSymbolTable()->lookup(Name.Value));
 789       if (!Alloca)
 790         return error(Name.SourceRange.Start,
 791                      "alloca instruction named '" + Name.Value +
 792                          "' isn't defined in the function '" + F.getName() +
 793                          "'");
 794     }
 795     if (!TFI->isSupportedStackID(Object.StackID))
 796       return error(Object.ID.SourceRange.Start,
 797                    Twine("StackID is not supported by target"));
 798     if (Object.Type == yaml::MachineStackObject::VariableSized)
 799       ObjectIdx =
 800           MFI.CreateVariableSizedObject(Object.Alignment.valueOrOne(), Alloca);
 801     else
 802       ObjectIdx = MFI.CreateStackObject(
 803           Object.Size, Object.Alignment.valueOrOne(),
 804           Object.Type == yaml::MachineStackObject::SpillSlot, Alloca,
 805           Object.StackID);
 806     MFI.setObjectOffset(ObjectIdx, Object.Offset);
 807
 808     if (!PFS.StackObjectSlots.insert(std::make_pair(Object.ID.Value, ObjectIdx))
 809              .second)
 810       return error(Object.ID.SourceRange.Start,
 811                    Twine("redefinition of stack object '%stack.") +
 812                        Twine(Object.ID.Value) + "'");
 813     if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
 814                                  Object.CalleeSavedRestored, ObjectIdx))
 815       return true;
 816     if (Object.LocalOffset)
 817       MFI.mapLocalFrameObject(ObjectIdx, *Object.LocalOffset);
 818     if (parseStackObjectsDebugInfo(PFS, Object, ObjectIdx))
 819       return true;
 820   }
 821   MFI.setCalleeSavedInfo(CSIInfo);
 822   if (!CSIInfo.empty())
 823     MFI.setCalleeSavedInfoValid(true);
 824
 825   // Initialize the various stack object references after initializing the
 826   // stack objects.
 827   if (!YamlMFI.StackProtector.Value.empty()) {
 828     SMDiagnostic Error;
 829     int FI;
 830     if (parseStackObjectReference(PFS, FI, YamlMFI.StackProtector.Value, Error))
 831       return error(Error, YamlMFI.StackProtector.SourceRange);
 832     MFI.setStackProtectorIndex(FI);
 833   }
 834
 835   if (!YamlMFI.FunctionContext.Value.empty()) {
 836     SMDiagnostic Error;
 837     int FI;
 838     if (parseStackObjectReference(PFS, FI, YamlMFI.FunctionContext.Value, Error))
 839       return error(Error, YamlMFI.FunctionContext.SourceRange);
 840     MFI.setFunctionContextIndex(FI);
 841   }
 842
 843   return false;
 844 }
 845
 846 bool MIRParserImpl::parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
 847     std::vector<CalleeSavedInfo> &CSIInfo,
 848     const yaml::StringValue &RegisterSource, bool IsRestored, int FrameIdx) {
 849   if (RegisterSource.Value.empty())
 850     return false;
 851   Register Reg;
 852   SMDiagnostic Error;
 853   if (parseNamedRegisterReference(PFS, Reg, RegisterSource.Value, Error))
 854     return error(Error, RegisterSource.SourceRange);
 855   CalleeSavedInfo CSI(Reg, FrameIdx);
 856   CSI.setRestored(IsRestored);
 857   CSIInfo.push_back(CSI);
 858   return false;
 859 }
 860
 861 /// Verify that given node is of a certain type. Return true on error.
 862 template <typename T>
 863 static bool typecheckMDNode(T *&Result, MDNode *Node,
 864                             const yaml::StringValue &Source,
 865                             StringRef TypeString, MIRParserImpl &Parser) {
 866   if (!Node)
 867     return false;
 868   Result = dyn_cast<T>(Node);
 869   if (!Result)
 870     return Parser.error(Source.SourceRange.Start,
 871                         "expected a reference to a '" + TypeString +
 872                             "' metadata node");
 873   return false;
 874 }
 875
 876 template <typename T>
 877 bool MIRParserImpl::parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
 878     const T &Object, int FrameIdx) {
 879   // Debug information can only be attached to stack objects; Fixed stack
 880   // objects aren't supported.
 881   MDNode *Var = nullptr, *Expr = nullptr, *Loc = nullptr;
 882   if (parseMDNode(PFS, Var, Object.DebugVar) ||
 883       parseMDNode(PFS, Expr, Object.DebugExpr) ||
 884       parseMDNode(PFS, Loc, Object.DebugLoc))
 885     return true;
 886   if (!Var && !Expr && !Loc)
 887     return false;
 888   DILocalVariable *DIVar = nullptr;
 889   DIExpression *DIExpr = nullptr;
 890   DILocation *DILoc = nullptr;
 891   if (typecheckMDNode(DIVar, Var, Object.DebugVar, "DILocalVariable", *this) ||
 892       typecheckMDNode(DIExpr, Expr, Object.DebugExpr, "DIExpression", *this) ||
 893       typecheckMDNode(DILoc, Loc, Object.DebugLoc, "DILocation", *this))
 894     return true;
 895   PFS.MF.setVariableDbgInfo(DIVar, DIExpr, FrameIdx, DILoc);
 896   return false;
 897 }
 898
 899 bool MIRParserImpl::parseMDNode(PerFunctionMIParsingState &PFS,
 900     MDNode *&Node, const yaml::StringValue &Source) {
 901   if (Source.Value.empty())
 902     return false;
 903   SMDiagnostic Error;
 904   if (llvm::parseMDNode(PFS, Node, Source.Value, Error))
 905     return error(Error, Source.SourceRange);
 906   return false;
 907 }
 908
 909 bool MIRParserImpl::initializeConstantPool(PerFunctionMIParsingState &PFS,
 910     MachineConstantPool &ConstantPool, const yaml::MachineFunction &YamlMF) {
 911   DenseMap<unsigned, unsigned> &ConstantPoolSlots = PFS.ConstantPoolSlots;
 912   const MachineFunction &MF = PFS.MF;
 913   const auto &M = *MF.getFunction().getParent();
 914   SMDiagnostic Error;
 915   for (const auto &YamlConstant : YamlMF.Constants) {
 916     if (YamlConstant.IsTargetSpecific)
 917       // FIXME: Support target-specific constant pools
 918       return error(YamlConstant.Value.SourceRange.Start,
 919                    "Can't parse target-specific constant pool entries yet");
 920     const Constant *Value = dyn_cast_or_null<Constant>(
 921         parseConstantValue(YamlConstant.Value.Value, Error, M));
 922     if (!Value)
 923       return error(Error, YamlConstant.Value.SourceRange);
 924     const Align PrefTypeAlign =
 925         M.getDataLayout().getPrefTypeAlign(Value->getType());
 926     const Align Alignment = YamlConstant.Alignment.value_or(PrefTypeAlign);
 927     unsigned Index = ConstantPool.getConstantPoolIndex(Value, Alignment);
 928     if (!ConstantPoolSlots.insert(std::make_pair(YamlConstant.ID.Value, Index))
 929              .second)
 930       return error(YamlConstant.ID.SourceRange.Start,
 931                    Twine("redefinition of constant pool item '%const.") +
 932                        Twine(YamlConstant.ID.Value) + "'");
 933   }
 934   return false;
 935 }
 936
 937 bool MIRParserImpl::initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
 938     const yaml::MachineJumpTable &YamlJTI) {
 939   MachineJumpTableInfo *JTI = PFS.MF.getOrCreateJumpTableInfo(YamlJTI.Kind);
 940   for (const auto &Entry : YamlJTI.Entries) {
 941     std::vector<MachineBasicBlock *> Blocks;
 942     for (const auto &MBBSource : Entry.Blocks) {
 943       MachineBasicBlock *MBB = nullptr;
 944       if (parseMBBReference(PFS, MBB, MBBSource.Value))
 945         return true;
 946       Blocks.push_back(MBB);
 947     }
 948     unsigned Index = JTI->createJumpTableIndex(Blocks);
 949     if (!PFS.JumpTableSlots.insert(std::make_pair(Entry.ID.Value, Index))
 950              .second)
 951       return error(Entry.ID.SourceRange.Start,
 952                    Twine("redefinition of jump table entry '%jump-table.") +
 953                        Twine(Entry.ID.Value) + "'");
 954   }
 955   return false;
 956 }
 957
 958 bool MIRParserImpl::parseMBBReference(PerFunctionMIParsingState &PFS,
 959                                       MachineBasicBlock *&MBB,
 960                                       const yaml::StringValue &Source) {
 961   SMDiagnostic Error;
 962   if (llvm::parseMBBReference(PFS, MBB, Source.Value, Error))
 963     return error(Error, Source.SourceRange);
 964   return false;
 965 }
 966
 967 bool MIRParserImpl::parseMachineMetadata(PerFunctionMIParsingState &PFS,
 968                                          const yaml::StringValue &Source) {
 969   SMDiagnostic Error;
 970   if (llvm::parseMachineMetadata(PFS, Source.Value, Source.SourceRange, Error))
 971     return error(Error, Source.SourceRange);
 972   return false;
 973 }
 974
 975 bool MIRParserImpl::parseMachineMetadataNodes(
 976     PerFunctionMIParsingState &PFS, MachineFunction &MF,
 977     const yaml::MachineFunction &YMF) {
 978   for (const auto &MDS : YMF.MachineMetadataNodes) {
 979     if (parseMachineMetadata(PFS, MDS))
 980       return true;
 981   }
 982   // Report missing definitions from forward referenced nodes.
 983   if (!PFS.MachineForwardRefMDNodes.empty())
 984     return error(PFS.MachineForwardRefMDNodes.begin()->second.second,
 985                  "use of undefined metadata '!" +
 986                      Twine(PFS.MachineForwardRefMDNodes.begin()->first) + "'");
 987   return false;
 988 }
 989
 990 SMDiagnostic MIRParserImpl::diagFromMIStringDiag(const SMDiagnostic &Error,
 991                                                  SMRange SourceRange) {
 992   assert(SourceRange.isValid() && "Invalid source range");
 993   SMLoc Loc = SourceRange.Start;
 994   bool HasQuote = Loc.getPointer() < SourceRange.End.getPointer() &&
 995                   *Loc.getPointer() == '\'';
 996   // Translate the location of the error from the location in the MI string to
 997   // the corresponding location in the MIR file.
 998   Loc = Loc.getFromPointer(Loc.getPointer() + Error.getColumnNo() +
 999                            (HasQuote ? 1 : 0));
1000
1001   // TODO: Translate any source ranges as well.
1002   return SM.GetMessage(Loc, Error.getKind(), Error.getMessage(), None,
1003                        Error.getFixIts());
1004 }
1005
1006 SMDiagnostic MIRParserImpl::diagFromBlockStringDiag(const SMDiagnostic &Error,
1007                                                     SMRange SourceRange) {
1008   assert(SourceRange.isValid());
1009
1010   // Translate the location of the error from the location in the llvm IR string
1011   // to the corresponding location in the MIR file.
1012   auto LineAndColumn = SM.getLineAndColumn(SourceRange.Start);
1013   unsigned Line = LineAndColumn.first + Error.getLineNo() - 1;
1014   unsigned Column = Error.getColumnNo();
1015   StringRef LineStr = Error.getLineContents();
1016   SMLoc Loc = Error.getLoc();
1017
1018   // Get the full line and adjust the column number by taking the indentation of
1019   // LLVM IR into account.
1020   for (line_iterator L(*SM.getMemoryBuffer(SM.getMainFileID()), false), E;
1021        L != E; ++L) {
1022     if (L.line_number() == Line) {
1023       LineStr = *L;
1024       Loc = SMLoc::getFromPointer(LineStr.data());
1025       auto Indent = LineStr.find(Error.getLineContents());
1026       if (Indent != StringRef::npos)
1027         Column += Indent;
1028       break;
1029     }
1030   }
1031
1032   return SMDiagnostic(SM, Loc, Filename, Line, Column, Error.getKind(),
1033                       Error.getMessage(), LineStr, Error.getRanges(),
1034                       Error.getFixIts());
1035 }
1036
1037 MIRParser::MIRParser(std::unique_ptr<MIRParserImpl> Impl)
1038     : Impl(std::move(Impl)) {}
1039
1040 MIRParser::~MIRParser() = default;
1041
1042 std::unique_ptr<Module>
1043 MIRParser::parseIRModule(DataLayoutCallbackTy DataLayoutCallback) {
1044   return Impl->parseIRModule(DataLayoutCallback);
1045 }
1046
1047 bool MIRParser::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
1048   return Impl->parseMachineFunctions(M, MMI);
1049 }
1050
1051 std::unique_ptr<MIRParser> llvm::createMIRParserFromFile(
1052     StringRef Filename, SMDiagnostic &Error, LLVMContext &Context,
1053     std::function<void(Function &)> ProcessIRFunction) {
1054   auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
1055   if (std::error_code EC = FileOrErr.getError()) {
1056     Error = SMDiagnostic(Filename, SourceMgr::DK_Error,
1057                          "Could not open input file: " + EC.message());
1058     return nullptr;
1059   }
1060   return createMIRParser(std::move(FileOrErr.get()), Context,
1061                          ProcessIRFunction);
1062 }
1063
1064 std::unique_ptr<MIRParser>
1065 llvm::createMIRParser(std::unique_ptr<MemoryBuffer> Contents,
1066                       LLVMContext &Context,
1067                       std::function<void(Function &)> ProcessIRFunction) {
1068   auto Filename = Contents->getBufferIdentifier();
1069   if (Context.shouldDiscardValueNames()) {
1070     Context.diagnose(DiagnosticInfoMIRParser(
1071         DS_Error,
1072         SMDiagnostic(
1073             Filename, SourceMgr::DK_Error,
1074             "Can't read MIR with a Context that discards named Values")));
1075     return nullptr;
1076   }
1077   return std::make_unique<MIRParser>(std::make_unique<MIRParserImpl>(
1078       std::move(Contents), Filename, Context, ProcessIRFunction));
1079 }