LLVM 19.0.0git
MachineFunction.h
Go to the documentation of this file.
1//===- llvm/CodeGen/MachineFunction.h ---------------------------*- C++ -*-===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8//
9// Collect native machine code for a function. This class contains a list of
10// MachineBasicBlock instances that make up the current compiled function.
11//
12// This class also contains pointers to various classes which hold
13// target-specific information about the generated code.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef LLVM_CODEGEN_MACHINEFUNCTION_H
18#define LLVM_CODEGEN_MACHINEFUNCTION_H
19
20#include "llvm/ADT/ArrayRef.h"
21#include "llvm/ADT/BitVector.h"
22#include "llvm/ADT/DenseMap.h"
25#include "llvm/ADT/ilist.h"
26#include "llvm/ADT/iterator.h"
37#include <cassert>
38#include <cstdint>
39#include <memory>
40#include <utility>
41#include <variant>
42#include <vector>
43
44namespace llvm {
45
46class BasicBlock;
47class BlockAddress;
48class DataLayout;
49class DebugLoc;
50struct DenormalMode;
51class DIExpression;
52class DILocalVariable;
53class DILocation;
54class Function;
55class GISelChangeObserver;
56class GlobalValue;
57class LLVMTargetMachine;
58class MachineConstantPool;
59class MachineFrameInfo;
60class MachineFunction;
61class MachineJumpTableInfo;
62class MachineModuleInfo;
63class MachineRegisterInfo;
64class MCContext;
65class MCInstrDesc;
66class MCSymbol;
67class MCSection;
68class Pass;
69class PseudoSourceValueManager;
70class raw_ostream;
71class SlotIndexes;
72class StringRef;
73class TargetRegisterClass;
74class TargetSubtargetInfo;
75struct WasmEHFuncInfo;
76struct WinEHFuncInfo;
77
80};
81
85
86 template <class Iterator>
87 void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator) {
88 assert(this == &OldList && "never transfer MBBs between functions");
89 }
90};
91
92/// MachineFunctionInfo - This class can be derived from and used by targets to
93/// hold private target-specific information for each MachineFunction. Objects
94/// of type are accessed/created with MF::getInfo and destroyed when the
95/// MachineFunction is destroyed.
98
99 /// Factory function: default behavior is to call new using the
100 /// supplied allocator.
101 ///
102 /// This function can be overridden in a derive class.
103 template <typename FuncInfoTy, typename SubtargetTy = TargetSubtargetInfo>
104 static FuncInfoTy *create(BumpPtrAllocator &Allocator, const Function &F,
105 const SubtargetTy *STI) {
106 return new (Allocator.Allocate<FuncInfoTy>()) FuncInfoTy(F, STI);
107 }
108
109 template <typename Ty>
110 static Ty *create(BumpPtrAllocator &Allocator, const Ty &MFI) {
111 return new (Allocator.Allocate<Ty>()) Ty(MFI);
112 }
113
114 /// Make a functionally equivalent copy of this MachineFunctionInfo in \p MF.
115 /// This requires remapping MachineBasicBlock references from the original
116 /// parent to values in the new function. Targets may assume that virtual
117 /// register and frame index values are preserved in the new function.
118 virtual MachineFunctionInfo *
121 const {
122 return nullptr;
123 }
124};
125
126/// Properties which a MachineFunction may have at a given point in time.
127/// Each of these has checking code in the MachineVerifier, and passes can
128/// require that a property be set.
130 // Possible TODO: Allow targets to extend this (perhaps by allowing the
131 // constructor to specify the size of the bit vector)
132 // Possible TODO: Allow requiring the negative (e.g. VRegsAllocated could be
133 // stated as the negative of "has vregs"
134
135public:
136 // The properties are stated in "positive" form; i.e. a pass could require
137 // that the property hold, but not that it does not hold.
138
139 // Property descriptions:
140 // IsSSA: True when the machine function is in SSA form and virtual registers
141 // have a single def.
142 // NoPHIs: The machine function does not contain any PHI instruction.
143 // TracksLiveness: True when tracking register liveness accurately.
144 // While this property is set, register liveness information in basic block
145 // live-in lists and machine instruction operands (e.g. implicit defs) is
146 // accurate, kill flags are conservatively accurate (kill flag correctly
147 // indicates the last use of a register, an operand without kill flag may or
148 // may not be the last use of a register). This means it can be used to
149 // change the code in ways that affect the values in registers, for example
150 // by the register scavenger.
151 // When this property is cleared at a very late time, liveness is no longer
152 // reliable.
153 // NoVRegs: The machine function does not use any virtual registers.
154 // Legalized: In GlobalISel: the MachineLegalizer ran and all pre-isel generic
155 // instructions have been legalized; i.e., all instructions are now one of:
156 // - generic and always legal (e.g., COPY)
157 // - target-specific
158 // - legal pre-isel generic instructions.
159 // RegBankSelected: In GlobalISel: the RegBankSelect pass ran and all generic
160 // virtual registers have been assigned to a register bank.
161 // Selected: In GlobalISel: the InstructionSelect pass ran and all pre-isel
162 // generic instructions have been eliminated; i.e., all instructions are now
163 // target-specific or non-pre-isel generic instructions (e.g., COPY).
164 // Since only pre-isel generic instructions can have generic virtual register
165 // operands, this also means that all generic virtual registers have been
166 // constrained to virtual registers (assigned to register classes) and that
167 // all sizes attached to them have been eliminated.
168 // TiedOpsRewritten: The twoaddressinstruction pass will set this flag, it
169 // means that tied-def have been rewritten to meet the RegConstraint.
170 // FailsVerification: Means that the function is not expected to pass machine
171 // verification. This can be set by passes that introduce known problems that
172 // have not been fixed yet.
173 // TracksDebugUserValues: Without this property enabled, debug instructions
174 // such as DBG_VALUE are allowed to reference virtual registers even if those
175 // registers do not have a definition. With the property enabled virtual
176 // registers must only be used if they have a definition. This property
177 // allows earlier passes in the pipeline to skip updates of `DBG_VALUE`
178 // instructions to save compile time.
179 enum class Property : unsigned {
180 IsSSA,
181 NoPHIs,
183 NoVRegs,
185 Legalized,
187 Selected,
192 };
193
194 bool hasProperty(Property P) const {
195 return Properties[static_cast<unsigned>(P)];
196 }
197
199 Properties.set(static_cast<unsigned>(P));
200 return *this;
201 }
202
204 Properties.reset(static_cast<unsigned>(P));
205 return *this;
206 }
207
208 /// Reset all the properties.
210 Properties.reset();
211 return *this;
212 }
213
215 Properties |= MFP.Properties;
216 return *this;
217 }
218
220 Properties.reset(MFP.Properties);
221 return *this;
222 }
223
224 // Returns true if all properties set in V (i.e. required by a pass) are set
225 // in this.
227 return !V.Properties.test(Properties);
228 }
229
230 /// Print the MachineFunctionProperties in human-readable form.
231 void print(raw_ostream &OS) const;
232
233private:
234 BitVector Properties =
235 BitVector(static_cast<unsigned>(Property::LastProperty)+1);
236};
237
239 /// Filter or finally function. Null indicates a catch-all.
241
242 /// Address of block to recover at. Null for a finally handler.
244};
245
246/// This structure is used to retain landing pad info for the current function.
248 MachineBasicBlock *LandingPadBlock; // Landing pad block.
249 SmallVector<MCSymbol *, 1> BeginLabels; // Labels prior to invoke.
250 SmallVector<MCSymbol *, 1> EndLabels; // Labels after invoke.
251 SmallVector<SEHHandler, 1> SEHHandlers; // SEH handlers active at this lpad.
252 MCSymbol *LandingPadLabel = nullptr; // Label at beginning of landing pad.
253 std::vector<int> TypeIds; // List of type ids (filters negative).
254
256 : LandingPadBlock(MBB) {}
257};
258
260 Function &F;
262 const TargetSubtargetInfo *STI;
263 MCContext &Ctx;
265
266 // RegInfo - Information about each register in use in the function.
268
269 // Used to keep track of target-specific per-machine-function information for
270 // the target implementation.
271 MachineFunctionInfo *MFInfo;
272
273 // Keep track of objects allocated on the stack.
274 MachineFrameInfo *FrameInfo;
275
276 // Keep track of constants which are spilled to memory
278
279 // Keep track of jump tables for switch instructions
280 MachineJumpTableInfo *JumpTableInfo;
281
282 // Keep track of the function section.
283 MCSection *Section = nullptr;
284
285 // Catchpad unwind destination info for wasm EH.
286 // Keeps track of Wasm exception handling related data. This will be null for
287 // functions that aren't using a wasm EH personality.
288 WasmEHFuncInfo *WasmEHInfo = nullptr;
289
290 // Keeps track of Windows exception handling related data. This will be null
291 // for functions that aren't using a funclet-based EH personality.
292 WinEHFuncInfo *WinEHInfo = nullptr;
293
294 // Function-level unique numbering for MachineBasicBlocks. When a
295 // MachineBasicBlock is inserted into a MachineFunction is it automatically
296 // numbered and this vector keeps track of the mapping from ID's to MBB's.
297 std::vector<MachineBasicBlock*> MBBNumbering;
298
299 // Pool-allocate MachineFunction-lifetime and IR objects.
301
302 // Allocation management for instructions in function.
303 Recycler<MachineInstr> InstructionRecycler;
304
305 // Allocation management for operand arrays on instructions.
306 ArrayRecycler<MachineOperand> OperandRecycler;
307
308 // Allocation management for basic blocks in function.
309 Recycler<MachineBasicBlock> BasicBlockRecycler;
310
311 // List of machine basic blocks in function
313 BasicBlockListType BasicBlocks;
314
315 /// FunctionNumber - This provides a unique ID for each function emitted in
316 /// this translation unit.
317 ///
318 unsigned FunctionNumber;
319
320 /// Alignment - The alignment of the function.
321 Align Alignment;
322
323 /// ExposesReturnsTwice - True if the function calls setjmp or related
324 /// functions with attribute "returns twice", but doesn't have
325 /// the attribute itself.
326 /// This is used to limit optimizations which cannot reason
327 /// about the control flow of such functions.
328 bool ExposesReturnsTwice = false;
329
330 /// True if the function includes any inline assembly.
331 bool HasInlineAsm = false;
332
333 /// True if any WinCFI instruction have been emitted in this function.
334 bool HasWinCFI = false;
335
336 /// Current high-level properties of the IR of the function (e.g. is in SSA
337 /// form or whether registers have been allocated)
338 MachineFunctionProperties Properties;
339
340 // Allocation management for pseudo source values.
341 std::unique_ptr<PseudoSourceValueManager> PSVManager;
342
343 /// List of moves done by a function's prolog. Used to construct frame maps
344 /// by debug and exception handling consumers.
345 std::vector<MCCFIInstruction> FrameInstructions;
346
347 /// List of basic blocks immediately following calls to _setjmp. Used to
348 /// construct a table of valid longjmp targets for Windows Control Flow Guard.
349 std::vector<MCSymbol *> LongjmpTargets;
350
351 /// List of basic blocks that are the target of catchrets. Used to construct
352 /// a table of valid targets for Windows EHCont Guard.
353 std::vector<MCSymbol *> CatchretTargets;
354
355 /// \name Exception Handling
356 /// \{
357
358 /// List of LandingPadInfo describing the landing pad information.
359 std::vector<LandingPadInfo> LandingPads;
360
361 /// Map a landing pad's EH symbol to the call site indexes.
363
364 /// Map a landing pad to its index.
366
367 /// Map of invoke call site index values to associated begin EH_LABEL.
369
370 /// CodeView label annotations.
371 std::vector<std::pair<MCSymbol *, MDNode *>> CodeViewAnnotations;
372
373 bool CallsEHReturn = false;
374 bool CallsUnwindInit = false;
375 bool HasEHCatchret = false;
376 bool HasEHScopes = false;
377 bool HasEHFunclets = false;
378 bool IsOutlined = false;
379
380 /// BBID to assign to the next basic block of this function.
381 unsigned NextBBID = 0;
382
383 /// Section Type for basic blocks, only relevant with basic block sections.
384 BasicBlockSection BBSectionsType = BasicBlockSection::None;
385
386 /// List of C++ TypeInfo used.
387 std::vector<const GlobalValue *> TypeInfos;
388
389 /// List of typeids encoding filters used.
390 std::vector<unsigned> FilterIds;
391
392 /// List of the indices in FilterIds corresponding to filter terminators.
393 std::vector<unsigned> FilterEnds;
394
395 EHPersonality PersonalityTypeCache = EHPersonality::Unknown;
396
397 /// \}
398
399 /// Clear all the members of this MachineFunction, but the ones used
400 /// to initialize again the MachineFunction.
401 /// More specifically, this deallocates all the dynamically allocated
402 /// objects and get rid of all the XXXInfo data structure, but keep
403 /// unchanged the references to Fn, Target, MMI, and FunctionNumber.
404 void clear();
405 /// Allocate and initialize the different members.
406 /// In particular, the XXXInfo data structure.
407 /// \pre Fn, Target, MMI, and FunctionNumber are properly set.
408 void init();
409
410public:
411 /// Description of the location of a variable whose Address is valid and
412 /// unchanging during function execution. The Address may be:
413 /// * A stack index, which can be negative for fixed stack objects.
414 /// * A MCRegister, whose entry value contains the address of the variable.
416 std::variant<int, MCRegister> Address;
417
418 public:
422
424 int Slot, const DILocation *Loc)
425 : Address(Slot), Var(Var), Expr(Expr), Loc(Loc) {}
426
428 MCRegister EntryValReg, const DILocation *Loc)
429 : Address(EntryValReg), Var(Var), Expr(Expr), Loc(Loc) {}
430
431 /// Return true if this variable is in a stack slot.
432 bool inStackSlot() const { return std::holds_alternative<int>(Address); }
433
434 /// Return true if this variable is in the entry value of a register.
435 bool inEntryValueRegister() const {
436 return std::holds_alternative<MCRegister>(Address);
437 }
438
439 /// Returns the stack slot of this variable, assuming `inStackSlot()` is
440 /// true.
441 int getStackSlot() const { return std::get<int>(Address); }
442
443 /// Returns the MCRegister of this variable, assuming
444 /// `inEntryValueRegister()` is true.
446 return std::get<MCRegister>(Address);
447 }
448
449 /// Updates the stack slot of this variable, assuming `inStackSlot()` is
450 /// true.
451 void updateStackSlot(int NewSlot) {
452 assert(inStackSlot());
453 Address = NewSlot;
454 }
455 };
456
457 class Delegate {
458 virtual void anchor();
459
460 public:
461 virtual ~Delegate() = default;
462 /// Callback after an insertion. This should not modify the MI directly.
464 /// Callback before a removal. This should not modify the MI directly.
465 virtual void MF_HandleRemoval(MachineInstr &MI) = 0;
466 /// Callback before changing MCInstrDesc. This should not modify the MI
467 /// directly.
468 virtual void MF_HandleChangeDesc(MachineInstr &MI, const MCInstrDesc &TID) {
469 return;
470 }
471 };
472
473 /// Structure used to represent pair of argument number after call lowering
474 /// and register used to transfer that argument.
475 /// For now we support only cases when argument is transferred through one
476 /// register.
477 struct ArgRegPair {
480 ArgRegPair(Register R, unsigned Arg) : Reg(R), ArgNo(Arg) {
481 assert(Arg < (1 << 16) && "Arg out of range");
482 }
483 };
484
486 /// Vector of call argument and its forwarding register.
488 };
489
490private:
491 Delegate *TheDelegate = nullptr;
492 GISelChangeObserver *Observer = nullptr;
493
495 /// Map a call instruction to call site arguments forwarding info.
496 CallSiteInfoMap CallSitesInfo;
497
498 /// A helper function that returns call site info for a give call
499 /// instruction if debug entry value support is enabled.
500 CallSiteInfoMap::iterator getCallSiteInfo(const MachineInstr *MI);
501
502 // Callbacks for insertion and removal.
503 void handleInsertion(MachineInstr &MI);
504 void handleRemoval(MachineInstr &MI);
505 friend struct ilist_traits<MachineInstr>;
506
507public:
508 // Need to be accessed from MachineInstr::setDesc.
509 void handleChangeDesc(MachineInstr &MI, const MCInstrDesc &TID);
510
513
514 /// A count of how many instructions in the function have had numbers
515 /// assigned to them. Used for debug value tracking, to determine the
516 /// next instruction number.
517 unsigned DebugInstrNumberingCount = 0;
518
519 /// Set value of DebugInstrNumberingCount field. Avoid using this unless
520 /// you're deserializing this data.
521 void setDebugInstrNumberingCount(unsigned Num);
522
523 /// Pair of instruction number and operand number.
524 using DebugInstrOperandPair = std::pair<unsigned, unsigned>;
525
526 /// Replacement definition for a debug instruction reference. Made up of a
527 /// source instruction / operand pair, destination pair, and a qualifying
528 /// subregister indicating what bits in the operand make up the substitution.
529 // For example, a debug user
530 /// of %1:
531 /// %0:gr32 = someinst, debug-instr-number 1
532 /// %1:gr16 = %0.some_16_bit_subreg, debug-instr-number 2
533 /// Would receive the substitution {{2, 0}, {1, 0}, $subreg}, where $subreg is
534 /// the subregister number for some_16_bit_subreg.
536 public:
537 DebugInstrOperandPair Src; ///< Source instruction / operand pair.
538 DebugInstrOperandPair Dest; ///< Replacement instruction / operand pair.
539 unsigned Subreg; ///< Qualifier for which part of Dest is read.
540
542 const DebugInstrOperandPair &Dest, unsigned Subreg)
543 : Src(Src), Dest(Dest), Subreg(Subreg) {}
544
545 /// Order only by source instruction / operand pair: there should never
546 /// be duplicate entries for the same source in any collection.
547 bool operator<(const DebugSubstitution &Other) const {
548 return Src < Other.Src;
549 }
550 };
551
552 /// Debug value substitutions: a collection of DebugSubstitution objects,
553 /// recording changes in where a value is defined. For example, when one
554 /// instruction is substituted for another. Keeping a record allows recovery
555 /// of variable locations after compilation finishes.
557
558 /// Location of a PHI instruction that is also a debug-info variable value,
559 /// for the duration of register allocation. Loaded by the PHI-elimination
560 /// pass, and emitted as DBG_PHI instructions during VirtRegRewriter, with
561 /// maintenance applied by intermediate passes that edit registers (such as
562 /// coalescing and the allocator passes).
564 public:
565 MachineBasicBlock *MBB; ///< Block where this PHI was originally located.
566 Register Reg; ///< VReg where the control-flow-merge happens.
567 unsigned SubReg; ///< Optional subreg qualifier within Reg.
569 : MBB(MBB), Reg(Reg), SubReg(SubReg) {}
570 };
571
572 /// Map of debug instruction numbers to the position of their PHI instructions
573 /// during register allocation. See DebugPHIRegallocPos.
575
576 /// Flag for whether this function contains DBG_VALUEs (false) or
577 /// DBG_INSTR_REF (true).
578 bool UseDebugInstrRef = false;
579
580 /// Create a substitution between one <instr,operand> value to a different,
581 /// new value.
582 void makeDebugValueSubstitution(DebugInstrOperandPair, DebugInstrOperandPair,
583 unsigned SubReg = 0);
584
585 /// Create substitutions for any tracked values in \p Old, to point at
586 /// \p New. Needed when we re-create an instruction during optimization,
587 /// which has the same signature (i.e., def operands in the same place) but
588 /// a modified instruction type, flags, or otherwise. An example: X86 moves
589 /// are sometimes transformed into equivalent LEAs.
590 /// If the two instructions are not the same opcode, limit which operands to
591 /// examine for substitutions to the first N operands by setting
592 /// \p MaxOperand.
593 void substituteDebugValuesForInst(const MachineInstr &Old, MachineInstr &New,
594 unsigned MaxOperand = UINT_MAX);
595
596 /// Find the underlying defining instruction / operand for a COPY instruction
597 /// while in SSA form. Copies do not actually define values -- they move them
598 /// between registers. Labelling a COPY-like instruction with an instruction
599 /// number is to be avoided as it makes value numbers non-unique later in
600 /// compilation. This method follows the definition chain for any sequence of
601 /// COPY-like instructions to find whatever non-COPY-like instruction defines
602 /// the copied value; or for parameters, creates a DBG_PHI on entry.
603 /// May insert instructions into the entry block!
604 /// \p MI The copy-like instruction to salvage.
605 /// \p DbgPHICache A container to cache already-solved COPYs.
606 /// \returns An instruction/operand pair identifying the defining value.
608 salvageCopySSA(MachineInstr &MI,
610
611 DebugInstrOperandPair salvageCopySSAImpl(MachineInstr &MI);
612
613 /// Finalise any partially emitted debug instructions. These are DBG_INSTR_REF
614 /// instructions where we only knew the vreg of the value they use, not the
615 /// instruction that defines that vreg. Once isel finishes, we should have
616 /// enough information for every DBG_INSTR_REF to point at an instruction
617 /// (or DBG_PHI).
618 void finalizeDebugInstrRefs();
619
620 /// Determine whether, in the current machine configuration, we should use
621 /// instruction referencing or not.
622 bool shouldUseDebugInstrRef() const;
623
624 /// Returns true if the function's variable locations are tracked with
625 /// instruction referencing.
626 bool useDebugInstrRef() const;
627
628 /// Set whether this function will use instruction referencing or not.
629 void setUseDebugInstrRef(bool UseInstrRef);
630
631 /// A reserved operand number representing the instructions memory operand,
632 /// for instructions that have a stack spill fused into them.
633 const static unsigned int DebugOperandMemNumber;
634
636 const TargetSubtargetInfo &STI, unsigned FunctionNum,
637 MachineModuleInfo &MMI);
641
642 /// Reset the instance as if it was just created.
643 void reset() {
644 clear();
645 init();
646 }
647
648 /// Reset the currently registered delegate - otherwise assert.
649 void resetDelegate(Delegate *delegate) {
650 assert(TheDelegate == delegate &&
651 "Only the current delegate can perform reset!");
652 TheDelegate = nullptr;
653 }
654
655 /// Set the delegate. resetDelegate must be called before attempting
656 /// to set.
657 void setDelegate(Delegate *delegate) {
658 assert(delegate && !TheDelegate &&
659 "Attempted to set delegate to null, or to change it without "
660 "first resetting it!");
661
662 TheDelegate = delegate;
663 }
664
665 void setObserver(GISelChangeObserver *O) { Observer = O; }
666
667 GISelChangeObserver *getObserver() const { return Observer; }
668
669 MachineModuleInfo &getMMI() const { return MMI; }
670 MCContext &getContext() const { return Ctx; }
671
672 /// Returns the Section this function belongs to.
673 MCSection *getSection() const { return Section; }
674
675 /// Indicates the Section this function belongs to.
676 void setSection(MCSection *S) { Section = S; }
677
678 PseudoSourceValueManager &getPSVManager() const { return *PSVManager; }
679
680 /// Return the DataLayout attached to the Module associated to this MF.
681 const DataLayout &getDataLayout() const;
682
683 /// Return the LLVM function that this machine code represents
684 Function &getFunction() { return F; }
685
686 /// Return the LLVM function that this machine code represents
687 const Function &getFunction() const { return F; }
688
689 /// getName - Return the name of the corresponding LLVM function.
690 StringRef getName() const;
691
692 /// getFunctionNumber - Return a unique ID for the current function.
693 unsigned getFunctionNumber() const { return FunctionNumber; }
694
695 /// Returns true if this function has basic block sections enabled.
696 bool hasBBSections() const {
697 return (BBSectionsType == BasicBlockSection::All ||
698 BBSectionsType == BasicBlockSection::List ||
699 BBSectionsType == BasicBlockSection::Preset);
700 }
701
702 /// Returns true if basic block labels are to be generated for this function.
703 bool hasBBLabels() const {
704 return BBSectionsType == BasicBlockSection::Labels;
705 }
706
707 void setBBSectionsType(BasicBlockSection V) { BBSectionsType = V; }
708
709 /// Assign IsBeginSection IsEndSection fields for basic blocks in this
710 /// function.
711 void assignBeginEndSections();
712
713 /// getTarget - Return the target machine this machine code is compiled with
714 const LLVMTargetMachine &getTarget() const { return Target; }
715
716 /// getSubtarget - Return the subtarget for which this machine code is being
717 /// compiled.
718 const TargetSubtargetInfo &getSubtarget() const { return *STI; }
719
720 /// getSubtarget - This method returns a pointer to the specified type of
721 /// TargetSubtargetInfo. In debug builds, it verifies that the object being
722 /// returned is of the correct type.
723 template<typename STC> const STC &getSubtarget() const {
724 return *static_cast<const STC *>(STI);
725 }
726
727 /// getRegInfo - Return information about the registers currently in use.
729 const MachineRegisterInfo &getRegInfo() const { return *RegInfo; }
730
731 /// getFrameInfo - Return the frame info object for the current function.
732 /// This object contains information about objects allocated on the stack
733 /// frame of the current function in an abstract way.
734 MachineFrameInfo &getFrameInfo() { return *FrameInfo; }
735 const MachineFrameInfo &getFrameInfo() const { return *FrameInfo; }
736
737 /// getJumpTableInfo - Return the jump table info object for the current
738 /// function. This object contains information about jump tables in the
739 /// current function. If the current function has no jump tables, this will
740 /// return null.
741 const MachineJumpTableInfo *getJumpTableInfo() const { return JumpTableInfo; }
742 MachineJumpTableInfo *getJumpTableInfo() { return JumpTableInfo; }
743
744 /// getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it
745 /// does already exist, allocate one.
746 MachineJumpTableInfo *getOrCreateJumpTableInfo(unsigned JTEntryKind);
747
748 /// getConstantPool - Return the constant pool object for the current
749 /// function.
752
753 /// getWasmEHFuncInfo - Return information about how the current function uses
754 /// Wasm exception handling. Returns null for functions that don't use wasm
755 /// exception handling.
756 const WasmEHFuncInfo *getWasmEHFuncInfo() const { return WasmEHInfo; }
757 WasmEHFuncInfo *getWasmEHFuncInfo() { return WasmEHInfo; }
758
759 /// getWinEHFuncInfo - Return information about how the current function uses
760 /// Windows exception handling. Returns null for functions that don't use
761 /// funclets for exception handling.
762 const WinEHFuncInfo *getWinEHFuncInfo() const { return WinEHInfo; }
763 WinEHFuncInfo *getWinEHFuncInfo() { return WinEHInfo; }
764
765 /// getAlignment - Return the alignment of the function.
766 Align getAlignment() const { return Alignment; }
767
768 /// setAlignment - Set the alignment of the function.
769 void setAlignment(Align A) { Alignment = A; }
770
771 /// ensureAlignment - Make sure the function is at least A bytes aligned.
773 if (Alignment < A)
774 Alignment = A;
775 }
776
777 /// exposesReturnsTwice - Returns true if the function calls setjmp or
778 /// any other similar functions with attribute "returns twice" without
779 /// having the attribute itself.
780 bool exposesReturnsTwice() const {
781 return ExposesReturnsTwice;
782 }
783
784 /// setCallsSetJmp - Set a flag that indicates if there's a call to
785 /// a "returns twice" function.
787 ExposesReturnsTwice = B;
788 }
789
790 /// Returns true if the function contains any inline assembly.
791 bool hasInlineAsm() const {
792 return HasInlineAsm;
793 }
794
795 /// Set a flag that indicates that the function contains inline assembly.
796 void setHasInlineAsm(bool B) {
797 HasInlineAsm = B;
798 }
799
800 bool hasWinCFI() const {
801 return HasWinCFI;
802 }
803 void setHasWinCFI(bool v) { HasWinCFI = v; }
804
805 /// True if this function needs frame moves for debug or exceptions.
806 bool needsFrameMoves() const;
807
808 /// Get the function properties
809 const MachineFunctionProperties &getProperties() const { return Properties; }
810 MachineFunctionProperties &getProperties() { return Properties; }
811
812 /// getInfo - Keep track of various per-function pieces of information for
813 /// backends that would like to do so.
814 ///
815 template<typename Ty>
816 Ty *getInfo() {
817 return static_cast<Ty*>(MFInfo);
818 }
819
820 template<typename Ty>
821 const Ty *getInfo() const {
822 return static_cast<const Ty *>(MFInfo);
823 }
824
825 template <typename Ty> Ty *cloneInfo(const Ty &Old) {
826 assert(!MFInfo);
827 MFInfo = Ty::template create<Ty>(Allocator, Old);
828 return static_cast<Ty *>(MFInfo);
829 }
830
831 /// Initialize the target specific MachineFunctionInfo
832 void initTargetMachineFunctionInfo(const TargetSubtargetInfo &STI);
833
835 const MachineFunction &OrigMF,
837 assert(!MFInfo && "new function already has MachineFunctionInfo");
838 if (!OrigMF.MFInfo)
839 return nullptr;
840 return OrigMF.MFInfo->clone(Allocator, *this, Src2DstMBB);
841 }
842
843 /// Returns the denormal handling type for the default rounding mode of the
844 /// function.
845 DenormalMode getDenormalMode(const fltSemantics &FPType) const;
846
847 /// getBlockNumbered - MachineBasicBlocks are automatically numbered when they
848 /// are inserted into the machine function. The block number for a machine
849 /// basic block can be found by using the MBB::getNumber method, this method
850 /// provides the inverse mapping.
852 assert(N < MBBNumbering.size() && "Illegal block number");
853 assert(MBBNumbering[N] && "Block was removed from the machine function!");
854 return MBBNumbering[N];
855 }
856
857 /// Should we be emitting segmented stack stuff for the function
858 bool shouldSplitStack() const;
859
860 /// getNumBlockIDs - Return the number of MBB ID's allocated.
861 unsigned getNumBlockIDs() const { return (unsigned)MBBNumbering.size(); }
862
863 /// RenumberBlocks - This discards all of the MachineBasicBlock numbers and
864 /// recomputes them. This guarantees that the MBB numbers are sequential,
865 /// dense, and match the ordering of the blocks within the function. If a
866 /// specific MachineBasicBlock is specified, only that block and those after
867 /// it are renumbered.
868 void RenumberBlocks(MachineBasicBlock *MBBFrom = nullptr);
869
870 /// print - Print out the MachineFunction in a format suitable for debugging
871 /// to the specified stream.
872 void print(raw_ostream &OS, const SlotIndexes* = nullptr) const;
873
874 /// viewCFG - This function is meant for use from the debugger. You can just
875 /// say 'call F->viewCFG()' and a ghostview window should pop up from the
876 /// program, displaying the CFG of the current function with the code for each
877 /// basic block inside. This depends on there being a 'dot' and 'gv' program
878 /// in your path.
879 void viewCFG() const;
880
881 /// viewCFGOnly - This function is meant for use from the debugger. It works
882 /// just like viewCFG, but it does not include the contents of basic blocks
883 /// into the nodes, just the label. If you are only interested in the CFG
884 /// this can make the graph smaller.
885 ///
886 void viewCFGOnly() const;
887
888 /// dump - Print the current MachineFunction to cerr, useful for debugger use.
889 void dump() const;
890
891 /// Run the current MachineFunction through the machine code verifier, useful
892 /// for debugger use.
893 /// \returns true if no problems were found.
894 bool verify(Pass *p = nullptr, const char *Banner = nullptr,
895 bool AbortOnError = true) const;
896
897 /// Run the current MachineFunction through the machine code verifier, useful
898 /// for debugger use.
899 /// \returns true if no problems were found.
900 bool verify(LiveIntervals *LiveInts, SlotIndexes *Indexes,
901 const char *Banner = nullptr, bool AbortOnError = true) const;
902
903 // Provide accessors for the MachineBasicBlock list...
908
909 /// Support for MachineBasicBlock::getNextNode().
912 return &MachineFunction::BasicBlocks;
913 }
914
915 /// addLiveIn - Add the specified physical register as a live-in value and
916 /// create a corresponding virtual register for it.
918
919 //===--------------------------------------------------------------------===//
920 // BasicBlock accessor functions.
921 //
922 iterator begin() { return BasicBlocks.begin(); }
923 const_iterator begin() const { return BasicBlocks.begin(); }
924 iterator end () { return BasicBlocks.end(); }
925 const_iterator end () const { return BasicBlocks.end(); }
926
927 reverse_iterator rbegin() { return BasicBlocks.rbegin(); }
928 const_reverse_iterator rbegin() const { return BasicBlocks.rbegin(); }
929 reverse_iterator rend () { return BasicBlocks.rend(); }
930 const_reverse_iterator rend () const { return BasicBlocks.rend(); }
931
932 unsigned size() const { return (unsigned)BasicBlocks.size();}
933 bool empty() const { return BasicBlocks.empty(); }
934 const MachineBasicBlock &front() const { return BasicBlocks.front(); }
935 MachineBasicBlock &front() { return BasicBlocks.front(); }
936 const MachineBasicBlock & back() const { return BasicBlocks.back(); }
937 MachineBasicBlock & back() { return BasicBlocks.back(); }
938
939 void push_back (MachineBasicBlock *MBB) { BasicBlocks.push_back (MBB); }
942 BasicBlocks.insert(MBBI, MBB);
943 }
944 void splice(iterator InsertPt, iterator MBBI) {
945 BasicBlocks.splice(InsertPt, BasicBlocks, MBBI);
946 }
948 BasicBlocks.splice(InsertPt, BasicBlocks, MBB);
949 }
950 void splice(iterator InsertPt, iterator MBBI, iterator MBBE) {
951 BasicBlocks.splice(InsertPt, BasicBlocks, MBBI, MBBE);
952 }
953
954 void remove(iterator MBBI) { BasicBlocks.remove(MBBI); }
955 void remove(MachineBasicBlock *MBBI) { BasicBlocks.remove(MBBI); }
956 void erase(iterator MBBI) { BasicBlocks.erase(MBBI); }
957 void erase(MachineBasicBlock *MBBI) { BasicBlocks.erase(MBBI); }
958
959 template <typename Comp>
960 void sort(Comp comp) {
961 BasicBlocks.sort(comp);
962 }
963
964 /// Return the number of \p MachineInstrs in this \p MachineFunction.
965 unsigned getInstructionCount() const {
966 unsigned InstrCount = 0;
967 for (const MachineBasicBlock &MBB : BasicBlocks)
968 InstrCount += MBB.size();
969 return InstrCount;
970 }
971
972 //===--------------------------------------------------------------------===//
973 // Internal functions used to automatically number MachineBasicBlocks
974
975 /// Adds the MBB to the internal numbering. Returns the unique number
976 /// assigned to the MBB.
978 MBBNumbering.push_back(MBB);
979 return (unsigned)MBBNumbering.size()-1;
980 }
981
982 /// removeFromMBBNumbering - Remove the specific machine basic block from our
983 /// tracker, this is only really to be used by the MachineBasicBlock
984 /// implementation.
985 void removeFromMBBNumbering(unsigned N) {
986 assert(N < MBBNumbering.size() && "Illegal basic block #");
987 MBBNumbering[N] = nullptr;
988 }
989
990 /// CreateMachineInstr - Allocate a new MachineInstr. Use this instead
991 /// of `new MachineInstr'.
992 MachineInstr *CreateMachineInstr(const MCInstrDesc &MCID, DebugLoc DL,
993 bool NoImplicit = false);
994
995 /// Create a new MachineInstr which is a copy of \p Orig, identical in all
996 /// ways except the instruction has no parent, prev, or next. Bundling flags
997 /// are reset.
998 ///
999 /// Note: Clones a single instruction, not whole instruction bundles.
1000 /// Does not perform target specific adjustments; consider using
1001 /// TargetInstrInfo::duplicate() instead.
1002 MachineInstr *CloneMachineInstr(const MachineInstr *Orig);
1003
1004 /// Clones instruction or the whole instruction bundle \p Orig and insert
1005 /// into \p MBB before \p InsertBefore.
1006 ///
1007 /// Note: Does not perform target specific adjustments; consider using
1008 /// TargetInstrInfo::duplicate() intead.
1009 MachineInstr &
1010 cloneMachineInstrBundle(MachineBasicBlock &MBB,
1011 MachineBasicBlock::iterator InsertBefore,
1012 const MachineInstr &Orig);
1013
1014 /// DeleteMachineInstr - Delete the given MachineInstr.
1015 void deleteMachineInstr(MachineInstr *MI);
1016
1017 /// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this
1018 /// instead of `new MachineBasicBlock'. Sets `MachineBasicBlock::BBID` if
1019 /// basic-block-sections is enabled for the function.
1021 CreateMachineBasicBlock(const BasicBlock *BB = nullptr,
1022 std::optional<UniqueBBID> BBID = std::nullopt);
1023
1024 /// DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
1025 void deleteMachineBasicBlock(MachineBasicBlock *MBB);
1026
1027 /// getMachineMemOperand - Allocate a new MachineMemOperand.
1028 /// MachineMemOperands are owned by the MachineFunction and need not be
1029 /// explicitly deallocated.
1032 Align base_alignment, const AAMDNodes &AAInfo = AAMDNodes(),
1033 const MDNode *Ranges = nullptr, SyncScope::ID SSID = SyncScope::System,
1034 AtomicOrdering Ordering = AtomicOrdering::NotAtomic,
1035 AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);
1038 Align BaseAlignment, const AAMDNodes &AAInfo = AAMDNodes(),
1039 const MDNode *Ranges = nullptr, SyncScope::ID SSID = SyncScope::System,
1040 AtomicOrdering Ordering = AtomicOrdering::NotAtomic,
1041 AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);
1044 Align BaseAlignment, const AAMDNodes &AAInfo = AAMDNodes(),
1045 const MDNode *Ranges = nullptr, SyncScope::ID SSID = SyncScope::System,
1046 AtomicOrdering Ordering = AtomicOrdering::NotAtomic,
1047 AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic) {
1048 return getMachineMemOperand(PtrInfo, F, LocationSize::precise(Size),
1049 BaseAlignment, AAInfo, Ranges, SSID, Ordering,
1050 FailureOrdering);
1051 }
1052
1053 /// getMachineMemOperand - Allocate a new MachineMemOperand by copying
1054 /// an existing one, adjusting by an offset and using the given size.
1055 /// MachineMemOperands are owned by the MachineFunction and need not be
1056 /// explicitly deallocated.
1058 int64_t Offset, LLT Ty);
1060 int64_t Offset, LocationSize Size) {
1061 return getMachineMemOperand(
1062 MMO, Offset,
1063 !Size.hasValue() ? LLT()
1064 : Size.isScalable()
1065 ? LLT::scalable_vector(1, 8 * Size.getValue().getKnownMinValue())
1066 : LLT::scalar(8 * Size.getValue().getKnownMinValue()));
1067 }
1069 int64_t Offset, uint64_t Size) {
1070 return getMachineMemOperand(MMO, Offset, LocationSize::precise(Size));
1071 }
1072
1073 /// getMachineMemOperand - Allocate a new MachineMemOperand by copying
1074 /// an existing one, replacing only the MachinePointerInfo and size.
1075 /// MachineMemOperands are owned by the MachineFunction and need not be
1076 /// explicitly deallocated.
1078 const MachinePointerInfo &PtrInfo,
1081 const MachinePointerInfo &PtrInfo,
1082 LLT Ty);
1084 const MachinePointerInfo &PtrInfo,
1085 uint64_t Size) {
1086 return getMachineMemOperand(MMO, PtrInfo, LocationSize::precise(Size));
1087 }
1088
1089 /// Allocate a new MachineMemOperand by copying an existing one,
1090 /// replacing only AliasAnalysis information. MachineMemOperands are owned
1091 /// by the MachineFunction and need not be explicitly deallocated.
1093 const AAMDNodes &AAInfo);
1094
1095 /// Allocate a new MachineMemOperand by copying an existing one,
1096 /// replacing the flags. MachineMemOperands are owned
1097 /// by the MachineFunction and need not be explicitly deallocated.
1100
1102
1103 /// Allocate an array of MachineOperands. This is only intended for use by
1104 /// internal MachineInstr functions.
1106 return OperandRecycler.allocate(Cap, Allocator);
1107 }
1108
1109 /// Dellocate an array of MachineOperands and recycle the memory. This is
1110 /// only intended for use by internal MachineInstr functions.
1111 /// Cap must be the same capacity that was used to allocate the array.
1113 OperandRecycler.deallocate(Cap, Array);
1114 }
1115
1116 /// Allocate and initialize a register mask with @p NumRegister bits.
1117 uint32_t *allocateRegMask();
1118
1119 ArrayRef<int> allocateShuffleMask(ArrayRef<int> Mask);
1120
1121 /// Allocate and construct an extra info structure for a `MachineInstr`.
1122 ///
1123 /// This is allocated on the function's allocator and so lives the life of
1124 /// the function.
1125 MachineInstr::ExtraInfo *createMIExtraInfo(
1126 ArrayRef<MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol = nullptr,
1127 MCSymbol *PostInstrSymbol = nullptr, MDNode *HeapAllocMarker = nullptr,
1128 MDNode *PCSections = nullptr, uint32_t CFIType = 0);
1129
1130 /// Allocate a string and populate it with the given external symbol name.
1131 const char *createExternalSymbolName(StringRef Name);
1132
1133 //===--------------------------------------------------------------------===//
1134 // Label Manipulation.
1135
1136 /// getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
1137 /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
1138 /// normal 'L' label is returned.
1139 MCSymbol *getJTISymbol(unsigned JTI, MCContext &Ctx,
1140 bool isLinkerPrivate = false) const;
1141
1142 /// getPICBaseSymbol - Return a function-local symbol to represent the PIC
1143 /// base.
1144 MCSymbol *getPICBaseSymbol() const;
1145
1146 /// Returns a reference to a list of cfi instructions in the function's
1147 /// prologue. Used to construct frame maps for debug and exception handling
1148 /// comsumers.
1149 const std::vector<MCCFIInstruction> &getFrameInstructions() const {
1150 return FrameInstructions;
1151 }
1152
1153 [[nodiscard]] unsigned addFrameInst(const MCCFIInstruction &Inst);
1154
1155 /// Returns a reference to a list of symbols immediately following calls to
1156 /// _setjmp in the function. Used to construct the longjmp target table used
1157 /// by Windows Control Flow Guard.
1158 const std::vector<MCSymbol *> &getLongjmpTargets() const {
1159 return LongjmpTargets;
1160 }
1161
1162 /// Add the specified symbol to the list of valid longjmp targets for Windows
1163 /// Control Flow Guard.
1164 void addLongjmpTarget(MCSymbol *Target) { LongjmpTargets.push_back(Target); }
1165
1166 /// Returns a reference to a list of symbols that we have catchrets.
1167 /// Used to construct the catchret target table used by Windows EHCont Guard.
1168 const std::vector<MCSymbol *> &getCatchretTargets() const {
1169 return CatchretTargets;
1170 }
1171
1172 /// Add the specified symbol to the list of valid catchret targets for Windows
1173 /// EHCont Guard.
1175 CatchretTargets.push_back(Target);
1176 }
1177
1178 /// \name Exception Handling
1179 /// \{
1180
1181 bool callsEHReturn() const { return CallsEHReturn; }
1182 void setCallsEHReturn(bool b) { CallsEHReturn = b; }
1183
1184 bool callsUnwindInit() const { return CallsUnwindInit; }
1185 void setCallsUnwindInit(bool b) { CallsUnwindInit = b; }
1186
1187 bool hasEHCatchret() const { return HasEHCatchret; }
1188 void setHasEHCatchret(bool V) { HasEHCatchret = V; }
1189
1190 bool hasEHScopes() const { return HasEHScopes; }
1191 void setHasEHScopes(bool V) { HasEHScopes = V; }
1192
1193 bool hasEHFunclets() const { return HasEHFunclets; }
1194 void setHasEHFunclets(bool V) { HasEHFunclets = V; }
1195
1196 bool isOutlined() const { return IsOutlined; }
1197 void setIsOutlined(bool V) { IsOutlined = V; }
1198
1199 /// Find or create an LandingPadInfo for the specified MachineBasicBlock.
1200 LandingPadInfo &getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad);
1201
1202 /// Return a reference to the landing pad info for the current function.
1203 const std::vector<LandingPadInfo> &getLandingPads() const {
1204 return LandingPads;
1205 }
1206
1207 /// Provide the begin and end labels of an invoke style call and associate it
1208 /// with a try landing pad block.
1209 void addInvoke(MachineBasicBlock *LandingPad,
1210 MCSymbol *BeginLabel, MCSymbol *EndLabel);
1211
1212 /// Add a new panding pad, and extract the exception handling information from
1213 /// the landingpad instruction. Returns the label ID for the landing pad
1214 /// entry.
1215 MCSymbol *addLandingPad(MachineBasicBlock *LandingPad);
1216
1217 /// Return the type id for the specified typeinfo. This is function wide.
1218 unsigned getTypeIDFor(const GlobalValue *TI);
1219
1220 /// Return the id of the filter encoded by TyIds. This is function wide.
1221 int getFilterIDFor(ArrayRef<unsigned> TyIds);
1222
1223 /// Map the landing pad's EH symbol to the call site indexes.
1224 void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef<unsigned> Sites);
1225
1226 /// Return if there is any wasm exception handling.
1228 return !WasmLPadToIndexMap.empty();
1229 }
1230
1231 /// Map the landing pad to its index. Used for Wasm exception handling.
1232 void setWasmLandingPadIndex(const MachineBasicBlock *LPad, unsigned Index) {
1233 WasmLPadToIndexMap[LPad] = Index;
1234 }
1235
1236 /// Returns true if the landing pad has an associate index in wasm EH.
1238 return WasmLPadToIndexMap.count(LPad);
1239 }
1240
1241 /// Get the index in wasm EH for a given landing pad.
1242 unsigned getWasmLandingPadIndex(const MachineBasicBlock *LPad) const {
1243 assert(hasWasmLandingPadIndex(LPad));
1244 return WasmLPadToIndexMap.lookup(LPad);
1245 }
1246
1248 return !LPadToCallSiteMap.empty();
1249 }
1250
1251 /// Get the call site indexes for a landing pad EH symbol.
1253 assert(hasCallSiteLandingPad(Sym) &&
1254 "missing call site number for landing pad!");
1255 return LPadToCallSiteMap[Sym];
1256 }
1257
1258 /// Return true if the landing pad Eh symbol has an associated call site.
1260 return !LPadToCallSiteMap[Sym].empty();
1261 }
1262
1263 bool hasAnyCallSiteLabel() const {
1264 return !CallSiteMap.empty();
1265 }
1266
1267 /// Map the begin label for a call site.
1268 void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site) {
1269 CallSiteMap[BeginLabel] = Site;
1270 }
1271
1272 /// Get the call site number for a begin label.
1273 unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) const {
1274 assert(hasCallSiteBeginLabel(BeginLabel) &&
1275 "Missing call site number for EH_LABEL!");
1276 return CallSiteMap.lookup(BeginLabel);
1277 }
1278
1279 /// Return true if the begin label has a call site number associated with it.
1280 bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) const {
1281 return CallSiteMap.count(BeginLabel);
1282 }
1283
1284 /// Record annotations associated with a particular label.
1286 CodeViewAnnotations.push_back({Label, MD});
1287 }
1288
1290 return CodeViewAnnotations;
1291 }
1292
1293 /// Return a reference to the C++ typeinfo for the current function.
1294 const std::vector<const GlobalValue *> &getTypeInfos() const {
1295 return TypeInfos;
1296 }
1297
1298 /// Return a reference to the typeids encoding filters used in the current
1299 /// function.
1300 const std::vector<unsigned> &getFilterIds() const {
1301 return FilterIds;
1302 }
1303
1304 /// \}
1305
1306 /// Collect information used to emit debugging information of a variable in a
1307 /// stack slot.
1309 int Slot, const DILocation *Loc) {
1310 VariableDbgInfos.emplace_back(Var, Expr, Slot, Loc);
1311 }
1312
1313 /// Collect information used to emit debugging information of a variable in
1314 /// the entry value of a register.
1316 MCRegister Reg, const DILocation *Loc) {
1317 VariableDbgInfos.emplace_back(Var, Expr, Reg, Loc);
1318 }
1319
1320 VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfos; }
1322 return VariableDbgInfos;
1323 }
1324
1325 /// Returns the collection of variables for which we have debug info and that
1326 /// have been assigned a stack slot.
1328 return make_filter_range(getVariableDbgInfo(), [](auto &VarInfo) {
1329 return VarInfo.inStackSlot();
1330 });
1331 }
1332
1333 /// Returns the collection of variables for which we have debug info and that
1334 /// have been assigned a stack slot.
1336 return make_filter_range(getVariableDbgInfo(), [](const auto &VarInfo) {
1337 return VarInfo.inStackSlot();
1338 });
1339 }
1340
1341 /// Returns the collection of variables for which we have debug info and that
1342 /// have been assigned an entry value register.
1344 return make_filter_range(getVariableDbgInfo(), [](const auto &VarInfo) {
1345 return VarInfo.inEntryValueRegister();
1346 });
1347 }
1348
1349 /// Start tracking the arguments passed to the call \p CallI.
1352 bool Inserted =
1353 CallSitesInfo.try_emplace(CallI, std::move(CallInfo)).second;
1354 (void)Inserted;
1355 assert(Inserted && "Call site info not unique");
1356 }
1357
1359 return CallSitesInfo;
1360 }
1361
1362 /// Following functions update call site info. They should be called before
1363 /// removing, replacing or copying call instruction.
1364
1365 /// Erase the call site info for \p MI. It is used to remove a call
1366 /// instruction from the instruction stream.
1367 void eraseCallSiteInfo(const MachineInstr *MI);
1368 /// Copy the call site info from \p Old to \ New. Its usage is when we are
1369 /// making a copy of the instruction that will be inserted at different point
1370 /// of the instruction stream.
1371 void copyCallSiteInfo(const MachineInstr *Old,
1372 const MachineInstr *New);
1373
1374 /// Move the call site info from \p Old to \New call site info. This function
1375 /// is used when we are replacing one call instruction with another one to
1376 /// the same callee.
1377 void moveCallSiteInfo(const MachineInstr *Old,
1378 const MachineInstr *New);
1379
1381 return ++DebugInstrNumberingCount;
1382 }
1383};
1384
1385//===--------------------------------------------------------------------===//
1386// GraphTraits specializations for function basic block graphs (CFGs)
1387//===--------------------------------------------------------------------===//
1388
1389// Provide specializations of GraphTraits to be able to treat a
1390// machine function as a graph of machine basic blocks... these are
1391// the same as the machine basic block iterators, except that the root
1392// node is implicitly the first node of the function.
1393//
1394template <> struct GraphTraits<MachineFunction*> :
1396 static NodeRef getEntryNode(MachineFunction *F) { return &F->front(); }
1397
1398 // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
1400
1402 return nodes_iterator(F->begin());
1403 }
1404
1406 return nodes_iterator(F->end());
1407 }
1408
1409 static unsigned size (MachineFunction *F) { return F->size(); }
1410};
1411template <> struct GraphTraits<const MachineFunction*> :
1413 static NodeRef getEntryNode(const MachineFunction *F) { return &F->front(); }
1414
1415 // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
1417
1419 return nodes_iterator(F->begin());
1420 }
1421
1423 return nodes_iterator(F->end());
1424 }
1425
1426 static unsigned size (const MachineFunction *F) {
1427 return F->size();
1428 }
1429};
1430
1431// Provide specializations of GraphTraits to be able to treat a function as a
1432// graph of basic blocks... and to walk it in inverse order. Inverse order for
1433// a function is considered to be when traversing the predecessor edges of a BB
1434// instead of the successor edges.
1435//
1436template <> struct GraphTraits<Inverse<MachineFunction*>> :
1439 return &G.Graph->front();
1440 }
1441};
1445 return &G.Graph->front();
1446 }
1447};
1448
1449void verifyMachineFunction(const std::string &Banner,
1450 const MachineFunction &MF);
1451
1452} // end namespace llvm
1453
1454#endif // LLVM_CODEGEN_MACHINEFUNCTION_H
unsigned SubReg
aarch64 AArch64 CCMP Pass
aarch64 promote const
MachineBasicBlock & MBB
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.
This file implements the BitVector class.
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)
Definition: CFGPrinter.cpp:82
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:135
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:148
static unsigned InstrCount
This file defines the DenseMap class.
std::string Name
uint32_t Index
uint64_t Size
std::optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1291
uint64_t Offset
Definition: ELF_riscv.cpp:478
Symbol * Sym
Definition: ELF_riscv.cpp:479
This file defines the little GraphTraits<X> template class that should be specialized by classes that...
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
#define G(x, y, z)
Definition: MD5.cpp:56
unsigned Reg
static unsigned addLiveIn(MachineFunction &MF, unsigned PReg, const TargetRegisterClass *RC)
#define P(N)
ppc ctr loops verify
static StringRef getName(Value *V)
Basic Register Allocator
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
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.
Definition: ArrayRecycler.h:71
Recycle small arrays allocated from a BumpPtrAllocator.
Definition: ArrayRecycler.h:28
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),...
Definition: ArrayRef.h:41
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
BitVector & reset()
Definition: BitVector.h:392
BitVector & set()
Definition: BitVector.h:351
The address of a basic block.
Definition: Constants.h:889
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
DWARF expression.
Debug location.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
A debug info location.
Definition: DebugLoc.h:33
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...
Definition: DenseMap.h:202
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&... Args)
Definition: DenseMap.h:235
bool empty() const
Definition: DenseMap.h:98
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:151
Abstract class that contains various methods for clients to notify about changes.
This class describes a target machine that is implemented with the LLVM target-independent code gener...
Context object for machine code objects.
Definition: MCContext.h:81
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:198
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:33
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
Metadata node.
Definition: Metadata.h:1067
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.
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.
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.
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
PseudoSourceValueManager & getPSVManager() const
void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site)
Map the begin label for a call site.
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.
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)
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()
bool hasBBSections() const
Returns true if this function has basic block sections enabled.
MCContext & getContext() 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.
unsigned size() const
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...
reverse_iterator rend()
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)
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)
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
void erase(MachineBasicBlock *MBBI)
unsigned getNumBlockIDs() const
getNumBlockIDs - Return the number of MBB ID's allocated.
const_iterator begin() const
void remove(MachineBasicBlock *MBBI)
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
MachineModuleInfo & getMMI() 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().
void sort(Comp comp)
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
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)
bool hasBBLabels() const
Returns true if basic block labels are to be generated for this function.
const Ty * getInfo() 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)
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()
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.
Definition: MachineInstr.h:69
bool isCandidateForCallSiteEntry(QueryType Type=IgnoreBundle) const
Return true if this is a call instruction that may have an associated call site entry in the debug in...
A description of a memory reference used in the backend.
Flags
Flags values. These may be or'd together.
This class contains meta information specific to a module.
MachineOperand class - Representation of each machine instruction operand.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:94
Manages creation of pseudo source values.
Recycler - This class manages a linked-list of deallocated nodes and facilitates reusing deallocated ...
Definition: Recycler.h:34
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
SlotIndexes pass.
Definition: SlotIndexes.h:300
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:950
std::reverse_iterator< const_iterator > const_reverse_iterator
Definition: SmallVector.h:267
std::reverse_iterator< iterator > reverse_iterator
Definition: SmallVector.h:268
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
TargetSubtargetInfo - Generic base class for all target subtargets.
Target - Wrapper for Target specific information.
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:266
void push_back(pointer val)
Definition: ilist.h:250
iterator erase(iterator where)
Definition: ilist.h:204
pointer remove(iterator &IT)
Definition: ilist.h:188
void push_front(pointer val)
Definition: ilist.h:249
iterator insert(iterator where, pointer New)
Definition: ilist.h:165
An intrusive list with ownership and callbacks specified/controlled by ilist_traits,...
Definition: ilist.h:328
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This file defines classes to implement an intrusive doubly linked list class (i.e.
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
@ BlockAddress
Definition: ISDOpcodes.h:84
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
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...
Definition: STLExtras.h:572
AtomicOrdering
Atomic ordering for LLVM's memory model.
BasicBlockSection
Definition: TargetOptions.h:61
#define N
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:760
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Represent subnormal handling kind for floating point instruction inputs and outputs.
static NodeRef getEntryNode(Inverse< MachineFunction * > G)
static NodeRef getEntryNode(Inverse< const MachineFunction * > G)
static unsigned size(MachineFunction *F)
static nodes_iterator nodes_begin(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 NodeRef getEntryNode(const MachineFunction *F)
This structure is used to retain landing pad info for the current function.
SmallVector< MCSymbol *, 1 > EndLabels
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 * 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.
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.
Definition: ilist.h:41
static void deleteNode(NodeTy *V)
Definition: ilist.h:42
void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator)
Callbacks do nothing by default in iplist and ilist.
Definition: ilist.h:65
void removeNodeFromList(NodeTy *)
Definition: ilist.h:67
void addNodeToList(NodeTy *)
Definition: ilist.h:66
Template traits for intrusive list.
Definition: ilist.h:90