57 std::unique_ptr<PerTargetMIParsingState>
Target;
61 bool NoLLVMIR =
false;
64 bool NoMIRDocuments =
false;
66 std::function<void(
Function &)> ProcessIRFunction;
71 std::function<
void(
Function &)> ProcessIRFunction);
95 std::unique_ptr<Module>
129 std::vector<CalleeSavedInfo> &CSIInfo,
131 bool IsRestored,
int FrameIdx);
133 template <
typename T>
183 std::function<
void(
Function &)> Callback)
185 In(SM.getMemoryBuffer(SM.AddNewSourceBuffer(
std::
move(Contents),
SMLoc()))
188 Filename(Filename), ProcessIRFunction(Callback) {
229std::unique_ptr<Module>
231 if (!In.setCurrentDocument()) {
235 NoMIRDocuments =
true;
236 auto M = std::make_unique<Module>(Filename,
Context);
237 if (
auto LayoutOverride =
238 DataLayoutCallback(M->getTargetTriple(), M->getDataLayoutStr()))
239 M->setDataLayout(*LayoutOverride);
243 std::unique_ptr<Module> M;
246 if (
const auto *BSN =
247 dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
250 Context, &IRSlots, DataLayoutCallback);
256 if (!In.setCurrentDocument())
257 NoMIRDocuments =
true;
260 M = std::make_unique<Module>(Filename,
Context);
261 if (
auto LayoutOverride =
262 DataLayoutCallback(M->getTargetTriple(), M->getDataLayoutStr()))
263 M->setDataLayout(*LayoutOverride);
278 }
while (In.setCurrentDocument());
284 auto &
Context = M.getContext();
291 if (ProcessIRFunction)
292 ProcessIRFunction(*
F);
300 yaml::EmptyContext Ctx;
304 TM.createDefaultFuncInfoYAML());
306 yaml::yamlize(In, YamlMF,
false, Ctx);
312 Function *
F = M.getFunction(FunctionName);
317 return error(
Twine(
"function '") + FunctionName +
318 "' isn't defined in the provided LLVM IR");
322 return error(
Twine(
"redefinition of machine function '") + FunctionName +
335 for (
unsigned I = 0,
E =
MRI.getNumVirtRegs();
I !=
E; ++
I) {
337 if (!
MRI.hasOneDef(Reg) && !
MRI.def_empty(Reg))
352 bool HasInlineAsm =
false;
353 bool AllTiedOpsRewritten =
true, HasTiedOps =
false;
358 if (
MI.isInlineAsm())
360 for (
unsigned I = 0;
I <
MI.getNumOperands(); ++
I) {
365 if (MO.
isUse() &&
MI.isRegTiedToDefOperand(
I, &DefIdx)) {
367 if (MO.
getReg() !=
MI.getOperand(DefIdx).getReg())
368 AllTiedOpsRewritten =
false;
375 MF.setHasInlineAsm(HasInlineAsm);
377 if (HasTiedOps && AllTiedOpsRewritten)
386 if (
MRI.getNumVirtRegs() == 0)
399 Twine(
" call instruction block out of range.") +
402 if (MILoc.
Offset >= CallB->size())
404 Twine(
" call instruction offset out of range.") +
405 " Unable to reference instruction at bb: " +
407 auto CallI = std::next(CallB->instr_begin(), MILoc.
Offset);
410 Twine(
" call site info should reference call "
411 "instruction. Instruction at bb:") +
413 " is not a call instruction");
415 for (
auto ArgRegPair : YamlCSInfo.ArgForwardingRegs) {
418 return error(
Error, ArgRegPair.Reg.SourceRange);
422 if (
TM.Options.EmitCallSiteInfo)
427 return error(
Twine(
"Call site info provided but not used"));
431void MIRParserImpl::setupDebugValueTracking(
435 unsigned MaxInstrNum = 0;
438 MaxInstrNum = std::max((
unsigned)
MI.peekDebugInstrNum(), MaxInstrNum);
439 MF.setDebugInstrNumberingCount(MaxInstrNum);
443 MF.makeDebugValueSubstitution({Sub.SrcInst, Sub.SrcOp},
444 {Sub.DstInst, Sub.DstOp}, Sub.Subreg);
567 MRI.freezeReservedRegs(MF);
569 computeFunctionProperties(MF);
574 setupDebugValueTracking(MF, PFS, YamlMF);
595 return error(VReg.ID.SourceRange.Start,
596 Twine(
"redefinition of virtual register '%") +
597 Twine(VReg.ID.Value) +
"'");
598 Info.Explicit =
true;
602 Info.D.RegBank =
nullptr;
604 const auto *RC =
Target->getRegClass(VReg.Class.Value);
612 VReg.Class.SourceRange.Start,
613 Twine(
"use of undefined register class or register bank '") +
614 VReg.Class.Value +
"'");
616 Info.D.RegBank = RegBank;
620 if (!VReg.PreferredRegister.Value.empty()) {
622 return error(VReg.Class.SourceRange.Start,
623 Twine(
"preferred register can only be set for normal vregs"));
626 VReg.PreferredRegister.Value,
Error))
627 return error(
Error, VReg.PreferredRegister.SourceRange);
632 for (
const auto &LiveIn : YamlMF.
LiveIns) {
635 return error(
Error, LiveIn.Register.SourceRange);
637 if (!LiveIn.VirtualRegister.Value.empty()) {
641 return error(
Error, LiveIn.VirtualRegister.SourceRange);
675 error(
Twine(
"Cannot determine class/bank of virtual register ") +
680 if (!
Info.D.RC->isAllocatable()) {
681 error(
Twine(
"Cannot use non-allocatable class '") +
682 TRI->getRegClassName(
Info.D.RC) +
"' for virtual register " +
688 MRI.setRegClass(Reg,
Info.D.RC);
689 if (
Info.PreferredReg != 0)
690 MRI.setSimpleHint(Reg,
Info.PreferredReg);
695 MRI.setRegBank(Reg, *
Info.D.RegBank);
714 if (
auto *RegMask =
TRI->getCustomEHPadPreservedMask(MF))
715 MRI.addPhysRegsUsedFromRegMask(RegMask);
767 std::vector<CalleeSavedInfo> CSIInfo;
779 Twine(
"StackID is not supported by target"));
786 Twine(
"redefinition of fixed stack object '%fixed-stack.") +
789 Object.CalleeSavedRestored, ObjectIdx))
800 if (!
Name.Value.empty()) {
801 Alloca = dyn_cast_or_null<AllocaInst>(
802 F.getValueSymbolTable()->lookup(
Name.Value));
805 "alloca instruction named '" +
Name.Value +
806 "' isn't defined in the function '" +
F.getName() +
811 Twine(
"StackID is not supported by target"));
825 Twine(
"redefinition of stack object '%stack.") +
828 Object.CalleeSavedRestored, ObjectIdx))
836 if (!CSIInfo.empty())
861 std::vector<CalleeSavedInfo> &CSIInfo,
863 if (RegisterSource.
Value.empty())
871 CSIInfo.push_back(CSI);
882 Result = dyn_cast<T>(
Node);
884 return Parser.
error(Source.SourceRange.Start,
885 "expected a reference to a '" + TypeString +
892 const T &
Object,
int FrameIdx) {
895 MDNode *Var =
nullptr, *Expr =
nullptr, *Loc =
nullptr;
896 if (parseMDNode(PFS, Var,
Object.DebugVar) ||
897 parseMDNode(PFS, Expr,
Object.DebugExpr) ||
898 parseMDNode(PFS, Loc,
Object.DebugLoc))
900 if (!Var && !Expr && !Loc)
915 if (Source.Value.empty())
929 for (
const auto &YamlConstant : YamlMF.
Constants) {
930 if (YamlConstant.IsTargetSpecific)
932 return error(YamlConstant.Value.SourceRange.Start,
933 "Can't parse target-specific constant pool entries yet");
937 return error(
Error, YamlConstant.Value.SourceRange);
938 const Align PrefTypeAlign =
940 const Align Alignment = YamlConstant.Alignment.value_or(PrefTypeAlign);
942 if (!ConstantPoolSlots.
insert(std::make_pair(YamlConstant.ID.Value,
Index))
944 return error(YamlConstant.ID.SourceRange.Start,
945 Twine(
"redefinition of constant pool item '%const.") +
946 Twine(YamlConstant.ID.Value) +
"'");
954 for (
const auto &Entry : YamlJTI.
Entries) {
955 std::vector<MachineBasicBlock *> Blocks;
956 for (
const auto &MBBSource : Entry.Blocks) {
958 if (parseMBBReference(PFS,
MBB, MBBSource.Value))
965 return error(Entry.ID.SourceRange.Start,
966 Twine(
"redefinition of jump table entry '%jump-table.") +
967 Twine(Entry.ID.Value) +
"'");
993 if (parseMachineMetadata(PFS, MDS))
999 "use of undefined metadata '!" +
1013 (HasQuote ? 1 : 0));
1027 unsigned Line = LineAndColumn.first +
Error.getLineNo() - 1;
1028 unsigned Column =
Error.getColumnNo();
1036 if (L.line_number() == Line) {
1039 auto Indent = LineStr.
find(
Error.getLineContents());
1047 Error.getMessage(), LineStr,
Error.getRanges(),
1056std::unique_ptr<Module>
1058 return Impl->parseIRModule(DataLayoutCallback);
1062 return Impl->parseMachineFunctions(M, MMI);
1067 std::function<
void(
Function &)> ProcessIRFunction) {
1069 if (std::error_code EC = FileOrErr.getError()) {
1071 "Could not open input file: " + EC.message());
1078std::unique_ptr<MIRParser>
1081 std::function<
void(
Function &)> ProcessIRFunction) {
1082 auto Filename = Contents->getBufferIdentifier();
1088 "Can't read MIR with a Context that discards named Values")));
1091 return std::make_unique<MIRParser>(std::make_unique<MIRParserImpl>(
1092 std::move(Contents), Filename,
Context, ProcessIRFunction));
unsigned const MachineRegisterInfo * MRI
This file defines the StringMap class.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Analysis containing CSE Info
This file defines the DenseMap class.
static bool isSSA(const MachineFunction &MF)
static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context)
static bool typecheckMDNode(T *&Result, MDNode *Node, const yaml::StringValue &Source, StringRef TypeString, MIRParserImpl &Parser)
Verify that given node is of a certain type. Return true on error.
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
unsigned const TargetRegisterInfo * TRI
Module.h This file contains the declarations for the Module class.
const char LLVMTargetMachineRef TM
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
an instruction to allocate memory on the stack
LLVM Basic Block Representation.
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...
This is an important base class in LLVM.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Diagnostic information for machine IR parser.
Lightweight error class with error context and mandatory checking.
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Module * getParent()
Get the module that this global value is contained inside of...
@ ExternalLinkage
Externally visible function.
This is an important class for using LLVM in a threaded context.
bool shouldDiscardValueNames() const
Return true if the Context runtime configuration is set to discard all value names.
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
This class describes a target machine that is implemented with the LLVM target-independent code gener...
This class implements the parsing of LLVM IR that's embedded inside a MIR file.
bool error(const Twine &Message)
Report an error with the given message at unknown location.
void reportDiagnostic(const SMDiagnostic &Diag)
bool setupRegisterInfo(const PerFunctionMIParsingState &PFS, const yaml::MachineFunction &YamlMF)
bool parseRegisterInfo(PerFunctionMIParsingState &PFS, const yaml::MachineFunction &YamlMF)
bool initializeFrameInfo(PerFunctionMIParsingState &PFS, const yaml::MachineFunction &YamlMF)
Function * createDummyFunction(StringRef Name, Module &M)
Create an empty function with the given name.
bool parseStackObjectsDebugInfo(PerFunctionMIParsingState &PFS, const T &Object, int FrameIdx)
bool initializeMachineFunction(const yaml::MachineFunction &YamlMF, MachineFunction &MF)
Initialize the machine function to the state that's described in the MIR file.
std::unique_ptr< Module > parseIRModule(DataLayoutCallbackTy DataLayoutCallback)
Try to parse the optional LLVM module and the machine functions in the MIR file.
bool initializeJumpTableInfo(PerFunctionMIParsingState &PFS, const yaml::MachineJumpTable &YamlJTI)
bool parseMachineFunctions(Module &M, MachineModuleInfo &MMI)
bool initializeConstantPool(PerFunctionMIParsingState &PFS, MachineConstantPool &ConstantPool, const yaml::MachineFunction &YamlMF)
MIRParserImpl(std::unique_ptr< MemoryBuffer > Contents, StringRef Filename, LLVMContext &Context, std::function< void(Function &)> ProcessIRFunction)
bool parseMachineFunction(Module &M, MachineModuleInfo &MMI)
Parse the machine function in the current YAML document.
bool parseCalleeSavedRegister(PerFunctionMIParsingState &PFS, std::vector< CalleeSavedInfo > &CSIInfo, const yaml::StringValue &RegisterSource, bool IsRestored, int FrameIdx)
bool parseMachineMetadataNodes(PerFunctionMIParsingState &PFS, MachineFunction &MF, const yaml::MachineFunction &YMF)
bool initializeCallSiteInfo(PerFunctionMIParsingState &PFS, const yaml::MachineFunction &YamlMF)
MIRParser(std::unique_ptr< MIRParserImpl > Impl)
std::unique_ptr< Module > parseIRModule(DataLayoutCallbackTy DataLayoutCallback=[](StringRef, StringRef) { return std::nullopt;})
Parses the optional LLVM IR module in the MIR file.
bool parseMachineFunctions(Module &M, MachineModuleInfo &MMI)
Parses MachineFunctions in the MIR file and add them to the given MachineModuleInfo MMI.
bool isEHPad() const
Returns true if the block is a landing pad.
void push_back(MachineInstr *MI)
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool IsImmutable, bool isAliased=false)
Create a new object at a fixed location on the stack.
void setAdjustsStack(bool V)
void setRestorePoint(MachineBasicBlock *NewRestore)
int CreateStackObject(uint64_t Size, Align Alignment, bool isSpillSlot, const AllocaInst *Alloca=nullptr, uint8_t ID=0)
Create a new statically sized stack object, returning a nonnegative identifier to represent it.
void ensureMaxAlignment(Align Alignment)
Make sure the function is at least Align bytes aligned.
void setHasPatchPoint(bool s=true)
void setLocalFrameSize(int64_t sz)
Set the size of the local object blob.
void setObjectOffset(int ObjectIdx, int64_t SPOffset)
Set the stack frame offset of the specified object.
void setFrameAddressIsTaken(bool T)
void setHasStackMap(bool s=true)
void setCVBytesOfCalleeSavedRegisters(unsigned S)
void setStackID(int ObjectIdx, uint8_t ID)
void setHasTailCall(bool V=true)
void setStackProtectorIndex(int I)
void setCalleeSavedInfoValid(bool v)
void setReturnAddressIsTaken(bool s)
void mapLocalFrameObject(int ObjectIndex, int64_t Offset)
Map a frame index into the local object block.
void setOffsetAdjustment(int Adj)
Set the correction for frame offsets.
void setHasOpaqueSPAdjustment(bool B)
void setCalleeSavedInfo(std::vector< CalleeSavedInfo > CSI)
Used by prolog/epilog inserter to set the function's callee saved information.
int CreateVariableSizedObject(Align Alignment, const AllocaInst *Alloca)
Notify the MachineFrameInfo object that a variable sized object has been created.
void setSavePoint(MachineBasicBlock *NewSave)
void setMaxCallFrameSize(unsigned S)
int CreateFixedSpillStackObject(uint64_t Size, int64_t SPOffset, bool IsImmutable=false)
Create a spill slot at a fixed location on the stack.
void setStackSize(uint64_t Size)
Set the size of the stack.
void setHasVAStart(bool B)
void setHasMustTailInVarArgFunc(bool B)
void setObjectAlignment(int ObjectIdx, Align Alignment)
setObjectAlignment - Change the alignment of the specified stack object.
void setFunctionContextIndex(int I)
Properties which a MachineFunction may have at a given point in time.
MachineFunctionProperties & set(Property P)
MachineFunctionProperties & reset(Property P)
void setBBSectionsType(BasicBlockSection V)
void setCallsUnwindInit(bool b)
void setHasEHFunclets(bool V)
void setExposesReturnsTwice(bool B)
setCallsSetJmp - Set a flag that indicates if there's a call to a "returns twice" function.
void setHasWinCFI(bool v)
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineJumpTableInfo * getOrCreateJumpTableInfo(unsigned JTEntryKind)
getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it does already exist,...
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
void setHasEHCatchret(bool V)
void setCallsEHReturn(bool b)
void setAlignment(Align A)
setAlignment - Set the alignment of the function.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
bool hasBBSections() const
Returns true if this function has basic block sections enabled.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
void addCallArgsForwardingRegs(const MachineInstr *CallI, CallSiteInfoImpl &&CallInfo)
Start tracking the arguments passed to the call CallI.
Function & getFunction()
Return the LLVM function that this machine code represents.
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
MachineConstantPool * getConstantPool()
getConstantPool - Return the constant pool object for the current function.
const MachineFunctionProperties & getProperties() const
Get the function properties.
void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr, int Slot, const DILocation *Loc)
Collect information used to emit debugging information of a variable.
void setHasEHScopes(bool V)
bool verify(Pass *p=nullptr, const char *Banner=nullptr, bool AbortOnError=true) const
Run the current MachineFunction through the machine code verifier, useful for debugger use.
void assignBeginEndSections()
Assign IsBeginSection IsEndSection fields for basic blocks in this function.
Representation of each machine instruction.
unsigned createJumpTableIndex(const std::vector< MachineBasicBlock * > &DestBBs)
createJumpTableIndex - Create a new jump table.
This class contains meta information specific to a module.
MachineFunction & getOrCreateMachineFunction(Function &F)
Returns the MachineFunction constructed for the IR function F.
const LLVMTargetMachine & getTarget() const
MachineFunction * getMachineFunction(const Function &F) const
Returns the MachineFunction associated to IR function F if there is one, otherwise nullptr.
MachineOperand class - Representation of each machine instruction operand.
unsigned getSubReg() const
bool isReg() const
isReg - Tests if this is a MO_Register operand.
bool isRegMask() const
isRegMask - Tests if this is a MO_RegisterMask operand.
Register getReg() const
getReg - Returns the register number.
const uint32_t * getRegMask() const
getRegMask - Returns a bit mask of registers preserved by this RegMask operand.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
bool tracksLiveness() const
tracksLiveness - Returns true when tracking register liveness accurately.
void invalidateLiveness()
invalidateLiveness - Indicates that register liveness is no longer being tracked accurately.
void setCalleeSavedRegs(ArrayRef< MCPhysReg > CSRs)
Sets the updated Callee Saved Registers list.
void addLiveIn(MCRegister Reg, Register vreg=Register())
addLiveIn - Add the specified register as a live-in.
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, std::optional< Align > Alignment=std::nullopt)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
A Module instance is used to store all the information related to an LLVM module.
This class implements the register bank concept.
Wrapper class representing virtual and physical registers.
static Register index2VirtReg(unsigned Index)
Convert a 0-based index to a virtual register number.
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
SourceMgr::DiagKind getKind() const
Represents a location in source code.
static SMLoc getFromPointer(const char *Ptr)
const char * getPointer() const
Represents a range in source code.
reference emplace_back(ArgTypes &&... Args)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling.
unsigned getMainFileID() const
std::pair< unsigned, unsigned > getLineAndColumn(SMLoc Loc, unsigned BufferID=0) const
Find the line and column number for the specified location in the specified file.
const MemoryBuffer * getMemoryBuffer(unsigned i) const
SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges={}, ArrayRef< SMFixIt > FixIts={}) const
Return an SMDiagnostic at the specified location with the specified string.
unsigned AddNewSourceBuffer(std::unique_ptr< MemoryBuffer > F, SMLoc IncludeLoc)
Add a new source buffer to this source manager.
StringRef - Represent a constant reference to a string, i.e.
bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
static constexpr size_t npos
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Information about stack frame layout on the target.
virtual bool isSupportedStackID(TargetStackID::Value ID) const
llvm::BasicBlockSection getBBSectionsType() const
If basic blocks should be emitted into their own section, corresponding to -fbasic-block-sections.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
virtual void mirFileLoaded(MachineFunction &MF) const
This is called after a .mir file was loaded.
virtual const TargetFrameLowering * getFrameLowering() const
Target - Wrapper for Target specific information.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
std::string str() const
Return the twine contents as a std::string.
static Type * getVoidTy(LLVMContext &C)
This function has undefined behavior.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
An efficient, type-erasing, non-owning reference to a callable.
A forward iterator which reads text lines from a buffer.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
bool parseStackObjectReference(PerFunctionMIParsingState &PFS, int &FI, StringRef Src, SMDiagnostic &Error)
bool parseMDNode(PerFunctionMIParsingState &PFS, MDNode *&Node, StringRef Src, SMDiagnostic &Error)
bool parseMachineBasicBlockDefinitions(PerFunctionMIParsingState &PFS, StringRef Src, SMDiagnostic &Error)
Parse the machine basic block definitions, and skip the machine instructions.
bool parseMBBReference(PerFunctionMIParsingState &PFS, MachineBasicBlock *&MBB, StringRef Src, SMDiagnostic &Error)
std::unique_ptr< MIRParser > createMIRParserFromFile(StringRef Filename, SMDiagnostic &Error, LLVMContext &Context, std::function< void(Function &)> ProcessIRFunction=nullptr)
This function is the main interface to the MIR serialization format parser.
std::unique_ptr< MIRParser > createMIRParser(std::unique_ptr< MemoryBuffer > Contents, LLVMContext &Context, std::function< void(Function &)> ProcessIRFunction=nullptr)
This function is another interface to the MIR serialization format parser.
std::unique_ptr< Module > parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context, SlotMapping *Slots=nullptr, DataLayoutCallbackTy DataLayoutCallback=[](StringRef, StringRef) { return std::nullopt;})
parseAssemblyFile and parseAssemblyString are wrappers around this function.
bool parseMachineInstructions(PerFunctionMIParsingState &PFS, StringRef Src, SMDiagnostic &Error)
Parse the machine instructions.
bool parseRegisterReference(PerFunctionMIParsingState &PFS, Register &Reg, StringRef Src, SMDiagnostic &Error)
Constant * parseConstantValue(StringRef Asm, SMDiagnostic &Err, const Module &M, const SlotMapping *Slots=nullptr)
Parse a type and a constant value in the given string.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
bool parseMachineMetadata(PerFunctionMIParsingState &PFS, StringRef Src, SMRange SourceRange, SMDiagnostic &Error)
bool parseVirtualRegisterReference(PerFunctionMIParsingState &PFS, VRegInfo *&Info, StringRef Src, SMDiagnostic &Error)
bool parseNamedRegisterReference(PerFunctionMIParsingState &PFS, Register &Reg, StringRef Src, SMDiagnostic &Error)
This struct is a compact representation of a valid (non-zero power of two) alignment.
Align valueOrOne() const
For convenience, returns a valid alignment or 1 if undefined.
DenseMap< unsigned, unsigned > JumpTableSlots
VRegInfo & getVRegInfo(Register Num)
DenseMap< unsigned, int > FixedStackObjectSlots
DenseMap< unsigned, unsigned > ConstantPoolSlots
StringMap< VRegInfo * > VRegInfosNamed
DenseMap< unsigned, int > StackObjectSlots
std::map< unsigned, std::pair< TempMDTuple, SMLoc > > MachineForwardRefMDNodes
DenseMap< Register, VRegInfo * > VRegInfos
This struct contains the mappings from the slot numbers to unnamed metadata nodes,...
Identifies call instruction location in machine function.
Serializable representation of MachineFrameInfo.
unsigned MaxCallFrameSize
~0u means: not computed yet.
StringValue StackProtector
bool HasMustTailInVarArgFunc
unsigned CVBytesOfCalleeSavedRegisters
bool HasOpaqueSPAdjustment
bool IsReturnAddressTaken
StringValue FunctionContext
std::vector< MachineStackObject > StackObjects
std::vector< StringValue > MachineMetadataNodes
std::optional< std::vector< FlowStringValue > > CalleeSavedRegisters
bool TracksDebugUserValues
std::vector< MachineConstantPoolValue > Constants
std::vector< CallSiteInfo > CallSitesInfo
std::vector< MachineFunctionLiveIn > LiveIns
std::vector< VirtualRegisterDefinition > VirtualRegisters
std::vector< FixedMachineStackObject > FixedStackObjects
std::vector< DebugValueSubstitution > DebugValueSubstitutions
std::unique_ptr< MachineFunctionInfo > MachineFuncInfo
Constant pool.
MachineJumpTable JumpTableInfo
MachineFrameInfo FrameInfo
std::vector< Entry > Entries
MachineJumpTableInfo::JTEntryKind Kind
A wrapper around std::string which contains a source range that's being set during parsing.