lib/CodeGen/MIRParser/MIRParser.cpp

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