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