1 //===- MIRParser.cpp - MIR serialization format parser implementation -----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the class that parses the optional LLVM IR and machine
11 // functions that are stored in MIR files.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/CodeGen/MIRParser/MIRParser.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"
49 /// This class implements the parsing of LLVM IR that's embedded inside a MIR
57 /// Maps from register class names to register classes.
58 Name2RegClassMap Names2RegClasses;
59 /// Maps from register bank names to register banks.
60 Name2RegBankMap Names2RegBanks;
61 /// True when the MIR file doesn't have LLVM IR. Dummy IR functions are
62 /// created and inserted into the given module when this is true.
63 bool NoLLVMIR = false;
64 /// True when a well formed MIR file does not contain any MIR/machine function
66 bool NoMIRDocuments = false;
69 MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
70 StringRef Filename, LLVMContext &Context);
72 void reportDiagnostic(const SMDiagnostic &Diag);
74 /// Report an error with the given message at unknown location.
76 /// Always returns true.
77 bool error(const Twine &Message);
79 /// Report an error with the given message at the given location.
81 /// Always returns true.
82 bool error(SMLoc Loc, const Twine &Message);
84 /// Report a given error with the location translated from the location in an
85 /// embedded string literal to a location in the MIR file.
87 /// Always returns true.
88 bool error(const SMDiagnostic &Error, SMRange SourceRange);
90 /// Try to parse the optional LLVM module and the machine functions in the MIR
93 /// Return null if an error occurred.
94 std::unique_ptr<Module> parseIRModule();
96 bool parseMachineFunctions(Module &M, MachineModuleInfo &MMI);
98 /// Parse the machine function in the current YAML document.
101 /// Return true if an error occurred.
102 bool parseMachineFunction(Module &M, MachineModuleInfo &MMI);
104 /// Initialize the machine function to the state that's described in the MIR
107 /// Return true if error occurred.
108 bool initializeMachineFunction(const yaml::MachineFunction &YamlMF,
109 MachineFunction &MF);
111 bool parseRegisterInfo(PerFunctionMIParsingState &PFS,
112 const yaml::MachineFunction &YamlMF);
114 bool setupRegisterInfo(const PerFunctionMIParsingState &PFS,
115 const yaml::MachineFunction &YamlMF);
117 bool initializeFrameInfo(PerFunctionMIParsingState &PFS,
118 const yaml::MachineFunction &YamlMF);
120 bool parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
121 std::vector<CalleeSavedInfo> &CSIInfo,
122 const yaml::StringValue &RegisterSource,
123 bool IsRestored, int FrameIdx);
125 bool parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
126 const yaml::MachineStackObject &Object,
129 bool initializeConstantPool(PerFunctionMIParsingState &PFS,
130 MachineConstantPool &ConstantPool,
131 const yaml::MachineFunction &YamlMF);
133 bool initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
134 const yaml::MachineJumpTable &YamlJTI);
137 bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node,
138 const yaml::StringValue &Source);
140 bool parseMBBReference(PerFunctionMIParsingState &PFS,
141 MachineBasicBlock *&MBB,
142 const yaml::StringValue &Source);
144 /// Return a MIR diagnostic converted from an MI string diagnostic.
145 SMDiagnostic diagFromMIStringDiag(const SMDiagnostic &Error,
146 SMRange SourceRange);
148 /// Return a MIR diagnostic converted from a diagnostic located in a YAML
149 /// block scalar string.
150 SMDiagnostic diagFromBlockStringDiag(const SMDiagnostic &Error,
151 SMRange SourceRange);
153 void initNames2RegClasses(const MachineFunction &MF);
154 void initNames2RegBanks(const MachineFunction &MF);
156 /// Check if the given identifier is a name of a register class.
158 /// Return null if the name isn't a register class.
159 const TargetRegisterClass *getRegClass(const MachineFunction &MF,
162 /// Check if the given identifier is a name of a register bank.
164 /// Return null if the name isn't a register bank.
165 const RegisterBank *getRegBank(const MachineFunction &MF, StringRef Name);
167 void computeFunctionProperties(MachineFunction &MF);
170 } // end namespace llvm
172 static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) {
173 reinterpret_cast<MIRParserImpl *>(Context)->reportDiagnostic(Diag);
176 MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
177 StringRef Filename, LLVMContext &Context)
179 In(SM.getMemoryBuffer(
180 SM.AddNewSourceBuffer(std::move(Contents), SMLoc()))->getBuffer(),
181 nullptr, handleYAMLDiag, this),
187 bool MIRParserImpl::error(const Twine &Message) {
188 Context.diagnose(DiagnosticInfoMIRParser(
189 DS_Error, SMDiagnostic(Filename, SourceMgr::DK_Error, Message.str())));
193 bool MIRParserImpl::error(SMLoc Loc, const Twine &Message) {
194 Context.diagnose(DiagnosticInfoMIRParser(
195 DS_Error, SM.GetMessage(Loc, SourceMgr::DK_Error, Message)));
199 bool MIRParserImpl::error(const SMDiagnostic &Error, SMRange SourceRange) {
200 assert(Error.getKind() == SourceMgr::DK_Error && "Expected an error");
201 reportDiagnostic(diagFromMIStringDiag(Error, SourceRange));
205 void MIRParserImpl::reportDiagnostic(const SMDiagnostic &Diag) {
206 DiagnosticSeverity Kind;
207 switch (Diag.getKind()) {
208 case SourceMgr::DK_Error:
211 case SourceMgr::DK_Warning:
214 case SourceMgr::DK_Note:
217 case SourceMgr::DK_Remark:
218 llvm_unreachable("remark unexpected");
221 Context.diagnose(DiagnosticInfoMIRParser(Kind, Diag));
224 std::unique_ptr<Module> MIRParserImpl::parseIRModule() {
225 if (!In.setCurrentDocument()) {
228 // Create an empty module when the MIR file is empty.
229 NoMIRDocuments = true;
230 return llvm::make_unique<Module>(Filename, Context);
233 std::unique_ptr<Module> M;
234 // Parse the block scalar manually so that we can return unique pointer
235 // without having to go trough YAML traits.
236 if (const auto *BSN =
237 dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
239 M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
242 reportDiagnostic(diagFromBlockStringDiag(Error, BSN->getSourceRange()));
246 if (!In.setCurrentDocument())
247 NoMIRDocuments = true;
249 // Create an new, empty module.
250 M = llvm::make_unique<Module>(Filename, Context);
256 bool MIRParserImpl::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
260 // Parse the machine functions.
262 if (parseMachineFunction(M, MMI))
265 } while (In.setCurrentDocument());
270 /// Create an empty function with the given name.
271 static Function *createDummyFunction(StringRef Name, Module &M) {
272 auto &Context = M.getContext();
273 Function *F = cast<Function>(M.getOrInsertFunction(
274 Name, FunctionType::get(Type::getVoidTy(Context), false)));
275 BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
276 new UnreachableInst(Context, BB);
280 bool MIRParserImpl::parseMachineFunction(Module &M, MachineModuleInfo &MMI) {
282 yaml::MachineFunction YamlMF;
283 yaml::EmptyContext Ctx;
284 yaml::yamlize(In, YamlMF, false, Ctx);
288 // Search for the corresponding IR function.
289 StringRef FunctionName = YamlMF.Name;
290 Function *F = M.getFunction(FunctionName);
293 F = createDummyFunction(FunctionName, M);
295 return error(Twine("function '") + FunctionName +
296 "' isn't defined in the provided LLVM IR");
299 if (MMI.getMachineFunction(*F) != nullptr)
300 return error(Twine("redefinition of machine function '") + FunctionName +
303 // Create the MachineFunction.
304 MachineFunction &MF = MMI.getOrCreateMachineFunction(*F);
305 if (initializeMachineFunction(YamlMF, MF))
311 static bool isSSA(const MachineFunction &MF) {
312 const MachineRegisterInfo &MRI = MF.getRegInfo();
313 for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
314 unsigned Reg = TargetRegisterInfo::index2VirtReg(I);
315 if (!MRI.hasOneDef(Reg) && !MRI.def_empty(Reg))
321 void MIRParserImpl::computeFunctionProperties(MachineFunction &MF) {
322 MachineFunctionProperties &Properties = MF.getProperties();
325 bool HasInlineAsm = false;
326 for (const MachineBasicBlock &MBB : MF) {
327 for (const MachineInstr &MI : MBB) {
330 if (MI.isInlineAsm())
335 Properties.set(MachineFunctionProperties::Property::NoPHIs);
336 MF.setHasInlineAsm(HasInlineAsm);
339 Properties.set(MachineFunctionProperties::Property::IsSSA);
341 Properties.reset(MachineFunctionProperties::Property::IsSSA);
343 const MachineRegisterInfo &MRI = MF.getRegInfo();
344 if (MRI.getNumVirtRegs() == 0)
345 Properties.set(MachineFunctionProperties::Property::NoVRegs);
349 MIRParserImpl::initializeMachineFunction(const yaml::MachineFunction &YamlMF,
350 MachineFunction &MF) {
351 // TODO: Recreate the machine function.
352 initNames2RegClasses(MF);
353 initNames2RegBanks(MF);
354 if (YamlMF.Alignment)
355 MF.setAlignment(YamlMF.Alignment);
356 MF.setExposesReturnsTwice(YamlMF.ExposesReturnsTwice);
358 if (YamlMF.Legalized)
359 MF.getProperties().set(MachineFunctionProperties::Property::Legalized);
360 if (YamlMF.RegBankSelected)
361 MF.getProperties().set(
362 MachineFunctionProperties::Property::RegBankSelected);
364 MF.getProperties().set(MachineFunctionProperties::Property::Selected);
366 PerFunctionMIParsingState PFS(MF, SM, IRSlots, Names2RegClasses,
368 if (parseRegisterInfo(PFS, YamlMF))
370 if (!YamlMF.Constants.empty()) {
371 auto *ConstantPool = MF.getConstantPool();
372 assert(ConstantPool && "Constant pool must be created");
373 if (initializeConstantPool(PFS, *ConstantPool, YamlMF))
377 StringRef BlockStr = YamlMF.Body.Value.Value;
380 BlockSM.AddNewSourceBuffer(
381 MemoryBuffer::getMemBuffer(BlockStr, "",/*RequiresNullTerminator=*/false),
384 if (parseMachineBasicBlockDefinitions(PFS, BlockStr, Error)) {
386 diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
391 // Initialize the frame information after creating all the MBBs so that the
392 // MBB references in the frame information can be resolved.
393 if (initializeFrameInfo(PFS, YamlMF))
395 // Initialize the jump table after creating all the MBBs so that the MBB
396 // references can be resolved.
397 if (!YamlMF.JumpTableInfo.Entries.empty() &&
398 initializeJumpTableInfo(PFS, YamlMF.JumpTableInfo))
400 // Parse the machine instructions after creating all of the MBBs so that the
401 // parser can resolve the MBB references.
402 StringRef InsnStr = YamlMF.Body.Value.Value;
404 InsnSM.AddNewSourceBuffer(
405 MemoryBuffer::getMemBuffer(InsnStr, "", /*RequiresNullTerminator=*/false),
408 if (parseMachineInstructions(PFS, InsnStr, Error)) {
410 diagFromBlockStringDiag(Error, YamlMF.Body.Value.SourceRange));
415 if (setupRegisterInfo(PFS, YamlMF))
418 computeFunctionProperties(MF);
424 bool MIRParserImpl::parseRegisterInfo(PerFunctionMIParsingState &PFS,
425 const yaml::MachineFunction &YamlMF) {
426 MachineFunction &MF = PFS.MF;
427 MachineRegisterInfo &RegInfo = MF.getRegInfo();
428 assert(RegInfo.tracksLiveness());
429 if (!YamlMF.TracksRegLiveness)
430 RegInfo.invalidateLiveness();
433 // Parse the virtual register information.
434 for (const auto &VReg : YamlMF.VirtualRegisters) {
435 VRegInfo &Info = PFS.getVRegInfo(VReg.ID.Value);
437 return error(VReg.ID.SourceRange.Start,
438 Twine("redefinition of virtual register '%") +
439 Twine(VReg.ID.Value) + "'");
440 Info.Explicit = true;
442 if (StringRef(VReg.Class.Value).equals("_")) {
443 Info.Kind = VRegInfo::GENERIC;
444 Info.D.RegBank = nullptr;
446 const auto *RC = getRegClass(MF, VReg.Class.Value);
448 Info.Kind = VRegInfo::NORMAL;
451 const RegisterBank *RegBank = getRegBank(MF, VReg.Class.Value);
454 VReg.Class.SourceRange.Start,
455 Twine("use of undefined register class or register bank '") +
456 VReg.Class.Value + "'");
457 Info.Kind = VRegInfo::REGBANK;
458 Info.D.RegBank = RegBank;
462 if (!VReg.PreferredRegister.Value.empty()) {
463 if (Info.Kind != VRegInfo::NORMAL)
464 return error(VReg.Class.SourceRange.Start,
465 Twine("preferred register can only be set for normal vregs"));
467 if (parseRegisterReference(PFS, Info.PreferredReg,
468 VReg.PreferredRegister.Value, Error))
469 return error(Error, VReg.PreferredRegister.SourceRange);
473 // Parse the liveins.
474 for (const auto &LiveIn : YamlMF.LiveIns) {
476 if (parseNamedRegisterReference(PFS, Reg, LiveIn.Register.Value, Error))
477 return error(Error, LiveIn.Register.SourceRange);
479 if (!LiveIn.VirtualRegister.Value.empty()) {
481 if (parseVirtualRegisterReference(PFS, Info, LiveIn.VirtualRegister.Value,
483 return error(Error, LiveIn.VirtualRegister.SourceRange);
486 RegInfo.addLiveIn(Reg, VReg);
489 // Parse the callee saved registers (Registers that will
490 // be saved for the caller).
491 if (YamlMF.CalleeSavedRegisters) {
492 SmallVector<MCPhysReg, 16> CalleeSavedRegisters;
493 for (const auto &RegSource : YamlMF.CalleeSavedRegisters.getValue()) {
495 if (parseNamedRegisterReference(PFS, Reg, RegSource.Value, Error))
496 return error(Error, RegSource.SourceRange);
497 CalleeSavedRegisters.push_back(Reg);
499 RegInfo.setCalleeSavedRegs(CalleeSavedRegisters);
505 bool MIRParserImpl::setupRegisterInfo(const PerFunctionMIParsingState &PFS,
506 const yaml::MachineFunction &YamlMF) {
507 MachineFunction &MF = PFS.MF;
508 MachineRegisterInfo &MRI = MF.getRegInfo();
511 for (auto P : PFS.VRegInfos) {
512 const VRegInfo &Info = *P.second;
513 unsigned Reg = Info.VReg;
515 case VRegInfo::UNKNOWN:
516 error(Twine("Cannot determine class/bank of virtual register ") +
517 Twine(P.first) + " in function '" + MF.getName() + "'");
520 case VRegInfo::NORMAL:
521 MRI.setRegClass(Reg, Info.D.RC);
522 if (Info.PreferredReg != 0)
523 MRI.setSimpleHint(Reg, Info.PreferredReg);
525 case VRegInfo::GENERIC:
527 case VRegInfo::REGBANK:
528 MRI.setRegBank(Reg, *Info.D.RegBank);
533 // Compute MachineRegisterInfo::UsedPhysRegMask
534 for (const MachineBasicBlock &MBB : MF) {
535 for (const MachineInstr &MI : MBB) {
536 for (const MachineOperand &MO : MI.operands()) {
539 MRI.addPhysRegsUsedFromRegMask(MO.getRegMask());
544 // FIXME: This is a temporary workaround until the reserved registers can be
546 MRI.freezeReservedRegs(MF);
550 bool MIRParserImpl::initializeFrameInfo(PerFunctionMIParsingState &PFS,
551 const yaml::MachineFunction &YamlMF) {
552 MachineFunction &MF = PFS.MF;
553 MachineFrameInfo &MFI = MF.getFrameInfo();
554 const Function &F = MF.getFunction();
555 const yaml::MachineFrameInfo &YamlMFI = YamlMF.FrameInfo;
556 MFI.setFrameAddressIsTaken(YamlMFI.IsFrameAddressTaken);
557 MFI.setReturnAddressIsTaken(YamlMFI.IsReturnAddressTaken);
558 MFI.setHasStackMap(YamlMFI.HasStackMap);
559 MFI.setHasPatchPoint(YamlMFI.HasPatchPoint);
560 MFI.setStackSize(YamlMFI.StackSize);
561 MFI.setOffsetAdjustment(YamlMFI.OffsetAdjustment);
562 if (YamlMFI.MaxAlignment)
563 MFI.ensureMaxAlignment(YamlMFI.MaxAlignment);
564 MFI.setAdjustsStack(YamlMFI.AdjustsStack);
565 MFI.setHasCalls(YamlMFI.HasCalls);
566 if (YamlMFI.MaxCallFrameSize != ~0u)
567 MFI.setMaxCallFrameSize(YamlMFI.MaxCallFrameSize);
568 MFI.setHasOpaqueSPAdjustment(YamlMFI.HasOpaqueSPAdjustment);
569 MFI.setHasVAStart(YamlMFI.HasVAStart);
570 MFI.setHasMustTailInVarArgFunc(YamlMFI.HasMustTailInVarArgFunc);
571 if (!YamlMFI.SavePoint.Value.empty()) {
572 MachineBasicBlock *MBB = nullptr;
573 if (parseMBBReference(PFS, MBB, YamlMFI.SavePoint))
575 MFI.setSavePoint(MBB);
577 if (!YamlMFI.RestorePoint.Value.empty()) {
578 MachineBasicBlock *MBB = nullptr;
579 if (parseMBBReference(PFS, MBB, YamlMFI.RestorePoint))
581 MFI.setRestorePoint(MBB);
584 std::vector<CalleeSavedInfo> CSIInfo;
585 // Initialize the fixed frame objects.
586 for (const auto &Object : YamlMF.FixedStackObjects) {
588 if (Object.Type != yaml::FixedMachineStackObject::SpillSlot)
589 ObjectIdx = MFI.CreateFixedObject(Object.Size, Object.Offset,
590 Object.IsImmutable, Object.IsAliased);
592 ObjectIdx = MFI.CreateFixedSpillStackObject(Object.Size, Object.Offset);
593 MFI.setObjectAlignment(ObjectIdx, Object.Alignment);
594 MFI.setStackID(ObjectIdx, Object.StackID);
595 if (!PFS.FixedStackObjectSlots.insert(std::make_pair(Object.ID.Value,
598 return error(Object.ID.SourceRange.Start,
599 Twine("redefinition of fixed stack object '%fixed-stack.") +
600 Twine(Object.ID.Value) + "'");
601 if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
602 Object.CalleeSavedRestored, ObjectIdx))
606 // Initialize the ordinary frame objects.
607 for (const auto &Object : YamlMF.StackObjects) {
609 const AllocaInst *Alloca = nullptr;
610 const yaml::StringValue &Name = Object.Name;
611 if (!Name.Value.empty()) {
612 Alloca = dyn_cast_or_null<AllocaInst>(
613 F.getValueSymbolTable()->lookup(Name.Value));
615 return error(Name.SourceRange.Start,
616 "alloca instruction named '" + Name.Value +
617 "' isn't defined in the function '" + F.getName() +
620 if (Object.Type == yaml::MachineStackObject::VariableSized)
621 ObjectIdx = MFI.CreateVariableSizedObject(Object.Alignment, Alloca);
623 ObjectIdx = MFI.CreateStackObject(
624 Object.Size, Object.Alignment,
625 Object.Type == yaml::MachineStackObject::SpillSlot, Alloca);
626 MFI.setObjectOffset(ObjectIdx, Object.Offset);
627 MFI.setStackID(ObjectIdx, Object.StackID);
629 if (!PFS.StackObjectSlots.insert(std::make_pair(Object.ID.Value, ObjectIdx))
631 return error(Object.ID.SourceRange.Start,
632 Twine("redefinition of stack object '%stack.") +
633 Twine(Object.ID.Value) + "'");
634 if (parseCalleeSavedRegister(PFS, CSIInfo, Object.CalleeSavedRegister,
635 Object.CalleeSavedRestored, ObjectIdx))
637 if (Object.LocalOffset)
638 MFI.mapLocalFrameObject(ObjectIdx, Object.LocalOffset.getValue());
639 if (parseStackObjectsDebugInfo(PFS, Object, ObjectIdx))
642 MFI.setCalleeSavedInfo(CSIInfo);
643 if (!CSIInfo.empty())
644 MFI.setCalleeSavedInfoValid(true);
646 // Initialize the various stack object references after initializing the
648 if (!YamlMFI.StackProtector.Value.empty()) {
651 if (parseStackObjectReference(PFS, FI, YamlMFI.StackProtector.Value, Error))
652 return error(Error, YamlMFI.StackProtector.SourceRange);
653 MFI.setStackProtectorIndex(FI);
658 bool MIRParserImpl::parseCalleeSavedRegister(PerFunctionMIParsingState &PFS,
659 std::vector<CalleeSavedInfo> &CSIInfo,
660 const yaml::StringValue &RegisterSource, bool IsRestored, int FrameIdx) {
661 if (RegisterSource.Value.empty())
665 if (parseNamedRegisterReference(PFS, Reg, RegisterSource.Value, Error))
666 return error(Error, RegisterSource.SourceRange);
667 CalleeSavedInfo CSI(Reg, FrameIdx);
668 CSI.setRestored(IsRestored);
669 CSIInfo.push_back(CSI);
673 /// Verify that given node is of a certain type. Return true on error.
674 template <typename T>
675 static bool typecheckMDNode(T *&Result, MDNode *Node,
676 const yaml::StringValue &Source,
677 StringRef TypeString, MIRParserImpl &Parser) {
680 Result = dyn_cast<T>(Node);
682 return Parser.error(Source.SourceRange.Start,
683 "expected a reference to a '" + TypeString +
688 bool MIRParserImpl::parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS,
689 const yaml::MachineStackObject &Object, int FrameIdx) {
690 // Debug information can only be attached to stack objects; Fixed stack
691 // objects aren't supported.
692 assert(FrameIdx >= 0 && "Expected a stack object frame index");
693 MDNode *Var = nullptr, *Expr = nullptr, *Loc = nullptr;
694 if (parseMDNode(PFS, Var, Object.DebugVar) ||
695 parseMDNode(PFS, Expr, Object.DebugExpr) ||
696 parseMDNode(PFS, Loc, Object.DebugLoc))
698 if (!Var && !Expr && !Loc)
700 DILocalVariable *DIVar = nullptr;
701 DIExpression *DIExpr = nullptr;
702 DILocation *DILoc = nullptr;
703 if (typecheckMDNode(DIVar, Var, Object.DebugVar, "DILocalVariable", *this) ||
704 typecheckMDNode(DIExpr, Expr, Object.DebugExpr, "DIExpression", *this) ||
705 typecheckMDNode(DILoc, Loc, Object.DebugLoc, "DILocation", *this))
707 PFS.MF.setVariableDbgInfo(DIVar, DIExpr, unsigned(FrameIdx), DILoc);
711 bool MIRParserImpl::parseMDNode(PerFunctionMIParsingState &PFS,
712 MDNode *&Node, const yaml::StringValue &Source) {
713 if (Source.Value.empty())
716 if (llvm::parseMDNode(PFS, Node, Source.Value, Error))
717 return error(Error, Source.SourceRange);
721 bool MIRParserImpl::initializeConstantPool(PerFunctionMIParsingState &PFS,
722 MachineConstantPool &ConstantPool, const yaml::MachineFunction &YamlMF) {
723 DenseMap<unsigned, unsigned> &ConstantPoolSlots = PFS.ConstantPoolSlots;
724 const MachineFunction &MF = PFS.MF;
725 const auto &M = *MF.getFunction().getParent();
727 for (const auto &YamlConstant : YamlMF.Constants) {
728 if (YamlConstant.IsTargetSpecific)
729 // FIXME: Support target-specific constant pools
730 return error(YamlConstant.Value.SourceRange.Start,
731 "Can't parse target-specific constant pool entries yet");
732 const Constant *Value = dyn_cast_or_null<Constant>(
733 parseConstantValue(YamlConstant.Value.Value, Error, M));
735 return error(Error, YamlConstant.Value.SourceRange);
737 YamlConstant.Alignment
738 ? YamlConstant.Alignment
739 : M.getDataLayout().getPrefTypeAlignment(Value->getType());
740 unsigned Index = ConstantPool.getConstantPoolIndex(Value, Alignment);
741 if (!ConstantPoolSlots.insert(std::make_pair(YamlConstant.ID.Value, Index))
743 return error(YamlConstant.ID.SourceRange.Start,
744 Twine("redefinition of constant pool item '%const.") +
745 Twine(YamlConstant.ID.Value) + "'");
750 bool MIRParserImpl::initializeJumpTableInfo(PerFunctionMIParsingState &PFS,
751 const yaml::MachineJumpTable &YamlJTI) {
752 MachineJumpTableInfo *JTI = PFS.MF.getOrCreateJumpTableInfo(YamlJTI.Kind);
753 for (const auto &Entry : YamlJTI.Entries) {
754 std::vector<MachineBasicBlock *> Blocks;
755 for (const auto &MBBSource : Entry.Blocks) {
756 MachineBasicBlock *MBB = nullptr;
757 if (parseMBBReference(PFS, MBB, MBBSource.Value))
759 Blocks.push_back(MBB);
761 unsigned Index = JTI->createJumpTableIndex(Blocks);
762 if (!PFS.JumpTableSlots.insert(std::make_pair(Entry.ID.Value, Index))
764 return error(Entry.ID.SourceRange.Start,
765 Twine("redefinition of jump table entry '%jump-table.") +
766 Twine(Entry.ID.Value) + "'");
771 bool MIRParserImpl::parseMBBReference(PerFunctionMIParsingState &PFS,
772 MachineBasicBlock *&MBB,
773 const yaml::StringValue &Source) {
775 if (llvm::parseMBBReference(PFS, MBB, Source.Value, Error))
776 return error(Error, Source.SourceRange);
780 SMDiagnostic MIRParserImpl::diagFromMIStringDiag(const SMDiagnostic &Error,
781 SMRange SourceRange) {
782 assert(SourceRange.isValid() && "Invalid source range");
783 SMLoc Loc = SourceRange.Start;
784 bool HasQuote = Loc.getPointer() < SourceRange.End.getPointer() &&
785 *Loc.getPointer() == '\'';
786 // Translate the location of the error from the location in the MI string to
787 // the corresponding location in the MIR file.
788 Loc = Loc.getFromPointer(Loc.getPointer() + Error.getColumnNo() +
791 // TODO: Translate any source ranges as well.
792 return SM.GetMessage(Loc, Error.getKind(), Error.getMessage(), None,
796 SMDiagnostic MIRParserImpl::diagFromBlockStringDiag(const SMDiagnostic &Error,
797 SMRange SourceRange) {
798 assert(SourceRange.isValid());
800 // Translate the location of the error from the location in the llvm IR string
801 // to the corresponding location in the MIR file.
802 auto LineAndColumn = SM.getLineAndColumn(SourceRange.Start);
803 unsigned Line = LineAndColumn.first + Error.getLineNo() - 1;
804 unsigned Column = Error.getColumnNo();
805 StringRef LineStr = Error.getLineContents();
806 SMLoc Loc = Error.getLoc();
808 // Get the full line and adjust the column number by taking the indentation of
809 // LLVM IR into account.
810 for (line_iterator L(*SM.getMemoryBuffer(SM.getMainFileID()), false), E;
812 if (L.line_number() == Line) {
814 Loc = SMLoc::getFromPointer(LineStr.data());
815 auto Indent = LineStr.find(Error.getLineContents());
816 if (Indent != StringRef::npos)
822 return SMDiagnostic(SM, Loc, Filename, Line, Column, Error.getKind(),
823 Error.getMessage(), LineStr, Error.getRanges(),
827 void MIRParserImpl::initNames2RegClasses(const MachineFunction &MF) {
828 if (!Names2RegClasses.empty())
830 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
831 for (unsigned I = 0, E = TRI->getNumRegClasses(); I < E; ++I) {
832 const auto *RC = TRI->getRegClass(I);
833 Names2RegClasses.insert(
834 std::make_pair(StringRef(TRI->getRegClassName(RC)).lower(), RC));
838 void MIRParserImpl::initNames2RegBanks(const MachineFunction &MF) {
839 if (!Names2RegBanks.empty())
841 const RegisterBankInfo *RBI = MF.getSubtarget().getRegBankInfo();
842 // If the target does not support GlobalISel, we may not have a
843 // register bank info.
846 for (unsigned I = 0, E = RBI->getNumRegBanks(); I < E; ++I) {
847 const auto &RegBank = RBI->getRegBank(I);
848 Names2RegBanks.insert(
849 std::make_pair(StringRef(RegBank.getName()).lower(), &RegBank));
853 const TargetRegisterClass *MIRParserImpl::getRegClass(const MachineFunction &MF,
855 auto RegClassInfo = Names2RegClasses.find(Name);
856 if (RegClassInfo == Names2RegClasses.end())
858 return RegClassInfo->getValue();
861 const RegisterBank *MIRParserImpl::getRegBank(const MachineFunction &MF,
863 auto RegBankInfo = Names2RegBanks.find(Name);
864 if (RegBankInfo == Names2RegBanks.end())
866 return RegBankInfo->getValue();
869 MIRParser::MIRParser(std::unique_ptr<MIRParserImpl> Impl)
870 : Impl(std::move(Impl)) {}
872 MIRParser::~MIRParser() {}
874 std::unique_ptr<Module> MIRParser::parseIRModule() {
875 return Impl->parseIRModule();
878 bool MIRParser::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
879 return Impl->parseMachineFunctions(M, MMI);
882 std::unique_ptr<MIRParser> llvm::createMIRParserFromFile(StringRef Filename,
884 LLVMContext &Context) {
885 auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
886 if (std::error_code EC = FileOrErr.getError()) {
887 Error = SMDiagnostic(Filename, SourceMgr::DK_Error,
888 "Could not open input file: " + EC.message());
891 return createMIRParser(std::move(FileOrErr.get()), Context);
894 std::unique_ptr<MIRParser>
895 llvm::createMIRParser(std::unique_ptr<MemoryBuffer> Contents,
896 LLVMContext &Context) {
897 auto Filename = Contents->getBufferIdentifier();
898 if (Context.shouldDiscardValueNames()) {
899 Context.diagnose(DiagnosticInfoMIRParser(
902 Filename, SourceMgr::DK_Error,
903 "Can't read MIR with a Context that discards named Values")));
906 return llvm::make_unique<MIRParser>(
907 llvm::make_unique<MIRParserImpl>(std::move(Contents), Filename, Context));