1//===- llvm/CodeGen/MachineFunction.h ---------------------------*- C++ -*-===// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7//===----------------------------------------------------------------------===// 9// Collect native machine code for a function. This class contains a list of 10// MachineBasicBlock instances that make up the current compiled function. 12// This class also contains pointers to various classes which hold 13// target-specific information about the generated code. 15//===----------------------------------------------------------------------===// 17#ifndef LLVM_CODEGEN_MACHINEFUNCTION_H 18#define LLVM_CODEGEN_MACHINEFUNCTION_H 55classGISelChangeObserver;
58classMachineConstantPool;
61classMachineJumpTableInfo;
62classMachineRegisterInfo;
68classPseudoSourceValueManager;
72classTargetRegisterClass;
73classTargetSubtargetInfo;
85template <
class Iterator>
87assert(
this == &OldList &&
"never transfer MBBs between functions");
91// The hotness of static data tracked by a MachineFunction and not represented 92// as a global object in the module IR / MIR. Typical examples are 93// MachineJumpTableInfo and MachineConstantPool. 100/// MachineFunctionInfo - This class can be derived from and used by targets to 101/// hold private target-specific information for each MachineFunction. Objects 102/// of type are accessed/created with MF::getInfo and destroyed when the 103/// MachineFunction is destroyed. 107 /// Factory function: default behavior is to call new using the 108 /// supplied allocator. 110 /// This function can be overridden in a derive class. 111template <
typename FuncInfoTy,
typename SubtargetTy = TargetSubtargetInfo>
113const SubtargetTy *STI) {
114returnnew (
Allocator.Allocate<FuncInfoTy>()) FuncInfoTy(
F, STI);
117template <
typename Ty>
119returnnew (
Allocator.Allocate<Ty>()) Ty(MFI);
122 /// Make a functionally equivalent copy of this MachineFunctionInfo in \p MF. 123 /// This requires remapping MachineBasicBlock references from the original 124 /// parent to values in the new function. Targets may assume that virtual 125 /// register and frame index values are preserved in the new function. 134/// Properties which a MachineFunction may have at a given point in time. 135/// Each of these has checking code in the MachineVerifier, and passes can 136/// require that a property be set. 138// Possible TODO: Allow targets to extend this (perhaps by allowing the 139// constructor to specify the size of the bit vector) 140// Possible TODO: Allow requiring the negative (e.g. VRegsAllocated could be 141// stated as the negative of "has vregs" 144// The properties are stated in "positive" form; i.e. a pass could require 145// that the property hold, but not that it does not hold. 147// Property descriptions: 148// IsSSA: True when the machine function is in SSA form and virtual registers 150// NoPHIs: The machine function does not contain any PHI instruction. 151// TracksLiveness: True when tracking register liveness accurately. 152// While this property is set, register liveness information in basic block 153// live-in lists and machine instruction operands (e.g. implicit defs) is 154// accurate, kill flags are conservatively accurate (kill flag correctly 155// indicates the last use of a register, an operand without kill flag may or 156// may not be the last use of a register). This means it can be used to 157// change the code in ways that affect the values in registers, for example 158// by the register scavenger. 159// When this property is cleared at a very late time, liveness is no longer 161// NoVRegs: The machine function does not use any virtual registers. 162// Legalized: In GlobalISel: the MachineLegalizer ran and all pre-isel generic 163// instructions have been legalized; i.e., all instructions are now one of: 164// - generic and always legal (e.g., COPY) 166// - legal pre-isel generic instructions. 167// RegBankSelected: In GlobalISel: the RegBankSelect pass ran and all generic 168// virtual registers have been assigned to a register bank. 169// Selected: In GlobalISel: the InstructionSelect pass ran and all pre-isel 170// generic instructions have been eliminated; i.e., all instructions are now 171// target-specific or non-pre-isel generic instructions (e.g., COPY). 172// Since only pre-isel generic instructions can have generic virtual register 173// operands, this also means that all generic virtual registers have been 174// constrained to virtual registers (assigned to register classes) and that 175// all sizes attached to them have been eliminated. 176// TiedOpsRewritten: The twoaddressinstruction pass will set this flag, it 177// means that tied-def have been rewritten to meet the RegConstraint. 178// FailsVerification: Means that the function is not expected to pass machine 179// verification. This can be set by passes that introduce known problems that 180// have not been fixed yet. 181// TracksDebugUserValues: Without this property enabled, debug instructions 182// such as DBG_VALUE are allowed to reference virtual registers even if those 183// registers do not have a definition. With the property enabled virtual 184// registers must only be used if they have a definition. This property 185// allows earlier passes in the pipeline to skip updates of `DBG_VALUE` 186// instructions to save compile time. 204return Properties[
static_cast<unsigned>(
P)];
208 Properties.set(
static_cast<unsigned>(
P));
213 Properties.reset(
static_cast<unsigned>(
P));
217 /// Reset all the properties. 224 Properties |= MFP.Properties;
229 Properties &= ~MFP.Properties;
233// Returns true if all properties set in V (i.e. required by a pass) are set 236return (Properties | ~V.Properties).all();
239 /// Print the MachineFunctionProperties in human-readable form. 247 /// Filter or finally function. Null indicates a catch-all. 250 /// Address of block to recover at. Null for a finally handler. 254/// This structure is used to retain landing pad info for the current function. 261 std::vector<int>
TypeIds;
// List of type ids (filters negative). 273// RegInfo - Information about each register in use in the function. 276// Used to keep track of target-specific per-machine-function information for 277// the target implementation. 280// Keep track of objects allocated on the stack. 283// Keep track of constants which are spilled to memory 286// Keep track of jump tables for switch instructions 289// Keep track of the function section. 292// Catchpad unwind destination info for wasm EH. 293// Keeps track of Wasm exception handling related data. This will be null for 294// functions that aren't using a wasm EH personality. 297// Keeps track of Windows exception handling related data. This will be null 298// for functions that aren't using a funclet-based EH personality. 301// Function-level unique numbering for MachineBasicBlocks. When a 302// MachineBasicBlock is inserted into a MachineFunction is it automatically 303// numbered and this vector keeps track of the mapping from ID's to MBB's. 304 std::vector<MachineBasicBlock*> MBBNumbering;
306// MBBNumbering epoch, incremented after renumbering to detect use of old 308unsigned MBBNumberingEpoch = 0;
310// Pool-allocate MachineFunction-lifetime and IR objects. 313// Allocation management for instructions in function. 316// Allocation management for operand arrays on instructions. 319// Allocation management for basic blocks in function. 322// List of machine basic blocks in function 326 /// FunctionNumber - This provides a unique ID for each function emitted in 327 /// this translation unit. 329unsigned FunctionNumber;
331 /// Alignment - The alignment of the function. 334 /// ExposesReturnsTwice - True if the function calls setjmp or related 335 /// functions with attribute "returns twice", but doesn't have 336 /// the attribute itself. 337 /// This is used to limit optimizations which cannot reason 338 /// about the control flow of such functions. 339bool ExposesReturnsTwice =
false;
341 /// True if the function includes any inline assembly. 342bool HasInlineAsm =
false;
344 /// True if any WinCFI instruction have been emitted in this function. 345bool HasWinCFI =
false;
347 /// Current high-level properties of the IR of the function (e.g. is in SSA 348 /// form or whether registers have been allocated) 351// Allocation management for pseudo source values. 352 std::unique_ptr<PseudoSourceValueManager> PSVManager;
354 /// List of moves done by a function's prolog. Used to construct frame maps 355 /// by debug and exception handling consumers. 356 std::vector<MCCFIInstruction> FrameInstructions;
358 /// List of basic blocks immediately following calls to _setjmp. Used to 359 /// construct a table of valid longjmp targets for Windows Control Flow Guard. 360 std::vector<MCSymbol *> LongjmpTargets;
362 /// List of basic blocks that are the target of catchrets. Used to construct 363 /// a table of valid targets for Windows EHCont Guard. 364 std::vector<MCSymbol *> CatchretTargets;
366 /// \name Exception Handling 369 /// List of LandingPadInfo describing the landing pad information. 370 std::vector<LandingPadInfo> LandingPads;
372 /// Map a landing pad's EH symbol to the call site indexes. 375 /// Map a landing pad to its index. 378 /// Map of invoke call site index values to associated begin EH_LABEL. 381 /// CodeView label annotations. 382 std::vector<std::pair<MCSymbol *, MDNode *>> CodeViewAnnotations;
384bool CallsEHReturn =
false;
385bool CallsUnwindInit =
false;
386bool HasEHCatchret =
false;
387bool HasEHScopes =
false;
388bool HasEHFunclets =
false;
389bool HasFakeUses =
false;
390bool IsOutlined =
false;
392 /// BBID to assign to the next basic block of this function. 393unsigned NextBBID = 0;
395 /// Section Type for basic blocks, only relevant with basic block sections. 398 /// List of C++ TypeInfo used. 399 std::vector<const GlobalValue *> TypeInfos;
401 /// List of typeids encoding filters used. 402 std::vector<unsigned> FilterIds;
404 /// List of the indices in FilterIds corresponding to filter terminators. 405 std::vector<unsigned> FilterEnds;
411 /// Clear all the members of this MachineFunction, but the ones used to 412 /// initialize again the MachineFunction. More specifically, this deallocates 413 /// all the dynamically allocated objects and get rids of all the XXXInfo data 414 /// structure, but keeps unchanged the references to Fn, Target, and 417 /// Allocate and initialize the different members. 418 /// In particular, the XXXInfo data structure. 419 /// \pre Fn, Target, and FunctionNumber are properly set. 423 /// Description of the location of a variable whose Address is valid and 424 /// unchanging during function execution. The Address may be: 425 /// * A stack index, which can be negative for fixed stack objects. 426 /// * A MCRegister, whose entry value contains the address of the variable. 428 std::variant<int, MCRegister>
Address;
437 :
Address(Slot), Var(Var), Expr(Expr), Loc(Loc) {}
441 :
Address(EntryValReg), Var(Var), Expr(Expr), Loc(Loc) {}
443 /// Return true if this variable is in a stack slot. 446 /// Return true if this variable is in the entry value of a register. 448return std::holds_alternative<MCRegister>(
Address);
451 /// Returns the stack slot of this variable, assuming `inStackSlot()` is 455 /// Returns the MCRegister of this variable, assuming 456 /// `inEntryValueRegister()` is true. 458return std::get<MCRegister>(
Address);
461 /// Updates the stack slot of this variable, assuming `inStackSlot()` is 474 /// Callback after an insertion. This should not modify the MI directly. 476 /// Callback before a removal. This should not modify the MI directly. 478 /// Callback before changing MCInstrDesc. This should not modify the MI 484 /// Structure used to represent pair of argument number after call lowering 485 /// and register used to transfer that argument. 486 /// For now we support only cases when argument is transferred through one 492assert(Arg < (1 << 16) &&
"Arg out of range");
497 /// Vector of call argument and its forwarding register. 511 /// Map a call instruction to call site arguments forwarding info. 514 /// A helper function that returns call site info for a give call 515 /// instruction if debug entry value support is enabled. 519 /// Mapping of call instruction to the global value and target flags that it 520 /// calls, if applicable. 523// Callbacks for insertion and removal. 529// Need to be accessed from MachineInstr::setDesc. 535 /// A count of how many instructions in the function have had numbers 536 /// assigned to them. Used for debug value tracking, to determine the 537 /// next instruction number. 538unsigned DebugInstrNumberingCount = 0;
540 /// Set value of DebugInstrNumberingCount field. Avoid using this unless 541 /// you're deserializing this data. 542void setDebugInstrNumberingCount(
unsigned Num);
544 /// Pair of instruction number and operand number. 547 /// Replacement definition for a debug instruction reference. Made up of a 548 /// source instruction / operand pair, destination pair, and a qualifying 549 /// subregister indicating what bits in the operand make up the substitution. 550// For example, a debug user 552 /// %0:gr32 = someinst, debug-instr-number 1 553 /// %1:gr16 = %0.some_16_bit_subreg, debug-instr-number 2 554 /// Would receive the substitution {{2, 0}, {1, 0}, $subreg}, where $subreg is 555 /// the subregister number for some_16_bit_subreg. 560unsignedSubreg;
///< Qualifier for which part of Dest is read. 564 : Src(Src), Dest(Dest), Subreg(Subreg) {}
566 /// Order only by source instruction / operand pair: there should never 567 /// be duplicate entries for the same source in any collection. 569return Src <
Other.Src;
573 /// Debug value substitutions: a collection of DebugSubstitution objects, 574 /// recording changes in where a value is defined. For example, when one 575 /// instruction is substituted for another. Keeping a record allows recovery 576 /// of variable locations after compilation finishes. 579 /// Location of a PHI instruction that is also a debug-info variable value, 580 /// for the duration of register allocation. Loaded by the PHI-elimination 581 /// pass, and emitted as DBG_PHI instructions during VirtRegRewriter, with 582 /// maintenance applied by intermediate passes that edit registers (such as 583 /// coalescing and the allocator passes). 588unsignedSubReg;
///< Optional subreg qualifier within Reg. 593 /// Map of debug instruction numbers to the position of their PHI instructions 594 /// during register allocation. See DebugPHIRegallocPos. 597 /// Flag for whether this function contains DBG_VALUEs (false) or 598 /// DBG_INSTR_REF (true). 599bool UseDebugInstrRef =
false;
601 /// Create a substitution between one <instr,operand> value to a different, 606 /// Create substitutions for any tracked values in \p Old, to point at 607 /// \p New. Needed when we re-create an instruction during optimization, 608 /// which has the same signature (i.e., def operands in the same place) but 609 /// a modified instruction type, flags, or otherwise. An example: X86 moves 610 /// are sometimes transformed into equivalent LEAs. 611 /// If the two instructions are not the same opcode, limit which operands to 612 /// examine for substitutions to the first N operands by setting 615unsigned MaxOperand = UINT_MAX);
617 /// Find the underlying defining instruction / operand for a COPY instruction 618 /// while in SSA form. Copies do not actually define values -- they move them 619 /// between registers. Labelling a COPY-like instruction with an instruction 620 /// number is to be avoided as it makes value numbers non-unique later in 621 /// compilation. This method follows the definition chain for any sequence of 622 /// COPY-like instructions to find whatever non-COPY-like instruction defines 623 /// the copied value; or for parameters, creates a DBG_PHI on entry. 624 /// May insert instructions into the entry block! 625 /// \p MI The copy-like instruction to salvage. 626 /// \p DbgPHICache A container to cache already-solved COPYs. 627 /// \returns An instruction/operand pair identifying the defining value. 634 /// Finalise any partially emitted debug instructions. These are DBG_INSTR_REF 635 /// instructions where we only knew the vreg of the value they use, not the 636 /// instruction that defines that vreg. Once isel finishes, we should have 637 /// enough information for every DBG_INSTR_REF to point at an instruction 639void finalizeDebugInstrRefs();
641 /// Determine whether, in the current machine configuration, we should use 642 /// instruction referencing or not. 643bool shouldUseDebugInstrRef()
const;
645 /// Returns true if the function's variable locations are tracked with 646 /// instruction referencing. 647bool useDebugInstrRef()
const;
649 /// Set whether this function will use instruction referencing or not. 650void setUseDebugInstrRef(
bool UseInstrRef);
652 /// A reserved operand number representing the instructions memory operand, 653 /// for instructions that have a stack spill fused into them. 658unsigned FunctionNum);
663 /// Reset the instance as if it was just created. 669 /// Reset the currently registered delegate - otherwise assert. 671assert(TheDelegate == delegate &&
672"Only the current delegate can perform reset!");
673 TheDelegate =
nullptr;
676 /// Set the delegate. resetDelegate must be called before attempting 679assert(delegate && !TheDelegate &&
680"Attempted to set delegate to null, or to change it without " 681"first resetting it!");
683 TheDelegate = delegate;
692 /// Returns the Section this function belongs to. 695 /// Indicates the Section this function belongs to. 700 /// Return the DataLayout attached to the Module associated to this MF. 703 /// Return the LLVM function that this machine code represents 706 /// Return the LLVM function that this machine code represents 709 /// getName - Return the name of the corresponding LLVM function. 712 /// getFunctionNumber - Return a unique ID for the current function. 715 /// Returns true if this function has basic block sections enabled. 717return (BBSectionsType == BasicBlockSection::All ||
718 BBSectionsType == BasicBlockSection::List ||
719 BBSectionsType == BasicBlockSection::Preset);
724 /// Assign IsBeginSection IsEndSection fields for basic blocks in this 726void assignBeginEndSections();
728 /// getTarget - Return the target machine this machine code is compiled with 731 /// getSubtarget - Return the subtarget for which this machine code is being 735 /// getSubtarget - This method returns a pointer to the specified type of 736 /// TargetSubtargetInfo. In debug builds, it verifies that the object being 737 /// returned is of the correct type. 739return *
static_cast<constSTC *
>(STI);
742 /// getRegInfo - Return information about the registers currently in use. 746 /// getFrameInfo - Return the frame info object for the current function. 747 /// This object contains information about objects allocated on the stack 748 /// frame of the current function in an abstract way. 752 /// getJumpTableInfo - Return the jump table info object for the current 753 /// function. This object contains information about jump tables in the 754 /// current function. If the current function has no jump tables, this will 759 /// getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it 760 /// does already exist, allocate one. 763 /// getConstantPool - Return the constant pool object for the current 768 /// getWasmEHFuncInfo - Return information about how the current function uses 769 /// Wasm exception handling. Returns null for functions that don't use wasm 770 /// exception handling. 774 /// getWinEHFuncInfo - Return information about how the current function uses 775 /// Windows exception handling. Returns null for functions that don't use 776 /// funclets for exception handling. 780 /// getAlignment - Return the alignment of the function. 783 /// setAlignment - Set the alignment of the function. 786 /// ensureAlignment - Make sure the function is at least A bytes aligned. 792 /// exposesReturnsTwice - Returns true if the function calls setjmp or 793 /// any other similar functions with attribute "returns twice" without 794 /// having the attribute itself. 796return ExposesReturnsTwice;
799 /// setCallsSetJmp - Set a flag that indicates if there's a call to 800 /// a "returns twice" function. 802 ExposesReturnsTwice =
B;
805 /// Returns true if the function contains any inline assembly. 810 /// Set a flag that indicates that the function contains inline assembly. 820 /// True if this function needs frame moves for debug or exceptions. 821bool needsFrameMoves()
const;
823 /// Get the function properties 827 /// getInfo - Keep track of various per-function pieces of information for 828 /// backends that would like to do so. 832returnstatic_cast<Ty*
>(MFInfo);
837returnstatic_cast<constTy *
>(MFInfo);
842 MFInfo = Ty::template create<Ty>(
Allocator, Old);
843returnstatic_cast<Ty *
>(MFInfo);
846 /// Initialize the target specific MachineFunctionInfo 852assert(!MFInfo &&
"new function already has MachineFunctionInfo");
858 /// Returns the denormal handling type for the default rounding mode of the 862 /// getBlockNumbered - MachineBasicBlocks are automatically numbered when they 863 /// are inserted into the machine function. The block number for a machine 864 /// basic block can be found by using the MBB::getNumber method, this method 865 /// provides the inverse mapping. 867assert(
N < MBBNumbering.size() &&
"Illegal block number");
868assert(MBBNumbering[
N] &&
"Block was removed from the machine function!");
869return MBBNumbering[
N];
872 /// Should we be emitting segmented stack stuff for the function 873bool shouldSplitStack()
const;
875 /// getNumBlockIDs - Return the number of MBB ID's allocated. 878 /// Return the numbering "epoch" of block numbers, incremented after each 879 /// numbering. Intended for asserting that no renumbering was performed when 880 /// used by, e.g., preserved analyses. 883 /// RenumberBlocks - This discards all of the MachineBasicBlock numbers and 884 /// recomputes them. This guarantees that the MBB numbers are sequential, 885 /// dense, and match the ordering of the blocks within the function. If a 886 /// specific MachineBasicBlock is specified, only that block and those after 887 /// it are renumbered. 890 /// Return an estimate of the function's code size, 891 /// taking into account block and function alignment 894 /// print - Print out the MachineFunction in a format suitable for debugging 895 /// to the specified stream. 898 /// viewCFG - This function is meant for use from the debugger. You can just 899 /// say 'call F->viewCFG()' and a ghostview window should pop up from the 900 /// program, displaying the CFG of the current function with the code for each 901 /// basic block inside. This depends on there being a 'dot' and 'gv' program 905 /// viewCFGOnly - This function is meant for use from the debugger. It works 906 /// just like viewCFG, but it does not include the contents of basic blocks 907 /// into the nodes, just the label. If you are only interested in the CFG 908 /// this can make the graph smaller. 910void viewCFGOnly()
const;
912 /// dump - Print the current MachineFunction to cerr, useful for debugger use. 915 /// Run the current MachineFunction through the machine code verifier, useful 916 /// for debugger use. 917 /// \returns true if no problems were found. 918boolverify(
Pass *p =
nullptr,
constchar *Banner =
nullptr,
921 /// Run the current MachineFunction through the machine code verifier, useful 922 /// for debugger use. 923 /// \returns true if no problems were found. 926bool AbortOnError =
true)
const;
928// Provide accessors for the MachineBasicBlock list... 934 /// Support for MachineBasicBlock::getNextNode(). 937return &MachineFunction::BasicBlocks;
940 /// addLiveIn - Add the specified physical register as a live-in value and 941 /// create a corresponding virtual register for it. 944//===--------------------------------------------------------------------===// 945// BasicBlock accessor functions. 957unsignedsize()
const{
return (
unsigned)BasicBlocks.size();}
958boolempty()
const{
return BasicBlocks.empty(); }
970 BasicBlocks.
splice(InsertPt, BasicBlocks,
MBBI);
973 BasicBlocks.
splice(InsertPt, BasicBlocks,
MBB);
976 BasicBlocks.
splice(InsertPt, BasicBlocks,
MBBI, MBBE);
984template <
typename Comp>
986 BasicBlocks.sort(comp);
989 /// Return the number of \p MachineInstrs in this \p MachineFunction. 997//===--------------------------------------------------------------------===// 998// Internal functions used to automatically number MachineBasicBlocks 1000 /// Adds the MBB to the internal numbering. Returns the unique number 1001 /// assigned to the MBB. 1003 MBBNumbering.push_back(
MBB);
1004return (
unsigned)MBBNumbering.size()-1;
1007 /// removeFromMBBNumbering - Remove the specific machine basic block from our 1008 /// tracker, this is only really to be used by the MachineBasicBlock 1011assert(
N < MBBNumbering.size() &&
"Illegal basic block #");
1012 MBBNumbering[
N] =
nullptr;
1015 /// CreateMachineInstr - Allocate a new MachineInstr. Use this instead 1016 /// of `new MachineInstr'. 1018bool NoImplicit =
false);
1020 /// Create a new MachineInstr which is a copy of \p Orig, identical in all 1021 /// ways except the instruction has no parent, prev, or next. Bundling flags 1024 /// Note: Clones a single instruction, not whole instruction bundles. 1025 /// Does not perform target specific adjustments; consider using 1026 /// TargetInstrInfo::duplicate() instead. 1029 /// Clones instruction or the whole instruction bundle \p Orig and insert 1030 /// into \p MBB before \p InsertBefore. 1032 /// Note: Does not perform target specific adjustments; consider using 1033 /// TargetInstrInfo::duplicate() instead. 1039 /// DeleteMachineInstr - Delete the given MachineInstr. 1042 /// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this 1043 /// instead of `new MachineBasicBlock'. Sets `MachineBasicBlock::BBID` if 1044 /// basic-block-sections is enabled for the function. 1046 CreateMachineBasicBlock(
constBasicBlock *BB =
nullptr,
1047 std::optional<UniqueBBID> BBID = std::nullopt);
1049 /// DeleteMachineBasicBlock - Delete the given MachineBasicBlock. 1052 /// getMachineMemOperand - Allocate a new MachineMemOperand. 1053 /// MachineMemOperands are owned by the MachineFunction and need not be 1054 /// explicitly deallocated. 1074 BaseAlignment, AAInfo, Ranges, SSID, Ordering,
1078 /// getMachineMemOperand - Allocate a new MachineMemOperand by copying 1079 /// an existing one, adjusting by an offset and using the given size. 1080 /// MachineMemOperands are owned by the MachineFunction and need not be 1081 /// explicitly deallocated. 1090 ? LLT::scalable_vector(1, 8 *
Size.getValue().getKnownMinValue())
1091 : LLT::scalar(8 *
Size.getValue().getKnownMinValue()));
1098 /// getMachineMemOperand - Allocate a new MachineMemOperand by copying 1099 /// an existing one, replacing only the MachinePointerInfo and size. 1100 /// MachineMemOperands are owned by the MachineFunction and need not be 1101 /// explicitly deallocated. 1114 /// Allocate a new MachineMemOperand by copying an existing one, 1115 /// replacing only AliasAnalysis information. MachineMemOperands are owned 1116 /// by the MachineFunction and need not be explicitly deallocated. 1120 /// Allocate a new MachineMemOperand by copying an existing one, 1121 /// replacing the flags. MachineMemOperands are owned 1122 /// by the MachineFunction and need not be explicitly deallocated. 1128 /// Allocate an array of MachineOperands. This is only intended for use by 1129 /// internal MachineInstr functions. 1134 /// Dellocate an array of MachineOperands and recycle the memory. This is 1135 /// only intended for use by internal MachineInstr functions. 1136 /// Cap must be the same capacity that was used to allocate the array. 1141 /// Allocate and initialize a register mask with @p NumRegister bits. 1146 /// Allocate and construct an extra info structure for a `MachineInstr`. 1148 /// This is allocated on the function's allocator and so lives the life of 1150 MachineInstr::ExtraInfo *createMIExtraInfo(
1152MCSymbol *PostInstrSymbol =
nullptr,
MDNode *HeapAllocMarker =
nullptr,
1156 /// Allocate a string and populate it with the given external symbol name. 1159//===--------------------------------------------------------------------===// 1160// Label Manipulation. 1162 /// getJTISymbol - Return the MCSymbol for the specified non-empty jump table. 1163 /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a 1164 /// normal 'L' label is returned. 1166bool isLinkerPrivate =
false)
const;
1168 /// getPICBaseSymbol - Return a function-local symbol to represent the PIC 1172 /// Returns a reference to a list of cfi instructions in the function's 1173 /// prologue. Used to construct frame maps for debug and exception handling 1176return FrameInstructions;
1181 /// Returns a reference to a list of symbols immediately following calls to 1182 /// _setjmp in the function. Used to construct the longjmp target table used 1183 /// by Windows Control Flow Guard. 1185return LongjmpTargets;
1188 /// Add the specified symbol to the list of valid longjmp targets for Windows 1189 /// Control Flow Guard. 1192 /// Returns a reference to a list of symbols that we have catchrets. 1193 /// Used to construct the catchret target table used by Windows EHCont Guard. 1195return CatchretTargets;
1198 /// Add the specified symbol to the list of valid catchret targets for Windows 1201 CatchretTargets.push_back(
Target);
1204 /// Tries to get the global and target flags for a call site, if the 1205 /// instruction is a call to a global. 1207return CalledGlobalsInfo.
lookup(
MI);
1210 /// Notes the global and target flags for a call site. 1214 CalledGlobalsInfo.
insert({
MI, Details});
1217 /// Iterates over the full set of call sites and their associated globals. 1222 /// \name Exception Handling 1246 /// Find or create an LandingPadInfo for the specified MachineBasicBlock. 1249 /// Return a reference to the landing pad info for the current function. 1254 /// Provide the begin and end labels of an invoke style call and associate it 1255 /// with a try landing pad block. 1259 /// Add a new panding pad, and extract the exception handling information from 1260 /// the landingpad instruction. Returns the label ID for the landing pad 1264 /// Return the type id for the specified typeinfo. This is function wide. 1267 /// Return the id of the filter encoded by TyIds. This is function wide. 1270 /// Map the landing pad's EH symbol to the call site indexes. 1273 /// Return if there is any wasm exception handling. 1275return !WasmLPadToIndexMap.
empty();
1278 /// Map the landing pad to its index. Used for Wasm exception handling. 1280 WasmLPadToIndexMap[LPad] =
Index;
1283 /// Returns true if the landing pad has an associate index in wasm EH. 1285return WasmLPadToIndexMap.
count(LPad);
1288 /// Get the index in wasm EH for a given landing pad. 1290assert(hasWasmLandingPadIndex(LPad));
1291return WasmLPadToIndexMap.
lookup(LPad);
1295return !LPadToCallSiteMap.
empty();
1298 /// Get the call site indexes for a landing pad EH symbol. 1301"missing call site number for landing pad!");
1302return LPadToCallSiteMap[
Sym];
1305 /// Return true if the landing pad Eh symbol has an associated call site. 1307return !LPadToCallSiteMap[
Sym].
empty();
1311return !CallSiteMap.
empty();
1314 /// Map the begin label for a call site. 1316 CallSiteMap[BeginLabel] = Site;
1319 /// Get the call site number for a begin label. 1321assert(hasCallSiteBeginLabel(BeginLabel) &&
1322"Missing call site number for EH_LABEL!");
1323return CallSiteMap.
lookup(BeginLabel);
1326 /// Return true if the begin label has a call site number associated with it. 1328return CallSiteMap.
count(BeginLabel);
1331 /// Record annotations associated with a particular label. 1333 CodeViewAnnotations.push_back({Label, MD});
1337return CodeViewAnnotations;
1340 /// Return a reference to the C++ typeinfo for the current function. 1345 /// Return a reference to the typeids encoding filters used in the current 1353 /// Collect information used to emit debugging information of a variable in a 1360 /// Collect information used to emit debugging information of a variable in 1361 /// the entry value of a register. 1369return VariableDbgInfos;
1372 /// Returns the collection of variables for which we have debug info and that 1373 /// have been assigned a stack slot. 1376return VarInfo.inStackSlot();
1380 /// Returns the collection of variables for which we have debug info and that 1381 /// have been assigned a stack slot. 1384return VarInfo.inStackSlot();
1388 /// Returns the collection of variables for which we have debug info and that 1389 /// have been assigned an entry value register. 1392return VarInfo.inEntryValueRegister();
1396 /// Start tracking the arguments passed to the call \p CallI. 1402assert(Inserted &&
"Call site info not unique");
1406return CallSitesInfo;
1409 /// Following functions update call site info. They should be called before 1410 /// removing, replacing or copying call instruction. 1412 /// Erase the call site info for \p MI. It is used to remove a call 1413 /// instruction from the instruction stream. 1415 /// Copy the call site info from \p Old to \ New. Its usage is when we are 1416 /// making a copy of the instruction that will be inserted at different point 1417 /// of the instruction stream. 1420 /// Move the call site info from \p Old to \New call site info. This function 1421 /// is used when we are replacing one call instruction with another one to 1422 /// the same callee. 1426return ++DebugInstrNumberingCount;
1430//===--------------------------------------------------------------------===// 1431// GraphTraits specializations for function basic block graphs (CFGs) 1432//===--------------------------------------------------------------------===// 1434// Provide specializations of GraphTraits to be able to treat a 1435// machine function as a graph of machine basic blocks... these are 1436// the same as the machine basic block iterators, except that the root 1437// node is implicitly the first node of the function. 1443// nodes_iterator/begin/end - Allow iteration over all nodes in the graph 1457returnF->getNumBlockIDs();
1460returnF->getBlockNumberEpoch();
1467// nodes_iterator/begin/end - Allow iteration over all nodes in the graph 1483returnF->getNumBlockIDs();
1486returnF->getBlockNumberEpoch();
1490// Provide specializations of GraphTraits to be able to treat a function as a 1491// graph of basic blocks... and to walk it in inverse order. Inverse order for 1492// a function is considered to be when traversing the predecessor edges of a BB 1493// instead of the successor edges. 1498return &
G.Graph->front();
1502returnF->getNumBlockIDs();
1505returnF->getBlockNumberEpoch();
1511return &
G.Graph->front();
1515returnF->getNumBlockIDs();
1518returnF->getBlockNumberEpoch();
1523const MachineFunction &MF);
1525}
// end namespace llvm 1527#endif// LLVM_CODEGEN_MACHINEFUNCTION_H aarch64 AArch64 CCMP Pass
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
This file defines the BumpPtrAllocator interface.
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
Atomic ordering constants.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static void viewCFG(Function &F, const BlockFrequencyInfo *BFI, const BranchProbabilityInfo *BPI, uint64_t MaxFreq, bool CFGOnly=false)
static unsigned InstrCount
This file defines the DenseMap class.
std::optional< std::vector< StOtherPiece > > Other
This file defines the little GraphTraits<X> template class that should be specialized by classes that...
static uint64_t estimateFunctionSizeInBytes(const LoongArchInstrInfo *TII, const MachineFunction &MF)
static unsigned addLiveIn(MachineFunction &MF, unsigned PReg, const TargetRegisterClass *RC)
static StringRef getName(Value *V)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
static MachineMemOperand * getMachineMemOperand(MachineFunction &MF, FrameIndexSDNode &FI)
The size of an allocated array is represented by a Capacity instance.
Recycle small arrays allocated from a BumpPtrAllocator.
T * allocate(Capacity Cap, AllocatorType &Allocator)
Allocate an array of at least the requested capacity.
void deallocate(Capacity Cap, T *Ptr)
Deallocate an array with the specified Capacity.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
The address of a basic block.
Allocate memory in an ever growing pool, as if by bump-pointer.
A parsed version of the target data layout string in and methods for querying it.
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&...Args)
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Abstract class that contains various methods for clients to notify about changes.
Context object for machine code objects.
Describe properties that are true of each instruction in the target description file.
Wrapper class representing physical registers. Should be passed by value.
Instances of this class represent a uniqued identifier for a section in the current translation unit.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
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.
Properties which a MachineFunction may have at a given point in time.
MachineFunctionProperties & reset()
Reset all the properties.
MachineFunctionProperties & set(const MachineFunctionProperties &MFP)
void print(raw_ostream &OS) const
Print the MachineFunctionProperties in human-readable form.
bool verifyRequiredProperties(const MachineFunctionProperties &V) const
MachineFunctionProperties & reset(const MachineFunctionProperties &MFP)
MachineFunctionProperties & set(Property P)
bool hasProperty(Property P) const
MachineFunctionProperties & reset(Property P)
Location of a PHI instruction that is also a debug-info variable value, for the duration of register ...
DebugPHIRegallocPos(MachineBasicBlock *MBB, Register Reg, unsigned SubReg)
Register Reg
VReg where the control-flow-merge happens.
unsigned SubReg
Optional subreg qualifier within Reg.
MachineBasicBlock * MBB
Block where this PHI was originally located.
Replacement definition for a debug instruction reference.
bool operator<(const DebugSubstitution &Other) const
Order only by source instruction / operand pair: there should never be duplicate entries for the same...
DebugInstrOperandPair Dest
Replacement instruction / operand pair.
DebugInstrOperandPair Src
Source instruction / operand pair.
DebugSubstitution(const DebugInstrOperandPair &Src, const DebugInstrOperandPair &Dest, unsigned Subreg)
unsigned Subreg
Qualifier for which part of Dest is read.
virtual void MF_HandleChangeDesc(MachineInstr &MI, const MCInstrDesc &TID)
Callback before changing MCInstrDesc.
virtual void MF_HandleRemoval(MachineInstr &MI)=0
Callback before a removal. This should not modify the MI directly.
virtual void MF_HandleInsertion(MachineInstr &MI)=0
Callback after an insertion. This should not modify the MI directly.
virtual ~Delegate()=default
Description of the location of a variable whose Address is valid and unchanging during function execu...
bool inStackSlot() const
Return true if this variable is in a stack slot.
void updateStackSlot(int NewSlot)
Updates the stack slot of this variable, assuming inStackSlot() is true.
MCRegister getEntryValueRegister() const
Returns the MCRegister of this variable, assuming inEntryValueRegister() is true.
bool inEntryValueRegister() const
Return true if this variable is in the entry value of a register.
const DILocalVariable * Var
VariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr, int Slot, const DILocation *Loc)
int getStackSlot() const
Returns the stack slot of this variable, assuming inStackSlot() is true.
const DIExpression * Expr
VariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr, MCRegister EntryValReg, const DILocation *Loc)
unsigned getInstructionCount() const
Return the number of MachineInstrs in this MachineFunction.
auto getEntryValueVariableDbgInfo() const
Returns the collection of variables for which we have debug info and that have been assigned an entry...
void setBBSectionsType(BasicBlockSection V)
MachineJumpTableInfo * getJumpTableInfo()
const WinEHFuncInfo * getWinEHFuncInfo() const
getWinEHFuncInfo - Return information about how the current function uses Windows exception handling.
void setCallsUnwindInit(bool b)
unsigned addToMBBNumbering(MachineBasicBlock *MBB)
Adds the MBB to the internal numbering.
void addLongjmpTarget(MCSymbol *Target)
Add the specified symbol to the list of valid longjmp targets for Windows Control Flow Guard.
const MachineConstantPool * getConstantPool() const
const MachineFrameInfo & getFrameInfo() const
void setHasEHFunclets(bool V)
std::pair< unsigned, unsigned > DebugInstrOperandPair
Pair of instruction number and operand number.
ArrayRecycler< MachineOperand >::Capacity OperandCapacity
void setExposesReturnsTwice(bool B)
setCallsSetJmp - Set a flag that indicates if there's a call to a "returns twice" function.
void removeFromMBBNumbering(unsigned N)
removeFromMBBNumbering - Remove the specific machine basic block from our tracker,...
SmallVector< DebugSubstitution, 8 > DebugValueSubstitutions
Debug value substitutions: a collection of DebugSubstitution objects, recording changes in where a va...
unsigned getFunctionNumber() const
getFunctionNumber - Return a unique ID for the current function.
void setHasInlineAsm(bool B)
Set a flag that indicates that the function contains inline assembly.
bool hasAnyCallSiteLabel() const
CalledGlobalInfo tryGetCalledGlobal(const MachineInstr *MI) const
Tries to get the global and target flags for a call site, if the instruction is a call to a global.
PseudoSourceValueManager & getPSVManager() const
void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site)
Map the begin label for a call site.
void setHasWinCFI(bool v)
void setWasmLandingPadIndex(const MachineBasicBlock *LPad, unsigned Index)
Map the landing pad to its index. Used for Wasm exception handling.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
const std::vector< MCCFIInstruction > & getFrameInstructions() const
Returns a reference to a list of cfi instructions in the function's prologue.
unsigned getNewDebugInstrNum()
void setHasEHCatchret(bool V)
MachineFunction & operator=(const MachineFunction &)=delete
bool hasInlineAsm() const
Returns true if the function contains any inline assembly.
void setCallsEHReturn(bool b)
bool hasEHCatchret() const
BasicBlockListType::reverse_iterator reverse_iterator
void setAlignment(Align A)
setAlignment - Set the alignment of the function.
WinEHFuncInfo * getWinEHFuncInfo()
bool exposesReturnsTwice() const
exposesReturnsTwice - Returns true if the function calls setjmp or any other similar functions with a...
MachineFunctionProperties & getProperties()
GISelChangeObserver * getObserver() const
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array)
Dellocate an array of MachineOperands and recycle the memory.
void setSection(MCSection *S)
Indicates the Section this function belongs to.
bool callsUnwindInit() const
MachineMemOperand * getMachineMemOperand(const MachineMemOperand *MMO, int64_t Offset, uint64_t Size)
void push_front(MachineBasicBlock *MBB)
const std::vector< unsigned > & getFilterIds() const
Return a reference to the typeids encoding filters used in the current function.
const std::vector< const GlobalValue * > & getTypeInfos() const
Return a reference to the C++ typeinfo for the current function.
auto getInStackSlotVariableDbgInfo() const
Returns the collection of variables for which we have debug info and that have been assigned a stack ...
bool hasAnyWasmLandingPadIndex() const
Return if there is any wasm exception handling.
const CallSiteInfoMap & getCallSitesInfo() const
void ensureAlignment(Align A)
ensureAlignment - Make sure the function is at least A bytes aligned.
void push_back(MachineBasicBlock *MBB)
reverse_iterator rbegin()
void setHasFakeUses(bool V)
bool hasBBSections() const
Returns true if this function has basic block sections enabled.
MCContext & getContext() const
bool callsEHReturn() const
void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr, MCRegister Reg, const DILocation *Loc)
Collect information used to emit debugging information of a variable in the entry value of a register...
const Function & getFunction() const
Return the LLVM function that this machine code represents.
MachineOperand * allocateOperandArray(OperandCapacity Cap)
Allocate an array of MachineOperands.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
MachineBasicBlock * getBlockNumbered(unsigned N) const
getBlockNumbered - MachineBasicBlocks are automatically numbered when they are inserted into the mach...
auto getInStackSlotVariableDbgInfo()
Returns the collection of variables for which we have debug info and that have been assigned a stack ...
Align getAlignment() const
getAlignment - Return the alignment of the function.
void splice(iterator InsertPt, iterator MBBI, iterator MBBE)
void addCatchretTarget(MCSymbol *Target)
Add the specified symbol to the list of valid catchret targets for Windows EHCont Guard.
unsigned getWasmLandingPadIndex(const MachineBasicBlock *LPad) const
Get the index in wasm EH for a given landing pad.
const_iterator end() const
static const unsigned int DebugOperandMemNumber
A reserved operand number representing the instructions memory operand, for instructions that have a ...
void setObserver(GISelChangeObserver *O)
unsigned getBlockNumberEpoch() const
Return the numbering "epoch" of block numbers, incremented after each numbering.
void resetDelegate(Delegate *delegate)
Reset the currently registered delegate - otherwise assert.
void addCodeViewAnnotation(MCSymbol *Label, MDNode *MD)
Record annotations associated with a particular label.
Function & getFunction()
Return the LLVM function that this machine code represents.
MachineMemOperand * getMachineMemOperand(const MachineMemOperand *MMO, const MachinePointerInfo &PtrInfo, uint64_t Size)
void erase(MachineBasicBlock *MBBI)
unsigned getNumBlockIDs() const
getNumBlockIDs - Return the number of MBB ID's allocated.
const_iterator begin() const
void remove(MachineBasicBlock *MBBI)
void setIsOutlined(bool V)
const std::vector< MCSymbol * > & getLongjmpTargets() const
Returns a reference to a list of symbols immediately following calls to _setjmp in the function.
const std::vector< LandingPadInfo > & getLandingPads() const
Return a reference to the landing pad info for the current function.
MCSection * getSection() const
Returns the Section this function belongs to.
const VariableDbgInfoMapTy & getVariableDbgInfo() const
const MachineBasicBlock & back() const
const_reverse_iterator rbegin() const
const STC & getSubtarget() const
getSubtarget - This method returns a pointer to the specified type of TargetSubtargetInfo.
BasicBlockListType::const_reverse_iterator const_reverse_iterator
unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) const
Get the call site number for a begin label.
void remove(iterator MBBI)
VariableDbgInfoMapTy & getVariableDbgInfo()
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
MachineConstantPool * getConstantPool()
getConstantPool - Return the constant pool object for the current function.
const MachineRegisterInfo & getRegInfo() const
const WasmEHFuncInfo * getWasmEHFuncInfo() const
getWasmEHFuncInfo - Return information about how the current function uses Wasm exception handling.
bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) const
Return true if the begin label has a call site number associated with it.
void splice(iterator InsertPt, MachineBasicBlock *MBB)
void addCallSiteInfo(const MachineInstr *CallI, CallSiteInfo &&CallInfo)
Start tracking the arguments passed to the call CallI.
static BasicBlockListType MachineFunction::* getSublistAccess(MachineBasicBlock *)
Support for MachineBasicBlock::getNextNode().
bool hasWasmLandingPadIndex(const MachineBasicBlock *LPad) const
Returns true if the landing pad has an associate index in wasm EH.
const MachineFunctionProperties & getProperties() const
Get the function properties.
Ty * cloneInfo(const Ty &Old)
const std::vector< MCSymbol * > & getCatchretTargets() const
Returns a reference to a list of symbols that we have catchrets.
bool hasCallSiteLandingPad(MCSymbol *Sym)
Return true if the landing pad Eh symbol has an associated call site.
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 setDelegate(Delegate *delegate)
Set the delegate.
void reset()
Reset the instance as if it was just created.
DenseMap< unsigned, DebugPHIRegallocPos > DebugPHIPositions
Map of debug instruction numbers to the position of their PHI instructions during register allocation...
const MachineBasicBlock & front() const
void setHasEHScopes(bool V)
MachineMemOperand * getMachineMemOperand(const MachineMemOperand *MMO, int64_t Offset, LocationSize Size)
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags F, uint64_t Size, Align BaseAlignment, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr, SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)
const Ty * getInfo() const
bool hasEHFunclets() const
const MachineJumpTableInfo * getJumpTableInfo() const
getJumpTableInfo - Return the jump table info object for the current function.
const_reverse_iterator rend() const
bool hasAnyCallSiteLandingPad() const
WasmEHFuncInfo * getWasmEHFuncInfo()
void splice(iterator InsertPt, iterator MBBI)
auto getCalledGlobals() const
Iterates over the full set of call sites and their associated globals.
void addCalledGlobal(const MachineInstr *MI, CalledGlobalInfo Details)
Notes the global and target flags for a call site.
void erase(iterator MBBI)
ArrayRef< std::pair< MCSymbol *, MDNode * > > getCodeViewAnnotations() const
VariableDbgInfoMapTy VariableDbgInfos
MachineFunction(const MachineFunction &)=delete
void insert(iterator MBBI, MachineBasicBlock *MBB)
MachineBasicBlock & back()
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
BasicBlockListType::const_iterator const_iterator
MachineFunctionInfo * cloneInfoFrom(const MachineFunction &OrigMF, const DenseMap< MachineBasicBlock *, MachineBasicBlock * > &Src2DstMBB)
MachineBasicBlock & front()
SmallVectorImpl< unsigned > & getCallSiteLandingPad(MCSymbol *Sym)
Get the call site indexes for a landing pad EH symbol.
Representation of each machine instruction.
bool isCandidateForAdditionalCallInfo(QueryType Type=IgnoreBundle) const
Return true if this is a call instruction that may have an additional information associated with it.
A description of a memory reference used in the backend.
Flags
Flags values. These may be or'd together.
MachineOperand class - Representation of each machine instruction operand.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Pass interface - Implemented by all 'passes'.
Manages creation of pseudo source values.
Recycler - This class manages a linked-list of deallocated nodes and facilitates reusing deallocated ...
Wrapper class representing virtual and physical registers.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
std::reverse_iterator< const_iterator > const_reverse_iterator
std::reverse_iterator< iterator > reverse_iterator
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
Primary interface to the complete machine description for the target machine.
TargetSubtargetInfo - Generic base class for all target subtargets.
Target - Wrapper for Target specific information.
void splice(iterator where, iplist_impl &L2)
void push_back(pointer val)
iterator erase(iterator where)
pointer remove(iterator &IT)
void push_front(pointer val)
iterator insert(iterator where, pointer New)
An intrusive list with ownership and callbacks specified/controlled by ilist_traits,...
This class implements an extremely fast bulk output stream that can only output to a stream.
This file defines classes to implement an intrusive doubly linked list class (i.e.
@ Cold
Attempts to make code in the caller as efficient as possible under the assumption that the call is no...
@ BasicBlock
Various leaf nodes.
This is an optimization pass for GlobalISel generic memory operations.
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
MachineFunctionDataHotness
void verifyMachineFunction(const std::string &Banner, const MachineFunction &MF)
iterator_range< filter_iterator< detail::IterOfRange< RangeT >, PredicateT > > make_filter_range(RangeT &&Range, PredicateT Pred)
Convenience function that takes a range of elements and a predicate, and return a new filter_iterator...
AtomicOrdering
Atomic ordering for LLVM's memory model.
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
This struct is a compact representation of a valid (non-zero power of two) alignment.
Represent subnormal handling kind for floating point instruction inputs and outputs.
static unsigned getNumberEpoch(MachineFunction *F)
static unsigned getMaxNumber(MachineFunction *F)
static NodeRef getEntryNode(Inverse< MachineFunction * > G)
static unsigned getNumberEpoch(const MachineFunction *F)
static unsigned getMaxNumber(const MachineFunction *F)
static NodeRef getEntryNode(Inverse< const MachineFunction * > G)
static unsigned getNumberEpoch(MachineFunction *F)
static unsigned size(MachineFunction *F)
static nodes_iterator nodes_begin(MachineFunction *F)
static unsigned getMaxNumber(MachineFunction *F)
static nodes_iterator nodes_end(MachineFunction *F)
static NodeRef getEntryNode(MachineFunction *F)
static nodes_iterator nodes_begin(const MachineFunction *F)
static nodes_iterator nodes_end(const MachineFunction *F)
static unsigned size(const MachineFunction *F)
static unsigned getMaxNumber(const MachineFunction *F)
static NodeRef getEntryNode(const MachineFunction *F)
static unsigned getNumberEpoch(const MachineFunction *F)
This structure is used to retain landing pad info for the current function.
SmallVector< MCSymbol *, 1 > EndLabels
MCSymbol * LandingPadLabel
SmallVector< SEHHandler, 1 > SEHHandlers
LandingPadInfo(MachineBasicBlock *MBB)
MachineBasicBlock * LandingPadBlock
SmallVector< MCSymbol *, 1 > BeginLabels
std::vector< int > TypeIds
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
static FuncInfoTy * create(BumpPtrAllocator &Allocator, const Function &F, const SubtargetTy *STI)
Factory function: default behavior is to call new using the supplied allocator.
virtual ~MachineFunctionInfo()
virtual MachineFunctionInfo * clone(BumpPtrAllocator &Allocator, MachineFunction &DestMF, const DenseMap< MachineBasicBlock *, MachineBasicBlock * > &Src2DstMBB) const
Make a functionally equivalent copy of this MachineFunctionInfo in MF.
static Ty * create(BumpPtrAllocator &Allocator, const Ty &MFI)
Structure used to represent pair of argument number after call lowering and register used to transfer...
ArgRegPair(Register R, unsigned Arg)
SmallVector< ArgRegPair, 1 > ArgRegPairs
Vector of call argument and its forwarding register.
const GlobalValue * Callee
This class contains a discriminated union of information about pointers in memory operands,...
const BlockAddress * RecoverBA
Address of block to recover at. Null for a finally handler.
const Function * FilterOrFinally
Filter or finally function. Null indicates a catch-all.
Use delete by default for iplist and ilist.
static void deleteNode(NodeTy *V)
void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator)
Callbacks do nothing by default in iplist and ilist.
void removeNodeFromList(NodeTy *)
void addNodeToList(NodeTy *)
Template traits for intrusive list.
