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"
23#include "llvm/ADT/GraphTraits.h"
24#include "llvm/ADT/SmallVector.h"
25#include "llvm/ADT/ilist.h"
26#include "llvm/ADT/iterator.h"
27#include "llvm/CodeGen/MachineBasicBlock.h"
28#include "llvm/CodeGen/MachineInstr.h"
29#include "llvm/CodeGen/MachineMemOperand.h"
30#include "llvm/IR/EHPersonalities.h"
31#include "llvm/Support/Allocator.h"
32#include "llvm/Support/ArrayRecycler.h"
33#include "llvm/Support/AtomicOrdering.h"
34#include "llvm/Support/Compiler.h"
35#include "llvm/Support/Recycler.h"
36#include "llvm/Target/TargetOptions.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
78template <> struct ilist_alloc_traits<MachineBasicBlock> {
79 void deleteNode(MachineBasicBlock *MBB);
80};
81
82template <> struct ilist_callback_traits<MachineBasicBlock> {
83 void addNodeToList(MachineBasicBlock* N);
84 void removeNodeFromList(MachineBasicBlock* N);
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.
96struct MachineFunctionInfo {
97 virtual ~MachineFunctionInfo();
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 *
119 clone(BumpPtrAllocator &Allocator, MachineFunction &DestMF,
120 const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB)
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.
129class MachineFunctionProperties {
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,
182 TracksLiveness,
183 NoVRegs,
184 FailedISel,
185 Legalized,
186 RegBankSelected,
187 Selected,
188 TiedOpsRewritten,
189 FailsVerification,
190 TracksDebugUserValues,
191 LastProperty = TracksDebugUserValues,
192 };
193
194 bool hasProperty(Property P) const {
195 return Properties[static_cast<unsigned>(P)];
196 }
197
198 MachineFunctionProperties &set(Property P) {
199 Properties.set(static_cast<unsigned>(P));
200 return *this;
201 }
202
203 MachineFunctionProperties &reset(Property P) {
204 Properties.reset(Idx: static_cast<unsigned>(P));
205 return *this;
206 }
207
208 /// Reset all the properties.
209 MachineFunctionProperties &reset() {
210 Properties.reset();
211 return *this;
212 }
213
214 MachineFunctionProperties &set(const MachineFunctionProperties &MFP) {
215 Properties |= MFP.Properties;
216 return *this;
217 }
218
219 MachineFunctionProperties &reset(const MachineFunctionProperties &MFP) {
220 Properties.reset(RHS: 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.
226 bool verifyRequiredProperties(const MachineFunctionProperties &V) const {
227 return !V.Properties.test(RHS: 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
238struct SEHHandler {
239 /// Filter or finally function. Null indicates a catch-all.
240 const Function *FilterOrFinally;
241
242 /// Address of block to recover at. Null for a finally handler.
243 const BlockAddress *RecoverBA;
244};
245
246/// This structure is used to retain landing pad info for the current function.
247struct LandingPadInfo {
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
255 explicit LandingPadInfo(MachineBasicBlock *MBB)
256 : LandingPadBlock(MBB) {}
257};
258
259class LLVM_EXTERNAL_VISIBILITY MachineFunction {
260 Function &F;
261 const LLVMTargetMachine &Target;
262 const TargetSubtargetInfo *STI;
263 MCContext &Ctx;
264 MachineModuleInfo &MMI;
265
266 // RegInfo - Information about each register in use in the function.
267 MachineRegisterInfo *RegInfo;
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
277 MachineConstantPool *ConstantPool;
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.
300 BumpPtrAllocator Allocator;
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
312 using BasicBlockListType = ilist<MachineBasicBlock>;
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.
362 DenseMap<MCSymbol*, SmallVector<unsigned, 4>> LPadToCallSiteMap;
363
364 /// Map a landing pad to its index.
365 DenseMap<const MachineBasicBlock *, unsigned> WasmLPadToIndexMap;
366
367 /// Map of invoke call site index values to associated begin EH_LABEL.
368 DenseMap<MCSymbol*, unsigned> CallSiteMap;
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.
415 class VariableDbgInfo {
416 std::variant<int, MCRegister> Address;
417
418 public:
419 const DILocalVariable *Var;
420 const DIExpression *Expr;
421 const DILocation *Loc;
422
423 VariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
424 int Slot, const DILocation *Loc)
425 : Address(Slot), Var(Var), Expr(Expr), Loc(Loc) {}
426
427 VariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
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>(v: 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>(v: Address);
437 }
438
439 /// Returns the stack slot of this variable, assuming `inStackSlot()` is
440 /// true.
441 int getStackSlot() const { return std::get<int>(v: Address); }
442
443 /// Returns the MCRegister of this variable, assuming
444 /// `inEntryValueRegister()` is true.
445 MCRegister getEntryValueRegister() const {
446 return std::get<MCRegister>(v: 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.
463 virtual void MF_HandleInsertion(MachineInstr &MI) = 0;
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 {
478 Register Reg;
479 uint16_t ArgNo;
480 ArgRegPair(Register R, unsigned Arg) : Reg(R), ArgNo(Arg) {
481 assert(Arg < (1 << 16) && "Arg out of range");
482 }
483 };
484
485 struct CallSiteInfo {
486 /// Vector of call argument and its forwarding register.
487 SmallVector<ArgRegPair, 1> ArgRegPairs;
488 };
489
490private:
491 Delegate *TheDelegate = nullptr;
492 GISelChangeObserver *Observer = nullptr;
493
494 using CallSiteInfoMap = DenseMap<const MachineInstr *, CallSiteInfo>;
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
511 using VariableDbgInfoMapTy = SmallVector<VariableDbgInfo, 4>;
512 VariableDbgInfoMapTy VariableDbgInfos;
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.
535 class DebugSubstitution {
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
541 DebugSubstitution(const DebugInstrOperandPair &Src,
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.
556 SmallVector<DebugSubstitution, 8> DebugValueSubstitutions;
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).
563 class DebugPHIRegallocPos {
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.
568 DebugPHIRegallocPos(MachineBasicBlock *MBB, Register Reg, unsigned SubReg)
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.
574 DenseMap<unsigned, DebugPHIRegallocPos> DebugPHIPositions;
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.
607 DebugInstrOperandPair
608 salvageCopySSA(MachineInstr &MI,
609 DenseMap<Register, DebugInstrOperandPair> &DbgPHICache);
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
635 MachineFunction(Function &F, const LLVMTargetMachine &Target,
636 const TargetSubtargetInfo &STI, unsigned FunctionNum,
637 MachineModuleInfo &MMI);
638 MachineFunction(const MachineFunction &) = delete;
639 MachineFunction &operator=(const MachineFunction &) = delete;
640 ~MachineFunction();
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.
728 MachineRegisterInfo &getRegInfo() { return *RegInfo; }
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.
750 MachineConstantPool *getConstantPool() { return ConstantPool; }
751 const MachineConstantPool *getConstantPool() const { return ConstantPool; }
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.
772 void ensureAlignment(Align A) {
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.
786 void setExposesReturnsTwice(bool B) {
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
834 MachineFunctionInfo *cloneInfoFrom(
835 const MachineFunction &OrigMF,
836 const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB) {
837 assert(!MFInfo && "new function already has MachineFunctionInfo");
838 if (!OrigMF.MFInfo)
839 return nullptr;
840 return OrigMF.MFInfo->clone(Allocator, DestMF&: *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.
851 MachineBasicBlock *getBlockNumbered(unsigned N) const {
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...
904 using iterator = BasicBlockListType::iterator;
905 using const_iterator = BasicBlockListType::const_iterator;
906 using const_reverse_iterator = BasicBlockListType::const_reverse_iterator;
907 using reverse_iterator = BasicBlockListType::reverse_iterator;
908
909 /// Support for MachineBasicBlock::getNextNode().
910 static BasicBlockListType MachineFunction::*
911 getSublistAccess(MachineBasicBlock *) {
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.
917 Register addLiveIn(MCRegister PReg, const TargetRegisterClass *RC);
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 (val: MBB); }
940 void push_front(MachineBasicBlock *MBB) { BasicBlocks.push_front(val: MBB); }
941 void insert(iterator MBBI, MachineBasicBlock *MBB) {
942 BasicBlocks.insert(where: MBBI, New: MBB);
943 }
944 void splice(iterator InsertPt, iterator MBBI) {
945 BasicBlocks.splice(where: InsertPt, L2&: BasicBlocks, first: MBBI);
946 }
947 void splice(iterator InsertPt, MachineBasicBlock *MBB) {
948 BasicBlocks.splice(where: InsertPt, L2&: BasicBlocks, N: MBB);
949 }
950 void splice(iterator InsertPt, iterator MBBI, iterator MBBE) {
951 BasicBlocks.splice(where: InsertPt, L2&: BasicBlocks, first: MBBI, last: MBBE);
952 }
953
954 void remove(iterator MBBI) { BasicBlocks.remove(IT&: MBBI); }
955 void remove(MachineBasicBlock *MBBI) { BasicBlocks.remove(IT: MBBI); }
956 void erase(iterator MBBI) { BasicBlocks.erase(where: MBBI); }
957 void erase(MachineBasicBlock *MBBI) { BasicBlocks.erase(IT: 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.
977 unsigned addToMBBNumbering(MachineBasicBlock *MBB) {
978 MBBNumbering.push_back(x: 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.
1020 MachineBasicBlock *
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.
1030 MachineMemOperand *getMachineMemOperand(
1031 MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, LLT MemTy,
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);
1036 MachineMemOperand *getMachineMemOperand(
1037 MachinePointerInfo PtrInfo, MachineMemOperand::Flags F, LocationSize Size,
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);
1042 MachineMemOperand *getMachineMemOperand(
1043 MachinePointerInfo PtrInfo, MachineMemOperand::Flags F, uint64_t Size,
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, Size: LocationSize::precise(Value: 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.
1057 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1058 int64_t Offset, LLT Ty);
1059 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1060 int64_t Offset, LocationSize Size) {
1061 return getMachineMemOperand(
1062 MMO, Offset,
1063 Ty: !Size.hasValue() ? LLT()
1064 : Size.isScalable()
1065 ? LLT::scalable_vector(MinNumElements: 1, ScalarSizeInBits: 8 * Size.getValue().getKnownMinValue())
1066 : LLT::scalar(SizeInBits: 8 * Size.getValue().getKnownMinValue()));
1067 }
1068 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1069 int64_t Offset, uint64_t Size) {
1070 return getMachineMemOperand(MMO, Offset, Size: LocationSize::precise(Value: 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.
1077 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1078 const MachinePointerInfo &PtrInfo,
1079 LocationSize Size);
1080 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1081 const MachinePointerInfo &PtrInfo,
1082 LLT Ty);
1083 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1084 const MachinePointerInfo &PtrInfo,
1085 uint64_t Size) {
1086 return getMachineMemOperand(MMO, PtrInfo, Size: LocationSize::precise(Value: 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.
1092 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
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.
1098 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1099 MachineMemOperand::Flags Flags);
1100
1101 using OperandCapacity = ArrayRecycler<MachineOperand>::Capacity;
1102
1103 /// Allocate an array of MachineOperands. This is only intended for use by
1104 /// internal MachineInstr functions.
1105 MachineOperand *allocateOperandArray(OperandCapacity Cap) {
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.
1112 void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array) {
1113 OperandRecycler.deallocate(Cap, Ptr: 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 MDNode *MMRAs = nullptr);
1130
1131 /// Allocate a string and populate it with the given external symbol name.
1132 const char *createExternalSymbolName(StringRef Name);
1133
1134 //===--------------------------------------------------------------------===//
1135 // Label Manipulation.
1136
1137 /// getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
1138 /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
1139 /// normal 'L' label is returned.
1140 MCSymbol *getJTISymbol(unsigned JTI, MCContext &Ctx,
1141 bool isLinkerPrivate = false) const;
1142
1143 /// getPICBaseSymbol - Return a function-local symbol to represent the PIC
1144 /// base.
1145 MCSymbol *getPICBaseSymbol() const;
1146
1147 /// Returns a reference to a list of cfi instructions in the function's
1148 /// prologue. Used to construct frame maps for debug and exception handling
1149 /// comsumers.
1150 const std::vector<MCCFIInstruction> &getFrameInstructions() const {
1151 return FrameInstructions;
1152 }
1153
1154 [[nodiscard]] unsigned addFrameInst(const MCCFIInstruction &Inst);
1155
1156 /// Returns a reference to a list of symbols immediately following calls to
1157 /// _setjmp in the function. Used to construct the longjmp target table used
1158 /// by Windows Control Flow Guard.
1159 const std::vector<MCSymbol *> &getLongjmpTargets() const {
1160 return LongjmpTargets;
1161 }
1162
1163 /// Add the specified symbol to the list of valid longjmp targets for Windows
1164 /// Control Flow Guard.
1165 void addLongjmpTarget(MCSymbol *Target) { LongjmpTargets.push_back(x: Target); }
1166
1167 /// Returns a reference to a list of symbols that we have catchrets.
1168 /// Used to construct the catchret target table used by Windows EHCont Guard.
1169 const std::vector<MCSymbol *> &getCatchretTargets() const {
1170 return CatchretTargets;
1171 }
1172
1173 /// Add the specified symbol to the list of valid catchret targets for Windows
1174 /// EHCont Guard.
1175 void addCatchretTarget(MCSymbol *Target) {
1176 CatchretTargets.push_back(x: Target);
1177 }
1178
1179 /// \name Exception Handling
1180 /// \{
1181
1182 bool callsEHReturn() const { return CallsEHReturn; }
1183 void setCallsEHReturn(bool b) { CallsEHReturn = b; }
1184
1185 bool callsUnwindInit() const { return CallsUnwindInit; }
1186 void setCallsUnwindInit(bool b) { CallsUnwindInit = b; }
1187
1188 bool hasEHCatchret() const { return HasEHCatchret; }
1189 void setHasEHCatchret(bool V) { HasEHCatchret = V; }
1190
1191 bool hasEHScopes() const { return HasEHScopes; }
1192 void setHasEHScopes(bool V) { HasEHScopes = V; }
1193
1194 bool hasEHFunclets() const { return HasEHFunclets; }
1195 void setHasEHFunclets(bool V) { HasEHFunclets = V; }
1196
1197 bool isOutlined() const { return IsOutlined; }
1198 void setIsOutlined(bool V) { IsOutlined = V; }
1199
1200 /// Find or create an LandingPadInfo for the specified MachineBasicBlock.
1201 LandingPadInfo &getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad);
1202
1203 /// Return a reference to the landing pad info for the current function.
1204 const std::vector<LandingPadInfo> &getLandingPads() const {
1205 return LandingPads;
1206 }
1207
1208 /// Provide the begin and end labels of an invoke style call and associate it
1209 /// with a try landing pad block.
1210 void addInvoke(MachineBasicBlock *LandingPad,
1211 MCSymbol *BeginLabel, MCSymbol *EndLabel);
1212
1213 /// Add a new panding pad, and extract the exception handling information from
1214 /// the landingpad instruction. Returns the label ID for the landing pad
1215 /// entry.
1216 MCSymbol *addLandingPad(MachineBasicBlock *LandingPad);
1217
1218 /// Return the type id for the specified typeinfo. This is function wide.
1219 unsigned getTypeIDFor(const GlobalValue *TI);
1220
1221 /// Return the id of the filter encoded by TyIds. This is function wide.
1222 int getFilterIDFor(ArrayRef<unsigned> TyIds);
1223
1224 /// Map the landing pad's EH symbol to the call site indexes.
1225 void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef<unsigned> Sites);
1226
1227 /// Return if there is any wasm exception handling.
1228 bool hasAnyWasmLandingPadIndex() const {
1229 return !WasmLPadToIndexMap.empty();
1230 }
1231
1232 /// Map the landing pad to its index. Used for Wasm exception handling.
1233 void setWasmLandingPadIndex(const MachineBasicBlock *LPad, unsigned Index) {
1234 WasmLPadToIndexMap[LPad] = Index;
1235 }
1236
1237 /// Returns true if the landing pad has an associate index in wasm EH.
1238 bool hasWasmLandingPadIndex(const MachineBasicBlock *LPad) const {
1239 return WasmLPadToIndexMap.count(Val: LPad);
1240 }
1241
1242 /// Get the index in wasm EH for a given landing pad.
1243 unsigned getWasmLandingPadIndex(const MachineBasicBlock *LPad) const {
1244 assert(hasWasmLandingPadIndex(LPad));
1245 return WasmLPadToIndexMap.lookup(Val: LPad);
1246 }
1247
1248 bool hasAnyCallSiteLandingPad() const {
1249 return !LPadToCallSiteMap.empty();
1250 }
1251
1252 /// Get the call site indexes for a landing pad EH symbol.
1253 SmallVectorImpl<unsigned> &getCallSiteLandingPad(MCSymbol *Sym) {
1254 assert(hasCallSiteLandingPad(Sym) &&
1255 "missing call site number for landing pad!");
1256 return LPadToCallSiteMap[Sym];
1257 }
1258
1259 /// Return true if the landing pad Eh symbol has an associated call site.
1260 bool hasCallSiteLandingPad(MCSymbol *Sym) {
1261 return !LPadToCallSiteMap[Sym].empty();
1262 }
1263
1264 bool hasAnyCallSiteLabel() const {
1265 return !CallSiteMap.empty();
1266 }
1267
1268 /// Map the begin label for a call site.
1269 void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site) {
1270 CallSiteMap[BeginLabel] = Site;
1271 }
1272
1273 /// Get the call site number for a begin label.
1274 unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) const {
1275 assert(hasCallSiteBeginLabel(BeginLabel) &&
1276 "Missing call site number for EH_LABEL!");
1277 return CallSiteMap.lookup(Val: BeginLabel);
1278 }
1279
1280 /// Return true if the begin label has a call site number associated with it.
1281 bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) const {
1282 return CallSiteMap.count(Val: BeginLabel);
1283 }
1284
1285 /// Record annotations associated with a particular label.
1286 void addCodeViewAnnotation(MCSymbol *Label, MDNode *MD) {
1287 CodeViewAnnotations.push_back(x: {Label, MD});
1288 }
1289
1290 ArrayRef<std::pair<MCSymbol *, MDNode *>> getCodeViewAnnotations() const {
1291 return CodeViewAnnotations;
1292 }
1293
1294 /// Return a reference to the C++ typeinfo for the current function.
1295 const std::vector<const GlobalValue *> &getTypeInfos() const {
1296 return TypeInfos;
1297 }
1298
1299 /// Return a reference to the typeids encoding filters used in the current
1300 /// function.
1301 const std::vector<unsigned> &getFilterIds() const {
1302 return FilterIds;
1303 }
1304
1305 /// \}
1306
1307 /// Collect information used to emit debugging information of a variable in a
1308 /// stack slot.
1309 void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
1310 int Slot, const DILocation *Loc) {
1311 VariableDbgInfos.emplace_back(Args&: Var, Args&: Expr, Args&: Slot, Args&: Loc);
1312 }
1313
1314 /// Collect information used to emit debugging information of a variable in
1315 /// the entry value of a register.
1316 void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
1317 MCRegister Reg, const DILocation *Loc) {
1318 VariableDbgInfos.emplace_back(Args&: Var, Args&: Expr, Args&: Reg, Args&: Loc);
1319 }
1320
1321 VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfos; }
1322 const VariableDbgInfoMapTy &getVariableDbgInfo() const {
1323 return VariableDbgInfos;
1324 }
1325
1326 /// Returns the collection of variables for which we have debug info and that
1327 /// have been assigned a stack slot.
1328 auto getInStackSlotVariableDbgInfo() {
1329 return make_filter_range(Range&: getVariableDbgInfo(), Pred: [](auto &VarInfo) {
1330 return VarInfo.inStackSlot();
1331 });
1332 }
1333
1334 /// Returns the collection of variables for which we have debug info and that
1335 /// have been assigned a stack slot.
1336 auto getInStackSlotVariableDbgInfo() const {
1337 return make_filter_range(Range: getVariableDbgInfo(), Pred: [](const auto &VarInfo) {
1338 return VarInfo.inStackSlot();
1339 });
1340 }
1341
1342 /// Returns the collection of variables for which we have debug info and that
1343 /// have been assigned an entry value register.
1344 auto getEntryValueVariableDbgInfo() const {
1345 return make_filter_range(Range: getVariableDbgInfo(), Pred: [](const auto &VarInfo) {
1346 return VarInfo.inEntryValueRegister();
1347 });
1348 }
1349
1350 /// Start tracking the arguments passed to the call \p CallI.
1351 void addCallSiteInfo(const MachineInstr *CallI, CallSiteInfo &&CallInfo) {
1352 assert(CallI->isCandidateForCallSiteEntry());
1353 bool Inserted =
1354 CallSitesInfo.try_emplace(Key: CallI, Args: std::move(CallInfo)).second;
1355 (void)Inserted;
1356 assert(Inserted && "Call site info not unique");
1357 }
1358
1359 const CallSiteInfoMap &getCallSitesInfo() const {
1360 return CallSitesInfo;
1361 }
1362
1363 /// Following functions update call site info. They should be called before
1364 /// removing, replacing or copying call instruction.
1365
1366 /// Erase the call site info for \p MI. It is used to remove a call
1367 /// instruction from the instruction stream.
1368 void eraseCallSiteInfo(const MachineInstr *MI);
1369 /// Copy the call site info from \p Old to \ New. Its usage is when we are
1370 /// making a copy of the instruction that will be inserted at different point
1371 /// of the instruction stream.
1372 void copyCallSiteInfo(const MachineInstr *Old,
1373 const MachineInstr *New);
1374
1375 /// Move the call site info from \p Old to \New call site info. This function
1376 /// is used when we are replacing one call instruction with another one to
1377 /// the same callee.
1378 void moveCallSiteInfo(const MachineInstr *Old,
1379 const MachineInstr *New);
1380
1381 unsigned getNewDebugInstrNum() {
1382 return ++DebugInstrNumberingCount;
1383 }
1384};
1385
1386//===--------------------------------------------------------------------===//
1387// GraphTraits specializations for function basic block graphs (CFGs)
1388//===--------------------------------------------------------------------===//
1389
1390// Provide specializations of GraphTraits to be able to treat a
1391// machine function as a graph of machine basic blocks... these are
1392// the same as the machine basic block iterators, except that the root
1393// node is implicitly the first node of the function.
1394//
1395template <> struct GraphTraits<MachineFunction*> :
1396 public GraphTraits<MachineBasicBlock*> {
1397 static NodeRef getEntryNode(MachineFunction *F) { return &F->front(); }
1398
1399 // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
1400 using nodes_iterator = pointer_iterator<MachineFunction::iterator>;
1401
1402 static nodes_iterator nodes_begin(MachineFunction *F) {
1403 return nodes_iterator(F->begin());
1404 }
1405
1406 static nodes_iterator nodes_end(MachineFunction *F) {
1407 return nodes_iterator(F->end());
1408 }
1409
1410 static unsigned size (MachineFunction *F) { return F->size(); }
1411};
1412template <> struct GraphTraits<const MachineFunction*> :
1413 public GraphTraits<const MachineBasicBlock*> {
1414 static NodeRef getEntryNode(const MachineFunction *F) { return &F->front(); }
1415
1416 // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
1417 using nodes_iterator = pointer_iterator<MachineFunction::const_iterator>;
1418
1419 static nodes_iterator nodes_begin(const MachineFunction *F) {
1420 return nodes_iterator(F->begin());
1421 }
1422
1423 static nodes_iterator nodes_end (const MachineFunction *F) {
1424 return nodes_iterator(F->end());
1425 }
1426
1427 static unsigned size (const MachineFunction *F) {
1428 return F->size();
1429 }
1430};
1431
1432// Provide specializations of GraphTraits to be able to treat a function as a
1433// graph of basic blocks... and to walk it in inverse order. Inverse order for
1434// a function is considered to be when traversing the predecessor edges of a BB
1435// instead of the successor edges.
1436//
1437template <> struct GraphTraits<Inverse<MachineFunction*>> :
1438 public GraphTraits<Inverse<MachineBasicBlock*>> {
1439 static NodeRef getEntryNode(Inverse<MachineFunction *> G) {
1440 return &G.Graph->front();
1441 }
1442};
1443template <> struct GraphTraits<Inverse<const MachineFunction*>> :
1444 public GraphTraits<Inverse<const MachineBasicBlock*>> {
1445 static NodeRef getEntryNode(Inverse<const MachineFunction *> G) {
1446 return &G.Graph->front();
1447 }
1448};
1449
1450void verifyMachineFunction(const std::string &Banner,
1451 const MachineFunction &MF);
1452
1453} // end namespace llvm
1454
1455#endif // LLVM_CODEGEN_MACHINEFUNCTION_H
1456

source code of llvm/include/llvm/CodeGen/MachineFunction.h