1 //===- MIRParser.cpp - MIR serialization format parser implementation -----===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the class that parses the optional LLVM IR and machine 11 // functions that are stored in MIR files. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/CodeGen/MIRParser/MIRParser.h" 16 #include "MIParser.h" 17 #include "llvm/ADT/DenseMap.h" 18 #include "llvm/ADT/STLExtras.h" 19 #include "llvm/ADT/StringMap.h" 20 #include "llvm/ADT/StringRef.h" 21 #include "llvm/AsmParser/Parser.h" 22 #include "llvm/AsmParser/SlotMapping.h" 23 #include "llvm/CodeGen/GlobalISel/RegisterBank.h" 24 #include "llvm/CodeGen/GlobalISel/RegisterBankInfo.h" 25 #include "llvm/CodeGen/MIRYamlMapping.h" 26 #include "llvm/CodeGen/MachineConstantPool.h" 27 #include "llvm/CodeGen/MachineFrameInfo.h" 28 #include "llvm/CodeGen/MachineFunction.h" 29 #include "llvm/CodeGen/MachineModuleInfo.h" 30 #include "llvm/CodeGen/MachineRegisterInfo.h" 31 #include "llvm/IR/BasicBlock.h" 32 #include "llvm/IR/DebugInfo.h" 33 #include "llvm/IR/DiagnosticInfo.h" 34 #include "llvm/IR/Instructions.h" 35 #include "llvm/IR/LLVMContext.h" 36 #include "llvm/IR/Module.h" 37 #include "llvm/IR/ValueSymbolTable.h" 38 #include "llvm/Support/LineIterator.h" 39 #include "llvm/Support/MemoryBuffer.h" 40 #include "llvm/Support/SMLoc.h" 41 #include "llvm/Support/SourceMgr.h" 42 #include "llvm/Support/YAMLTraits.h" 43 #include <memory> 44 45 using namespace llvm; 46 47 namespace llvm { 48 49 /// This class implements the parsing of LLVM IR that's embedded inside a MIR 50 /// file. 51 class MIRParserImpl { 52 SourceMgr SM; 53 StringRef Filename; 54 LLVMContext &Context; 55 StringMap<std::unique_ptr<yaml::MachineFunction>> Functions; 56 SlotMapping IRSlots; 57 /// Maps from register class names to register classes. 58 StringMap<const TargetRegisterClass *> Names2RegClasses; 59 /// Maps from register bank names to register banks. 60 StringMap<const RegisterBank *> Names2RegBanks; 61 62 public: 63 MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents, StringRef Filename, 64 LLVMContext &Context); 65 66 void reportDiagnostic(const SMDiagnostic &Diag); 67 68 /// Report an error with the given message at unknown location. 69 /// 70 /// Always returns true. 71 bool error(const Twine &Message); 72 73 /// Report an error with the given message at the given location. 74 /// 75 /// Always returns true. 76 bool error(SMLoc Loc, const Twine &Message); 77 78 /// Report a given error with the location translated from the location in an 79 /// embedded string literal to a location in the MIR file. 80 /// 81 /// Always returns true. 82 bool error(const SMDiagnostic &Error, SMRange SourceRange); 83 84 /// Try to parse the optional LLVM module and the machine functions in the MIR 85 /// file. 86 /// 87 /// Return null if an error occurred. 88 std::unique_ptr<Module> parse(); 89 90 /// Parse the machine function in the current YAML document. 91 /// 92 /// \param NoLLVMIR - set to true when the MIR file doesn't have LLVM IR. 93 /// A dummy IR function is created and inserted into the given module when 94 /// this parameter is true. 95 /// 96 /// Return true if an error occurred. 97 bool parseMachineFunction(yaml::Input &In, Module &M, bool NoLLVMIR); 98 99 /// Initialize the machine function to the state that's described in the MIR 100 /// file. 101 /// 102 /// Return true if error occurred. 103 bool initializeMachineFunction(MachineFunction &MF); 104 105 bool initializeRegisterInfo(PerFunctionMIParsingState &PFS, 106 const yaml::MachineFunction &YamlMF); 107 108 void inferRegisterInfo(const PerFunctionMIParsingState &PFS, 109 const yaml::MachineFunction &YamlMF); 110 111 bool initializeFrameInfo(PerFunctionMIParsingState &PFS, 112 const yaml::MachineFunction &YamlMF); 113 114 bool parseCalleeSavedRegister(PerFunctionMIParsingState &PFS, 115 std::vector<CalleeSavedInfo> &CSIInfo, 116 const yaml::StringValue &RegisterSource, 117 int FrameIdx); 118 119 bool parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS, 120 const yaml::MachineStackObject &Object, 121 int FrameIdx); 122 123 bool initializeConstantPool(PerFunctionMIParsingState &PFS, 124 MachineConstantPool &ConstantPool, 125 const yaml::MachineFunction &YamlMF); 126 127 bool initializeJumpTableInfo(PerFunctionMIParsingState &PFS, 128 const yaml::MachineJumpTable &YamlJTI); 129 130 private: 131 bool parseMDNode(const PerFunctionMIParsingState &PFS, MDNode *&Node, 132 const yaml::StringValue &Source); 133 134 bool parseMBBReference(const PerFunctionMIParsingState &PFS, 135 MachineBasicBlock *&MBB, 136 const yaml::StringValue &Source); 137 138 /// Return a MIR diagnostic converted from an MI string diagnostic. 139 SMDiagnostic diagFromMIStringDiag(const SMDiagnostic &Error, 140 SMRange SourceRange); 141 142 /// Return a MIR diagnostic converted from a diagnostic located in a YAML 143 /// block scalar string. 144 SMDiagnostic diagFromBlockStringDiag(const SMDiagnostic &Error, 145 SMRange SourceRange); 146 147 /// Create an empty function with the given name. 148 void createDummyFunction(StringRef Name, Module &M); 149 150 void initNames2RegClasses(const MachineFunction &MF); 151 void initNames2RegBanks(const MachineFunction &MF); 152 153 /// Check if the given identifier is a name of a register class. 154 /// 155 /// Return null if the name isn't a register class. 156 const TargetRegisterClass *getRegClass(const MachineFunction &MF, 157 StringRef Name); 158 159 /// Check if the given identifier is a name of a register bank. 160 /// 161 /// Return null if the name isn't a register bank. 162 const RegisterBank *getRegBank(const MachineFunction &MF, StringRef Name); 163 }; 164 165 } // end namespace llvm 166 167 MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents, 168 StringRef Filename, LLVMContext &Context) 169 : SM(), Filename(Filename), Context(Context) { 170 SM.AddNewSourceBuffer(std::move(Contents), SMLoc()); 171 } 172 173 bool MIRParserImpl::error(const Twine &Message) { 174 Context.diagnose(DiagnosticInfoMIRParser( 175 DS_Error, SMDiagnostic(Filename, SourceMgr::DK_Error, Message.str()))); 176 return true; 177 } 178 179 bool MIRParserImpl::error(SMLoc Loc, const Twine &Message) { 180 Context.diagnose(DiagnosticInfoMIRParser( 181 DS_Error, SM.GetMessage(Loc, SourceMgr::DK_Error, Message))); 182 return true; 183 } 184 185 bool MIRParserImpl::error(const SMDiagnostic &Error, SMRange SourceRange) { 186 assert(Error.getKind() == SourceMgr::DK_Error && "Expected an error"); 187 reportDiagnostic(diagFromMIStringDiag(Error, SourceRange)); 188 return true; 189 } 190 191 void MIRParserImpl::reportDiagnostic(const SMDiagnostic &Diag) { 192 DiagnosticSeverity Kind; 193 switch (Diag.getKind()) { 194 case SourceMgr::DK_Error: 195 Kind = DS_Error; 196 break; 197 case SourceMgr::DK_Warning: 198 Kind = DS_Warning; 199 break; 200 case SourceMgr::DK_Note: 201 Kind = DS_Note; 202 break; 203 } 204 Context.diagnose(DiagnosticInfoMIRParser(Kind, Diag)); 205 } 206 207 static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) { 208 reinterpret_cast<MIRParserImpl *>(Context)->reportDiagnostic(Diag); 209 } 210 211 std::unique_ptr<Module> MIRParserImpl::parse() { 212 yaml::Input In(SM.getMemoryBuffer(SM.getMainFileID())->getBuffer(), 213 /*Ctxt=*/nullptr, handleYAMLDiag, this); 214 In.setContext(&In); 215 216 if (!In.setCurrentDocument()) { 217 if (In.error()) 218 return nullptr; 219 // Create an empty module when the MIR file is empty. 220 return llvm::make_unique<Module>(Filename, Context); 221 } 222 223 std::unique_ptr<Module> M; 224 bool NoLLVMIR = false; 225 // Parse the block scalar manually so that we can return unique pointer 226 // without having to go trough YAML traits. 227 if (const auto *BSN = 228 dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) { 229 SMDiagnostic Error; 230 M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error, 231 Context, &IRSlots); 232 if (!M) { 233 reportDiagnostic(diagFromBlockStringDiag(Error, BSN->getSourceRange())); 234 return nullptr; 235 } 236 In.nextDocument(); 237 if (!In.setCurrentDocument()) 238 return M; 239 } else { 240 // Create an new, empty module. 241 M = llvm::make_unique<Module>(Filename, Context); 242 NoLLVMIR = true; 243 } 244 245 // Parse the machine functions. 246 do { 247 if (parseMachineFunction(In, *M, NoLLVMIR)) 248 return nullptr; 249 In.nextDocument(); 250 } while (In.setCurrentDocument()); 251 252 return M; 253 } 254 255 bool MIRParserImpl::parseMachineFunction(yaml::Input &In, Module &M, 256 bool NoLLVMIR) { 257 auto MF = llvm::make_unique<yaml::MachineFunction>(); 258 yaml::yamlize(In, *MF, false); 259 if (In.error()) 260 return true; 261 auto FunctionName = MF->Name; 262 if (Functions.find(FunctionName) != Functions.end()) 263 return error(Twine("redefinition of machine function '") + FunctionName + 264 "'"); 265 Functions.insert(std::make_pair(FunctionName, std::move(MF))); 266 if (NoLLVMIR) 267 createDummyFunction(FunctionName, M); 268 else if (!M.getFunction(FunctionName)) 269 return error(Twine("function '") + FunctionName + 270 "' isn't defined in the provided LLVM IR"); 271 return false; 272 } 273 274 void MIRParserImpl::createDummyFunction(StringRef Name, Module &M) { 275 auto &Context = M.getContext(); 276 Function *F = cast<Function>(M.getOrInsertFunction( 277 Name, FunctionType::get(Type::getVoidTy(Context), false))); 278 BasicBlock *BB = BasicBlock::Create(Context, "entry", F); 279 new UnreachableInst(Context, BB); 280 } 281 282 bool MIRParserImpl::initializeMachineFunction(MachineFunction &MF) { 283 auto It = Functions.find(MF.getName()); 284 if (It == Functions.end()) 285 return error(Twine("no machine function information for function '") + 286 MF.getName() + "' in the MIR file"); 287 // TODO: Recreate the machine function. 288 const yaml::MachineFunction &YamlMF = *It->getValue(); 289 if (YamlMF.Alignment) 290 MF.setAlignment(YamlMF.Alignment); 291 MF.setExposesReturnsTwice(YamlMF.ExposesReturnsTwice); 292 MF.setHasInlineAsm(YamlMF.HasInlineAsm); 293 if (YamlMF.AllVRegsAllocated) 294 MF.getProperties().set(MachineFunctionProperties::Property::AllVRegsAllocated); 295 PerFunctionMIParsingState PFS(MF, SM, IRSlots); 296 if (initializeRegisterInfo(PFS, YamlMF)) 297 return true; 298 if (!YamlMF.Constants.empty()) { 299 auto *ConstantPool = MF.getConstantPool(); 300 assert(ConstantPool && "Constant pool must be created"); 301 if (initializeConstantPool(PFS, *ConstantPool, YamlMF)) 302 return true; 303 } 304 305 StringRef BlockStr = YamlMF.Body.Value.Value; 306 SMDiagnostic Error; 307 SourceMgr BlockSM; 308 BlockSM.AddNewSourceBuffer( 309 MemoryBuffer::getMemBuffer(BlockStr, "",/*RequiresNullTerminator=*/false), 310 SMLoc()); 311 PFS.SM = &BlockSM; 312 if (parseMachineBasicBlockDefinitions(PFS, BlockStr, Error)) { 313 reportDiagnostic( 314 diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange)); 315 return true; 316 } 317 PFS.SM = &SM; 318 319 if (MF.empty()) 320 return error(Twine("machine function '") + Twine(MF.getName()) + 321 "' requires at least one machine basic block in its body"); 322 // Initialize the frame information after creating all the MBBs so that the 323 // MBB references in the frame information can be resolved. 324 if (initializeFrameInfo(PFS, YamlMF)) 325 return true; 326 // Initialize the jump table after creating all the MBBs so that the MBB 327 // references can be resolved. 328 if (!YamlMF.JumpTableInfo.Entries.empty() && 329 initializeJumpTableInfo(PFS, YamlMF.JumpTableInfo)) 330 return true; 331 // Parse the machine instructions after creating all of the MBBs so that the 332 // parser can resolve the MBB references. 333 StringRef InsnStr = YamlMF.Body.Value.Value; 334 SourceMgr InsnSM; 335 InsnSM.AddNewSourceBuffer( 336 MemoryBuffer::getMemBuffer(InsnStr, "", /*RequiresNullTerminator=*/false), 337 SMLoc()); 338 PFS.SM = &InsnSM; 339 if (parseMachineInstructions(PFS, InsnStr, Error)) { 340 reportDiagnostic( 341 diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange)); 342 return true; 343 } 344 PFS.SM = &SM; 345 346 inferRegisterInfo(PFS, YamlMF); 347 // FIXME: This is a temporary workaround until the reserved registers can be 348 // serialized. 349 MF.getRegInfo().freezeReservedRegs(MF); 350 MF.verify(); 351 return false; 352 } 353 354 bool MIRParserImpl::initializeRegisterInfo(PerFunctionMIParsingState &PFS, 355 const yaml::MachineFunction &YamlMF) { 356 MachineFunction &MF = PFS.MF; 357 MachineRegisterInfo &RegInfo = MF.getRegInfo(); 358 assert(RegInfo.isSSA()); 359 if (!YamlMF.IsSSA) 360 RegInfo.leaveSSA(); 361 assert(RegInfo.tracksLiveness()); 362 if (!YamlMF.TracksRegLiveness) 363 RegInfo.invalidateLiveness(); 364 RegInfo.enableSubRegLiveness(YamlMF.TracksSubRegLiveness); 365 366 SMDiagnostic Error; 367 // Parse the virtual register information. 368 for (const auto &VReg : YamlMF.VirtualRegisters) { 369 unsigned Reg; 370 if (StringRef(VReg.Class.Value).equals("_")) { 371 // This is a generic virtual register. 372 // The size will be set appropriately when we reach the definition. 373 Reg = RegInfo.createGenericVirtualRegister(/*Size*/ 1); 374 PFS.GenericVRegs.insert(Reg); 375 } else { 376 const auto *RC = getRegClass(MF, VReg.Class.Value); 377 if (RC) { 378 Reg = RegInfo.createVirtualRegister(RC); 379 } else { 380 const auto *RegBank = getRegBank(MF, VReg.Class.Value); 381 if (!RegBank) 382 return error( 383 VReg.Class.SourceRange.Start, 384 Twine("use of undefined register class or register bank '") + 385 VReg.Class.Value + "'"); 386 Reg = RegInfo.createGenericVirtualRegister(/*Size*/ 1); 387 RegInfo.setRegBank(Reg, *RegBank); 388 PFS.GenericVRegs.insert(Reg); 389 } 390 } 391 if (!PFS.VirtualRegisterSlots.insert(std::make_pair(VReg.ID.Value, Reg)) 392 .second) 393 return error(VReg.ID.SourceRange.Start, 394 Twine("redefinition of virtual register '%") + 395 Twine(VReg.ID.Value) + "'"); 396 if (!VReg.PreferredRegister.Value.empty()) { 397 unsigned PreferredReg = 0; 398 if (parseNamedRegisterReference(PFS, PreferredReg, 399 VReg.PreferredRegister.Value, Error)) 400 return error(Error, VReg.PreferredRegister.SourceRange); 401 RegInfo.setSimpleHint(Reg, PreferredReg); 402 } 403 } 404 405 // Parse the liveins. 406 for (const auto &LiveIn : YamlMF.LiveIns) { 407 unsigned Reg = 0; 408 if (parseNamedRegisterReference(PFS, Reg, LiveIn.Register.Value, Error)) 409 return error(Error, LiveIn.Register.SourceRange); 410 unsigned VReg = 0; 411 if (!LiveIn.VirtualRegister.Value.empty()) { 412 if (parseVirtualRegisterReference(PFS, VReg, LiveIn.VirtualRegister.Value, 413 Error)) 414 return error(Error, LiveIn.VirtualRegister.SourceRange); 415 } 416 RegInfo.addLiveIn(Reg, VReg); 417 } 418 419 // Parse the callee saved register mask. 420 BitVector CalleeSavedRegisterMask(RegInfo.getUsedPhysRegsMask().size()); 421 if (!YamlMF.CalleeSavedRegisters) 422 return false; 423 for (const auto &RegSource : YamlMF.CalleeSavedRegisters.getValue()) { 424 unsigned Reg = 0; 425 if (parseNamedRegisterReference(PFS, Reg, RegSource.Value, Error)) 426 return error(Error, RegSource.SourceRange); 427 CalleeSavedRegisterMask[Reg] = true; 428 } 429 RegInfo.setUsedPhysRegMask(CalleeSavedRegisterMask.flip()); 430 return false; 431 } 432 433 void MIRParserImpl::inferRegisterInfo(const PerFunctionMIParsingState &PFS, 434 const yaml::MachineFunction &YamlMF) { 435 if (YamlMF.CalleeSavedRegisters) 436 return; 437 MachineRegisterInfo &MRI = PFS.MF.getRegInfo(); 438 for (const MachineBasicBlock &MBB : PFS.MF) { 439 for (const MachineInstr &MI : MBB) { 440 for (const MachineOperand &MO : MI.operands()) { 441 if (!MO.isRegMask()) 442 continue; 443 MRI.addPhysRegsUsedFromRegMask(MO.getRegMask()); 444 } 445 } 446 } 447 } 448 449 bool MIRParserImpl::initializeFrameInfo(PerFunctionMIParsingState &PFS, 450 const yaml::MachineFunction &YamlMF) { 451 MachineFunction &MF = PFS.MF; 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(PFS, MBB, YamlMFI.SavePoint)) 472 return true; 473 MFI.setSavePoint(MBB); 474 } 475 if (!YamlMFI.RestorePoint.Value.empty()) { 476 MachineBasicBlock *MBB = nullptr; 477 if (parseMBBReference(PFS, MBB, YamlMFI.RestorePoint)) 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 if (!PFS.FixedStackObjectSlots.insert(std::make_pair(Object.ID.Value, 493 ObjectIdx)) 494 .second) 495 return error(Object.ID.SourceRange.Start, 496 Twine("redefinition of fixed stack object '%fixed-stack.") + 497 Twine(Object.ID.Value) + "'"); 498 if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister, 499 ObjectIdx)) 500 return true; 501 } 502 503 // Initialize the ordinary frame objects. 504 for (const auto &Object : YamlMF.StackObjects) { 505 int ObjectIdx; 506 const AllocaInst *Alloca = nullptr; 507 const yaml::StringValue &Name = Object.Name; 508 if (!Name.Value.empty()) { 509 Alloca = dyn_cast_or_null<AllocaInst>( 510 F.getValueSymbolTable().lookup(Name.Value)); 511 if (!Alloca) 512 return error(Name.SourceRange.Start, 513 "alloca instruction named '" + Name.Value + 514 "' isn't defined in the function '" + F.getName() + 515 "'"); 516 } 517 if (Object.Type == yaml::MachineStackObject::VariableSized) 518 ObjectIdx = MFI.CreateVariableSizedObject(Object.Alignment, Alloca); 519 else 520 ObjectIdx = MFI.CreateStackObject( 521 Object.Size, Object.Alignment, 522 Object.Type == yaml::MachineStackObject::SpillSlot, Alloca); 523 MFI.setObjectOffset(ObjectIdx, Object.Offset); 524 if (!PFS.StackObjectSlots.insert(std::make_pair(Object.ID.Value, ObjectIdx)) 525 .second) 526 return error(Object.ID.SourceRange.Start, 527 Twine("redefinition of stack object '%stack.") + 528 Twine(Object.ID.Value) + "'"); 529 if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister, 530 ObjectIdx)) 531 return true; 532 if (Object.LocalOffset) 533 MFI.mapLocalFrameObject(ObjectIdx, Object.LocalOffset.getValue()); 534 if (parseStackObjectsDebugInfo(PFS, Object, ObjectIdx)) 535 return true; 536 } 537 MFI.setCalleeSavedInfo(CSIInfo); 538 if (!CSIInfo.empty()) 539 MFI.setCalleeSavedInfoValid(true); 540 541 // Initialize the various stack object references after initializing the 542 // stack objects. 543 if (!YamlMFI.StackProtector.Value.empty()) { 544 SMDiagnostic Error; 545 int FI; 546 if (parseStackObjectReference(PFS, FI, YamlMFI.StackProtector.Value, Error)) 547 return error(Error, YamlMFI.StackProtector.SourceRange); 548 MFI.setStackProtectorIndex(FI); 549 } 550 return false; 551 } 552 553 bool MIRParserImpl::parseCalleeSavedRegister(PerFunctionMIParsingState &PFS, 554 std::vector<CalleeSavedInfo> &CSIInfo, 555 const yaml::StringValue &RegisterSource, int FrameIdx) { 556 if (RegisterSource.Value.empty()) 557 return false; 558 unsigned Reg = 0; 559 SMDiagnostic Error; 560 if (parseNamedRegisterReference(PFS, Reg, RegisterSource.Value, Error)) 561 return error(Error, RegisterSource.SourceRange); 562 CSIInfo.push_back(CalleeSavedInfo(Reg, FrameIdx)); 563 return false; 564 } 565 566 /// Verify that given node is of a certain type. Return true on error. 567 template <typename T> 568 static bool typecheckMDNode(T *&Result, MDNode *Node, 569 const yaml::StringValue &Source, 570 StringRef TypeString, MIRParserImpl &Parser) { 571 if (!Node) 572 return false; 573 Result = dyn_cast<T>(Node); 574 if (!Result) 575 return Parser.error(Source.SourceRange.Start, 576 "expected a reference to a '" + TypeString + 577 "' metadata node"); 578 return false; 579 } 580 581 bool MIRParserImpl::parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS, 582 const yaml::MachineStackObject &Object, int FrameIdx) { 583 // Debug information can only be attached to stack objects; Fixed stack 584 // objects aren't supported. 585 assert(FrameIdx >= 0 && "Expected a stack object frame index"); 586 MDNode *Var = nullptr, *Expr = nullptr, *Loc = nullptr; 587 if (parseMDNode(PFS, Var, Object.DebugVar) || 588 parseMDNode(PFS, Expr, Object.DebugExpr) || 589 parseMDNode(PFS, Loc, Object.DebugLoc)) 590 return true; 591 if (!Var && !Expr && !Loc) 592 return false; 593 DILocalVariable *DIVar = nullptr; 594 DIExpression *DIExpr = nullptr; 595 DILocation *DILoc = nullptr; 596 if (typecheckMDNode(DIVar, Var, Object.DebugVar, "DILocalVariable", *this) || 597 typecheckMDNode(DIExpr, Expr, Object.DebugExpr, "DIExpression", *this) || 598 typecheckMDNode(DILoc, Loc, Object.DebugLoc, "DILocation", *this)) 599 return true; 600 PFS.MF.getMMI().setVariableDbgInfo(DIVar, DIExpr, unsigned(FrameIdx), DILoc); 601 return false; 602 } 603 604 bool MIRParserImpl::parseMDNode(const PerFunctionMIParsingState &PFS, 605 MDNode *&Node, const yaml::StringValue &Source) { 606 if (Source.Value.empty()) 607 return false; 608 SMDiagnostic Error; 609 if (llvm::parseMDNode(PFS, Node, Source.Value, Error)) 610 return error(Error, Source.SourceRange); 611 return false; 612 } 613 614 bool MIRParserImpl::initializeConstantPool(PerFunctionMIParsingState &PFS, 615 MachineConstantPool &ConstantPool, const yaml::MachineFunction &YamlMF) { 616 DenseMap<unsigned, unsigned> &ConstantPoolSlots = PFS.ConstantPoolSlots; 617 const MachineFunction &MF = PFS.MF; 618 const auto &M = *MF.getFunction()->getParent(); 619 SMDiagnostic Error; 620 for (const auto &YamlConstant : YamlMF.Constants) { 621 const Constant *Value = dyn_cast_or_null<Constant>( 622 parseConstantValue(YamlConstant.Value.Value, Error, M)); 623 if (!Value) 624 return error(Error, YamlConstant.Value.SourceRange); 625 unsigned Alignment = 626 YamlConstant.Alignment 627 ? YamlConstant.Alignment 628 : M.getDataLayout().getPrefTypeAlignment(Value->getType()); 629 unsigned Index = ConstantPool.getConstantPoolIndex(Value, Alignment); 630 if (!ConstantPoolSlots.insert(std::make_pair(YamlConstant.ID.Value, Index)) 631 .second) 632 return error(YamlConstant.ID.SourceRange.Start, 633 Twine("redefinition of constant pool item '%const.") + 634 Twine(YamlConstant.ID.Value) + "'"); 635 } 636 return false; 637 } 638 639 bool MIRParserImpl::initializeJumpTableInfo(PerFunctionMIParsingState &PFS, 640 const yaml::MachineJumpTable &YamlJTI) { 641 MachineJumpTableInfo *JTI = PFS.MF.getOrCreateJumpTableInfo(YamlJTI.Kind); 642 for (const auto &Entry : YamlJTI.Entries) { 643 std::vector<MachineBasicBlock *> Blocks; 644 for (const auto &MBBSource : Entry.Blocks) { 645 MachineBasicBlock *MBB = nullptr; 646 if (parseMBBReference(PFS, MBB, MBBSource.Value)) 647 return true; 648 Blocks.push_back(MBB); 649 } 650 unsigned Index = JTI->createJumpTableIndex(Blocks); 651 if (!PFS.JumpTableSlots.insert(std::make_pair(Entry.ID.Value, Index)) 652 .second) 653 return error(Entry.ID.SourceRange.Start, 654 Twine("redefinition of jump table entry '%jump-table.") + 655 Twine(Entry.ID.Value) + "'"); 656 } 657 return false; 658 } 659 660 bool MIRParserImpl::parseMBBReference(const PerFunctionMIParsingState &PFS, 661 MachineBasicBlock *&MBB, 662 const yaml::StringValue &Source) { 663 SMDiagnostic Error; 664 if (llvm::parseMBBReference(PFS, MBB, Source.Value, Error)) 665 return error(Error, Source.SourceRange); 666 return false; 667 } 668 669 SMDiagnostic MIRParserImpl::diagFromMIStringDiag(const SMDiagnostic &Error, 670 SMRange SourceRange) { 671 assert(SourceRange.isValid() && "Invalid source range"); 672 SMLoc Loc = SourceRange.Start; 673 bool HasQuote = Loc.getPointer() < SourceRange.End.getPointer() && 674 *Loc.getPointer() == '\''; 675 // Translate the location of the error from the location in the MI string to 676 // the corresponding location in the MIR file. 677 Loc = Loc.getFromPointer(Loc.getPointer() + Error.getColumnNo() + 678 (HasQuote ? 1 : 0)); 679 680 // TODO: Translate any source ranges as well. 681 return SM.GetMessage(Loc, Error.getKind(), Error.getMessage(), None, 682 Error.getFixIts()); 683 } 684 685 SMDiagnostic MIRParserImpl::diagFromBlockStringDiag(const SMDiagnostic &Error, 686 SMRange SourceRange) { 687 assert(SourceRange.isValid()); 688 689 // Translate the location of the error from the location in the llvm IR string 690 // to the corresponding location in the MIR file. 691 auto LineAndColumn = SM.getLineAndColumn(SourceRange.Start); 692 unsigned Line = LineAndColumn.first + Error.getLineNo() - 1; 693 unsigned Column = Error.getColumnNo(); 694 StringRef LineStr = Error.getLineContents(); 695 SMLoc Loc = Error.getLoc(); 696 697 // Get the full line and adjust the column number by taking the indentation of 698 // LLVM IR into account. 699 for (line_iterator L(*SM.getMemoryBuffer(SM.getMainFileID()), false), E; 700 L != E; ++L) { 701 if (L.line_number() == Line) { 702 LineStr = *L; 703 Loc = SMLoc::getFromPointer(LineStr.data()); 704 auto Indent = LineStr.find(Error.getLineContents()); 705 if (Indent != StringRef::npos) 706 Column += Indent; 707 break; 708 } 709 } 710 711 return SMDiagnostic(SM, Loc, Filename, Line, Column, Error.getKind(), 712 Error.getMessage(), LineStr, Error.getRanges(), 713 Error.getFixIts()); 714 } 715 716 void MIRParserImpl::initNames2RegClasses(const MachineFunction &MF) { 717 if (!Names2RegClasses.empty()) 718 return; 719 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo(); 720 for (unsigned I = 0, E = TRI->getNumRegClasses(); I < E; ++I) { 721 const auto *RC = TRI->getRegClass(I); 722 Names2RegClasses.insert( 723 std::make_pair(StringRef(TRI->getRegClassName(RC)).lower(), RC)); 724 } 725 } 726 727 void MIRParserImpl::initNames2RegBanks(const MachineFunction &MF) { 728 if (!Names2RegBanks.empty()) 729 return; 730 const RegisterBankInfo *RBI = MF.getSubtarget().getRegBankInfo(); 731 // If the target does not support GlobalISel, we may not have a 732 // register bank info. 733 if (!RBI) 734 return; 735 for (unsigned I = 0, E = RBI->getNumRegBanks(); I < E; ++I) { 736 const auto &RegBank = RBI->getRegBank(I); 737 Names2RegBanks.insert( 738 std::make_pair(StringRef(RegBank.getName()).lower(), &RegBank)); 739 } 740 } 741 742 const TargetRegisterClass *MIRParserImpl::getRegClass(const MachineFunction &MF, 743 StringRef Name) { 744 initNames2RegClasses(MF); 745 auto RegClassInfo = Names2RegClasses.find(Name); 746 if (RegClassInfo == Names2RegClasses.end()) 747 return nullptr; 748 return RegClassInfo->getValue(); 749 } 750 751 const RegisterBank *MIRParserImpl::getRegBank(const MachineFunction &MF, 752 StringRef Name) { 753 initNames2RegBanks(MF); 754 auto RegBankInfo = Names2RegBanks.find(Name); 755 if (RegBankInfo == Names2RegBanks.end()) 756 return nullptr; 757 return RegBankInfo->getValue(); 758 } 759 760 MIRParser::MIRParser(std::unique_ptr<MIRParserImpl> Impl) 761 : Impl(std::move(Impl)) {} 762 763 MIRParser::~MIRParser() {} 764 765 std::unique_ptr<Module> MIRParser::parseLLVMModule() { return Impl->parse(); } 766 767 bool MIRParser::initializeMachineFunction(MachineFunction &MF) { 768 return Impl->initializeMachineFunction(MF); 769 } 770 771 std::unique_ptr<MIRParser> llvm::createMIRParserFromFile(StringRef Filename, 772 SMDiagnostic &Error, 773 LLVMContext &Context) { 774 auto FileOrErr = MemoryBuffer::getFile(Filename); 775 if (std::error_code EC = FileOrErr.getError()) { 776 Error = SMDiagnostic(Filename, SourceMgr::DK_Error, 777 "Could not open input file: " + EC.message()); 778 return nullptr; 779 } 780 return createMIRParser(std::move(FileOrErr.get()), Context); 781 } 782 783 std::unique_ptr<MIRParser> 784 llvm::createMIRParser(std::unique_ptr<MemoryBuffer> Contents, 785 LLVMContext &Context) { 786 auto Filename = Contents->getBufferIdentifier(); 787 return llvm::make_unique<MIRParser>( 788 llvm::make_unique<MIRParserImpl>(std::move(Contents), Filename, Context)); 789 } 790