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);
143 template <
typename T>
193 std::function<
void(
Function &)> Callback)
195 In(SM.getMemoryBuffer(SM.AddNewSourceBuffer(
std::
move(Contents),
SMLoc()))
198 Filename(Filename), ProcessIRFunction(Callback) {
239std::unique_ptr<Module>
241 if (!In.setCurrentDocument()) {
245 NoMIRDocuments =
true;
246 auto M = std::make_unique<Module>(Filename,
Context);
247 if (
auto LayoutOverride =
248 DataLayoutCallback(M->getTargetTriple(), M->getDataLayoutStr()))
249 M->setDataLayout(*LayoutOverride);
253 std::unique_ptr<Module> M;
256 if (
const auto *BSN =
257 dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
260 Context, &IRSlots, DataLayoutCallback);
266 if (!In.setCurrentDocument())
267 NoMIRDocuments =
true;
270 M = std::make_unique<Module>(Filename,
Context);
271 if (
auto LayoutOverride =
272 DataLayoutCallback(M->getTargetTriple(), M->getDataLayoutStr()))
273 M->setDataLayout(*LayoutOverride);
288 }
while (In.setCurrentDocument());
294 auto &
Context = M.getContext();
301 if (ProcessIRFunction)
302 ProcessIRFunction(*
F);
310 yaml::EmptyContext Ctx;
314 TM.createDefaultFuncInfoYAML());
316 yaml::yamlize(In, YamlMF,
false, Ctx);
322 Function *
F = M.getFunction(FunctionName);
327 return error(
Twine(
"function '") + FunctionName +
328 "' isn't defined in the provided LLVM IR");
332 return error(
Twine(
"redefinition of machine function '") + FunctionName +
345 for (
unsigned I = 0,
E =
MRI.getNumVirtRegs();
I !=
E; ++
I) {
347 if (!
MRI.hasOneDef(Reg) && !
MRI.def_empty(Reg))
362 bool HasInlineAsm =
false;
363 bool AllTiedOpsRewritten =
true, HasTiedOps =
false;
368 if (
MI.isInlineAsm())
370 for (
unsigned I = 0;
I <
MI.getNumOperands(); ++
I) {
375 if (MO.
isUse() &&
MI.isRegTiedToDefOperand(
I, &DefIdx)) {
377 if (MO.
getReg() !=
MI.getOperand(DefIdx).getReg())
378 AllTiedOpsRewritten =
false;
385 MF.setHasInlineAsm(HasInlineAsm);
387 if (HasTiedOps && AllTiedOpsRewritten)
396 if (
MRI.getNumVirtRegs() == 0)
409 Twine(
" call instruction block out of range.") +
412 if (MILoc.
Offset >= CallB->size())
414 Twine(
" call instruction offset out of range.") +
415 " Unable to reference instruction at bb: " +
417 auto CallI = std::next(CallB->instr_begin(), MILoc.
Offset);
420 Twine(
" call site info should reference call "
421 "instruction. Instruction at bb:") +
423 " is not a call instruction");
425 for (
auto ArgRegPair : YamlCSInfo.ArgForwardingRegs) {
428 return error(
Error, ArgRegPair.Reg.SourceRange);
432 if (
TM.Options.EmitCallSiteInfo)
437 return error(
Twine(
"Call site info provided but not used"));
441void MIRParserImpl::setupDebugValueTracking(
445 unsigned MaxInstrNum = 0;
448 MaxInstrNum = std::max((
unsigned)
MI.peekDebugInstrNum(), MaxInstrNum);
449 MF.setDebugInstrNumberingCount(MaxInstrNum);
453 MF.makeDebugValueSubstitution({Sub.SrcInst, Sub.SrcOp},
454 {Sub.DstInst, Sub.DstOp}, Sub.Subreg);
578 MRI.freezeReservedRegs(MF);
580 computeFunctionProperties(MF);
585 setupDebugValueTracking(MF, PFS, YamlMF);
606 return error(VReg.ID.SourceRange.Start,
607 Twine(
"redefinition of virtual register '%") +
608 Twine(VReg.ID.Value) +
"'");
609 Info.Explicit =
true;
613 Info.D.RegBank =
nullptr;
615 const auto *RC =
Target->getRegClass(VReg.Class.Value);
623 VReg.Class.SourceRange.Start,
624 Twine(
"use of undefined register class or register bank '") +
625 VReg.Class.Value +
"'");
627 Info.D.RegBank = RegBank;
631 if (!VReg.PreferredRegister.Value.empty()) {
633 return error(VReg.Class.SourceRange.Start,
634 Twine(
"preferred register can only be set for normal vregs"));
637 VReg.PreferredRegister.Value,
Error))
638 return error(
Error, VReg.PreferredRegister.SourceRange);
643 for (
const auto &LiveIn : YamlMF.
LiveIns) {
646 return error(
Error, LiveIn.Register.SourceRange);
648 if (!LiveIn.VirtualRegister.Value.empty()) {
652 return error(
Error, LiveIn.VirtualRegister.SourceRange);
686 error(
Twine(
"Cannot determine class/bank of virtual register ") +
691 if (!
Info.D.RC->isAllocatable()) {
692 error(
Twine(
"Cannot use non-allocatable class '") +
693 TRI->getRegClassName(
Info.D.RC) +
"' for virtual register " +
699 MRI.setRegClass(Reg,
Info.D.RC);
700 if (
Info.PreferredReg != 0)
701 MRI.setSimpleHint(Reg,
Info.PreferredReg);
706 MRI.setRegBank(Reg, *
Info.D.RegBank);
725 if (
auto *RegMask =
TRI->getCustomEHPadPreservedMask(MF))
726 MRI.addPhysRegsUsedFromRegMask(RegMask);
778 std::vector<CalleeSavedInfo> CSIInfo;
784 Object.IsImmutable, Object.IsAliased);
789 return error(Object.ID.SourceRange.Start,
790 Twine(
"StackID is not supported by target"));
796 return error(Object.ID.SourceRange.Start,
797 Twine(
"redefinition of fixed stack object '%fixed-stack.") +
798 Twine(Object.ID.Value) +
"'");
800 Object.CalleeSavedRestored, ObjectIdx))
811 return error(
Error, Object.EntryValueRegister.SourceRange);
812 if (!Reg.isPhysical())
813 return error(Object.EntryValueRegister.SourceRange.Start,
814 "Expected physical register for entry value field");
816 PFS, Object.DebugVar, Object.DebugExpr, Object.DebugLoc);
819 if (MaybeInfo->DIVar || MaybeInfo->DIExpr || MaybeInfo->DILoc)
821 Reg.asMCReg(), MaybeInfo->DILoc);
829 if (!
Name.Value.empty()) {
830 Alloca = dyn_cast_or_null<AllocaInst>(
831 F.getValueSymbolTable()->lookup(
Name.Value));
834 "alloca instruction named '" +
Name.Value +
835 "' isn't defined in the function '" +
F.getName() +
839 return error(Object.ID.SourceRange.Start,
840 Twine(
"StackID is not supported by target"));
846 Object.Size, Object.Alignment.valueOrOne(),
853 return error(Object.ID.SourceRange.Start,
854 Twine(
"redefinition of stack object '%stack.") +
855 Twine(Object.ID.Value) +
"'");
857 Object.CalleeSavedRestored, ObjectIdx))
859 if (Object.LocalOffset)
865 if (!CSIInfo.empty())
890 std::vector<CalleeSavedInfo> &CSIInfo,
892 if (RegisterSource.
Value.empty())
900 CSIInfo.push_back(CSI);
911 Result = dyn_cast<T>(
Node);
913 return Parser.
error(Source.SourceRange.Start,
914 "expected a reference to a '" + TypeString +
925 if (parseMDNode(PFS, Var, VarStr) || parseMDNode(PFS, Expr, ExprStr) ||
926 parseMDNode(PFS, Loc, LocStr))
940 const T &Object,
int FrameIdx) {
941 std::optional<VarExprLoc> MaybeInfo =
942 parseVarExprLoc(PFS, Object.DebugVar, Object.DebugExpr, Object.DebugLoc);
947 if (MaybeInfo->DIVar || MaybeInfo->DIExpr || MaybeInfo->DILoc)
955 if (Source.Value.empty())
969 for (
const auto &YamlConstant : YamlMF.
Constants) {
970 if (YamlConstant.IsTargetSpecific)
972 return error(YamlConstant.Value.SourceRange.Start,
973 "Can't parse target-specific constant pool entries yet");
977 return error(
Error, YamlConstant.Value.SourceRange);
978 const Align PrefTypeAlign =
980 const Align Alignment = YamlConstant.Alignment.value_or(PrefTypeAlign);
982 if (!ConstantPoolSlots.
insert(std::make_pair(YamlConstant.ID.Value,
Index))
984 return error(YamlConstant.ID.SourceRange.Start,
985 Twine(
"redefinition of constant pool item '%const.") +
986 Twine(YamlConstant.ID.Value) +
"'");
994 for (
const auto &Entry : YamlJTI.
Entries) {
995 std::vector<MachineBasicBlock *>
Blocks;
996 for (
const auto &MBBSource : Entry.Blocks) {
998 if (parseMBBReference(PFS,
MBB, MBBSource.Value))
1005 return error(Entry.ID.SourceRange.Start,
1006 Twine(
"redefinition of jump table entry '%jump-table.") +
1007 Twine(Entry.ID.Value) +
"'");
1033 if (parseMachineMetadata(PFS, MDS))
1039 "use of undefined metadata '!" +
1053 (HasQuote ? 1 : 0));
1067 unsigned Line = LineAndColumn.first +
Error.getLineNo() - 1;
1068 unsigned Column =
Error.getColumnNo();
1076 if (L.line_number() == Line) {
1079 auto Indent = LineStr.
find(
Error.getLineContents());
1087 Error.getMessage(), LineStr,
Error.getRanges(),
1096std::unique_ptr<Module>
1098 return Impl->parseIRModule(DataLayoutCallback);
1102 return Impl->parseMachineFunctions(M, MMI);
1107 std::function<
void(
Function &)> ProcessIRFunction) {
1109 if (std::error_code EC = FileOrErr.getError()) {
1111 "Could not open input file: " + EC.message());
1118std::unique_ptr<MIRParser>
1121 std::function<
void(
Function &)> ProcessIRFunction) {
1122 auto Filename = Contents->getBufferIdentifier();
1128 "Can't read MIR with a Context that discards named Values")));
1131 return std::make_unique<MIRParser>(std::make_unique<MIRParserImpl>(
1132 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.
DenseMap< Block *, BlockRelaxAux > Blocks
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)
std::optional< VarExprLoc > parseVarExprLoc(PerFunctionMIParsingState &PFS, const yaml::StringValue &VarStr, const yaml::StringValue &ExprStr, const yaml::StringValue &LocStr)
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.
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
void setIsOutlined(bool V)
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 in a stack slot.
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)
constexpr 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)
Implement std::hash so that hash_code can be used in STL containers.
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
std::vector< EntryValueObject > EntryValueObjects
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.