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 /// Vector of call argument and its forwarding register.
485 using CallSiteInfo = SmallVector<ArgRegPair, 1>;
486 using CallSiteInfoImpl = SmallVectorImpl<ArgRegPair>;
487
488private:
489 Delegate *TheDelegate = nullptr;
490 GISelChangeObserver *Observer = nullptr;
491
492 using CallSiteInfoMap = DenseMap<const MachineInstr *, CallSiteInfo>;
493 /// Map a call instruction to call site arguments forwarding info.
494 CallSiteInfoMap CallSitesInfo;
495
496 /// A helper function that returns call site info for a give call
497 /// instruction if debug entry value support is enabled.
498 CallSiteInfoMap::iterator getCallSiteInfo(const MachineInstr *MI);
499
500 // Callbacks for insertion and removal.
501 void handleInsertion(MachineInstr &MI);
502 void handleRemoval(MachineInstr &MI);
503 friend struct ilist_traits<MachineInstr>;
504
505public:
506 // Need to be accessed from MachineInstr::setDesc.
507 void handleChangeDesc(MachineInstr &MI, const MCInstrDesc &TID);
508
509 using VariableDbgInfoMapTy = SmallVector<VariableDbgInfo, 4>;
510 VariableDbgInfoMapTy VariableDbgInfos;
511
512 /// A count of how many instructions in the function have had numbers
513 /// assigned to them. Used for debug value tracking, to determine the
514 /// next instruction number.
515 unsigned DebugInstrNumberingCount = 0;
516
517 /// Set value of DebugInstrNumberingCount field. Avoid using this unless
518 /// you're deserializing this data.
519 void setDebugInstrNumberingCount(unsigned Num);
520
521 /// Pair of instruction number and operand number.
522 using DebugInstrOperandPair = std::pair<unsigned, unsigned>;
523
524 /// Replacement definition for a debug instruction reference. Made up of a
525 /// source instruction / operand pair, destination pair, and a qualifying
526 /// subregister indicating what bits in the operand make up the substitution.
527 // For example, a debug user
528 /// of %1:
529 /// %0:gr32 = someinst, debug-instr-number 1
530 /// %1:gr16 = %0.some_16_bit_subreg, debug-instr-number 2
531 /// Would receive the substitution {{2, 0}, {1, 0}, $subreg}, where $subreg is
532 /// the subregister number for some_16_bit_subreg.
533 class DebugSubstitution {
534 public:
535 DebugInstrOperandPair Src; ///< Source instruction / operand pair.
536 DebugInstrOperandPair Dest; ///< Replacement instruction / operand pair.
537 unsigned Subreg; ///< Qualifier for which part of Dest is read.
538
539 DebugSubstitution(const DebugInstrOperandPair &Src,
540 const DebugInstrOperandPair &Dest, unsigned Subreg)
541 : Src(Src), Dest(Dest), Subreg(Subreg) {}
542
543 /// Order only by source instruction / operand pair: there should never
544 /// be duplicate entries for the same source in any collection.
545 bool operator<(const DebugSubstitution &Other) const {
546 return Src < Other.Src;
547 }
548 };
549
550 /// Debug value substitutions: a collection of DebugSubstitution objects,
551 /// recording changes in where a value is defined. For example, when one
552 /// instruction is substituted for another. Keeping a record allows recovery
553 /// of variable locations after compilation finishes.
554 SmallVector<DebugSubstitution, 8> DebugValueSubstitutions;
555
556 /// Location of a PHI instruction that is also a debug-info variable value,
557 /// for the duration of register allocation. Loaded by the PHI-elimination
558 /// pass, and emitted as DBG_PHI instructions during VirtRegRewriter, with
559 /// maintenance applied by intermediate passes that edit registers (such as
560 /// coalescing and the allocator passes).
561 class DebugPHIRegallocPos {
562 public:
563 MachineBasicBlock *MBB; ///< Block where this PHI was originally located.
564 Register Reg; ///< VReg where the control-flow-merge happens.
565 unsigned SubReg; ///< Optional subreg qualifier within Reg.
566 DebugPHIRegallocPos(MachineBasicBlock *MBB, Register Reg, unsigned SubReg)
567 : MBB(MBB), Reg(Reg), SubReg(SubReg) {}
568 };
569
570 /// Map of debug instruction numbers to the position of their PHI instructions
571 /// during register allocation. See DebugPHIRegallocPos.
572 DenseMap<unsigned, DebugPHIRegallocPos> DebugPHIPositions;
573
574 /// Flag for whether this function contains DBG_VALUEs (false) or
575 /// DBG_INSTR_REF (true).
576 bool UseDebugInstrRef = false;
577
578 /// Create a substitution between one <instr,operand> value to a different,
579 /// new value.
580 void makeDebugValueSubstitution(DebugInstrOperandPair, DebugInstrOperandPair,
581 unsigned SubReg = 0);
582
583 /// Create substitutions for any tracked values in \p Old, to point at
584 /// \p New. Needed when we re-create an instruction during optimization,
585 /// which has the same signature (i.e., def operands in the same place) but
586 /// a modified instruction type, flags, or otherwise. An example: X86 moves
587 /// are sometimes transformed into equivalent LEAs.
588 /// If the two instructions are not the same opcode, limit which operands to
589 /// examine for substitutions to the first N operands by setting
590 /// \p MaxOperand.
591 void substituteDebugValuesForInst(const MachineInstr &Old, MachineInstr &New,
592 unsigned MaxOperand = UINT_MAX);
593
594 /// Find the underlying defining instruction / operand for a COPY instruction
595 /// while in SSA form. Copies do not actually define values -- they move them
596 /// between registers. Labelling a COPY-like instruction with an instruction
597 /// number is to be avoided as it makes value numbers non-unique later in
598 /// compilation. This method follows the definition chain for any sequence of
599 /// COPY-like instructions to find whatever non-COPY-like instruction defines
600 /// the copied value; or for parameters, creates a DBG_PHI on entry.
601 /// May insert instructions into the entry block!
602 /// \p MI The copy-like instruction to salvage.
603 /// \p DbgPHICache A container to cache already-solved COPYs.
604 /// \returns An instruction/operand pair identifying the defining value.
605 DebugInstrOperandPair
606 salvageCopySSA(MachineInstr &MI,
607 DenseMap<Register, DebugInstrOperandPair> &DbgPHICache);
608
609 DebugInstrOperandPair salvageCopySSAImpl(MachineInstr &MI);
610
611 /// Finalise any partially emitted debug instructions. These are DBG_INSTR_REF
612 /// instructions where we only knew the vreg of the value they use, not the
613 /// instruction that defines that vreg. Once isel finishes, we should have
614 /// enough information for every DBG_INSTR_REF to point at an instruction
615 /// (or DBG_PHI).
616 void finalizeDebugInstrRefs();
617
618 /// Determine whether, in the current machine configuration, we should use
619 /// instruction referencing or not.
620 bool shouldUseDebugInstrRef() const;
621
622 /// Returns true if the function's variable locations are tracked with
623 /// instruction referencing.
624 bool useDebugInstrRef() const;
625
626 /// Set whether this function will use instruction referencing or not.
627 void setUseDebugInstrRef(bool UseInstrRef);
628
629 /// A reserved operand number representing the instructions memory operand,
630 /// for instructions that have a stack spill fused into them.
631 const static unsigned int DebugOperandMemNumber;
632
633 MachineFunction(Function &F, const LLVMTargetMachine &Target,
634 const TargetSubtargetInfo &STI, unsigned FunctionNum,
635 MachineModuleInfo &MMI);
636 MachineFunction(const MachineFunction &) = delete;
637 MachineFunction &operator=(const MachineFunction &) = delete;
638 ~MachineFunction();
639
640 /// Reset the instance as if it was just created.
641 void reset() {
642 clear();
643 init();
644 }
645
646 /// Reset the currently registered delegate - otherwise assert.
647 void resetDelegate(Delegate *delegate) {
648 assert(TheDelegate == delegate &&
649 "Only the current delegate can perform reset!");
650 TheDelegate = nullptr;
651 }
652
653 /// Set the delegate. resetDelegate must be called before attempting
654 /// to set.
655 void setDelegate(Delegate *delegate) {
656 assert(delegate && !TheDelegate &&
657 "Attempted to set delegate to null, or to change it without "
658 "first resetting it!");
659
660 TheDelegate = delegate;
661 }
662
663 void setObserver(GISelChangeObserver *O) { Observer = O; }
664
665 GISelChangeObserver *getObserver() const { return Observer; }
666
667 MachineModuleInfo &getMMI() const { return MMI; }
668 MCContext &getContext() const { return Ctx; }
669
670 /// Returns the Section this function belongs to.
671 MCSection *getSection() const { return Section; }
672
673 /// Indicates the Section this function belongs to.
674 void setSection(MCSection *S) { Section = S; }
675
676 PseudoSourceValueManager &getPSVManager() const { return *PSVManager; }
677
678 /// Return the DataLayout attached to the Module associated to this MF.
679 const DataLayout &getDataLayout() const;
680
681 /// Return the LLVM function that this machine code represents
682 Function &getFunction() { return F; }
683
684 /// Return the LLVM function that this machine code represents
685 const Function &getFunction() const { return F; }
686
687 /// getName - Return the name of the corresponding LLVM function.
688 StringRef getName() const;
689
690 /// getFunctionNumber - Return a unique ID for the current function.
691 unsigned getFunctionNumber() const { return FunctionNumber; }
692
693 /// Returns true if this function has basic block sections enabled.
694 bool hasBBSections() const {
695 return (BBSectionsType == BasicBlockSection::All ||
696 BBSectionsType == BasicBlockSection::List ||
697 BBSectionsType == BasicBlockSection::Preset);
698 }
699
700 /// Returns true if basic block labels are to be generated for this function.
701 bool hasBBLabels() const {
702 return BBSectionsType == BasicBlockSection::Labels;
703 }
704
705 void setBBSectionsType(BasicBlockSection V) { BBSectionsType = V; }
706
707 /// Assign IsBeginSection IsEndSection fields for basic blocks in this
708 /// function.
709 void assignBeginEndSections();
710
711 /// getTarget - Return the target machine this machine code is compiled with
712 const LLVMTargetMachine &getTarget() const { return Target; }
713
714 /// getSubtarget - Return the subtarget for which this machine code is being
715 /// compiled.
716 const TargetSubtargetInfo &getSubtarget() const { return *STI; }
717
718 /// getSubtarget - This method returns a pointer to the specified type of
719 /// TargetSubtargetInfo. In debug builds, it verifies that the object being
720 /// returned is of the correct type.
721 template<typename STC> const STC &getSubtarget() const {
722 return *static_cast<const STC *>(STI);
723 }
724
725 /// getRegInfo - Return information about the registers currently in use.
726 MachineRegisterInfo &getRegInfo() { return *RegInfo; }
727 const MachineRegisterInfo &getRegInfo() const { return *RegInfo; }
728
729 /// getFrameInfo - Return the frame info object for the current function.
730 /// This object contains information about objects allocated on the stack
731 /// frame of the current function in an abstract way.
732 MachineFrameInfo &getFrameInfo() { return *FrameInfo; }
733 const MachineFrameInfo &getFrameInfo() const { return *FrameInfo; }
734
735 /// getJumpTableInfo - Return the jump table info object for the current
736 /// function. This object contains information about jump tables in the
737 /// current function. If the current function has no jump tables, this will
738 /// return null.
739 const MachineJumpTableInfo *getJumpTableInfo() const { return JumpTableInfo; }
740 MachineJumpTableInfo *getJumpTableInfo() { return JumpTableInfo; }
741
742 /// getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it
743 /// does already exist, allocate one.
744 MachineJumpTableInfo *getOrCreateJumpTableInfo(unsigned JTEntryKind);
745
746 /// getConstantPool - Return the constant pool object for the current
747 /// function.
748 MachineConstantPool *getConstantPool() { return ConstantPool; }
749 const MachineConstantPool *getConstantPool() const { return ConstantPool; }
750
751 /// getWasmEHFuncInfo - Return information about how the current function uses
752 /// Wasm exception handling. Returns null for functions that don't use wasm
753 /// exception handling.
754 const WasmEHFuncInfo *getWasmEHFuncInfo() const { return WasmEHInfo; }
755 WasmEHFuncInfo *getWasmEHFuncInfo() { return WasmEHInfo; }
756
757 /// getWinEHFuncInfo - Return information about how the current function uses
758 /// Windows exception handling. Returns null for functions that don't use
759 /// funclets for exception handling.
760 const WinEHFuncInfo *getWinEHFuncInfo() const { return WinEHInfo; }
761 WinEHFuncInfo *getWinEHFuncInfo() { return WinEHInfo; }
762
763 /// getAlignment - Return the alignment of the function.
764 Align getAlignment() const { return Alignment; }
765
766 /// setAlignment - Set the alignment of the function.
767 void setAlignment(Align A) { Alignment = A; }
768
769 /// ensureAlignment - Make sure the function is at least A bytes aligned.
770 void ensureAlignment(Align A) {
771 if (Alignment < A)
772 Alignment = A;
773 }
774
775 /// exposesReturnsTwice - Returns true if the function calls setjmp or
776 /// any other similar functions with attribute "returns twice" without
777 /// having the attribute itself.
778 bool exposesReturnsTwice() const {
779 return ExposesReturnsTwice;
780 }
781
782 /// setCallsSetJmp - Set a flag that indicates if there's a call to
783 /// a "returns twice" function.
784 void setExposesReturnsTwice(bool B) {
785 ExposesReturnsTwice = B;
786 }
787
788 /// Returns true if the function contains any inline assembly.
789 bool hasInlineAsm() const {
790 return HasInlineAsm;
791 }
792
793 /// Set a flag that indicates that the function contains inline assembly.
794 void setHasInlineAsm(bool B) {
795 HasInlineAsm = B;
796 }
797
798 bool hasWinCFI() const {
799 return HasWinCFI;
800 }
801 void setHasWinCFI(bool v) { HasWinCFI = v; }
802
803 /// True if this function needs frame moves for debug or exceptions.
804 bool needsFrameMoves() const;
805
806 /// Get the function properties
807 const MachineFunctionProperties &getProperties() const { return Properties; }
808 MachineFunctionProperties &getProperties() { return Properties; }
809
810 /// getInfo - Keep track of various per-function pieces of information for
811 /// backends that would like to do so.
812 ///
813 template<typename Ty>
814 Ty *getInfo() {
815 return static_cast<Ty*>(MFInfo);
816 }
817
818 template<typename Ty>
819 const Ty *getInfo() const {
820 return static_cast<const Ty *>(MFInfo);
821 }
822
823 template <typename Ty> Ty *cloneInfo(const Ty &Old) {
824 assert(!MFInfo);
825 MFInfo = Ty::template create<Ty>(Allocator, Old);
826 return static_cast<Ty *>(MFInfo);
827 }
828
829 /// Initialize the target specific MachineFunctionInfo
830 void initTargetMachineFunctionInfo(const TargetSubtargetInfo &STI);
831
832 MachineFunctionInfo *cloneInfoFrom(
833 const MachineFunction &OrigMF,
834 const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB) {
835 assert(!MFInfo && "new function already has MachineFunctionInfo");
836 if (!OrigMF.MFInfo)
837 return nullptr;
838 return OrigMF.MFInfo->clone(Allocator, DestMF&: *this, Src2DstMBB);
839 }
840
841 /// Returns the denormal handling type for the default rounding mode of the
842 /// function.
843 DenormalMode getDenormalMode(const fltSemantics &FPType) const;
844
845 /// getBlockNumbered - MachineBasicBlocks are automatically numbered when they
846 /// are inserted into the machine function. The block number for a machine
847 /// basic block can be found by using the MBB::getNumber method, this method
848 /// provides the inverse mapping.
849 MachineBasicBlock *getBlockNumbered(unsigned N) const {
850 assert(N < MBBNumbering.size() && "Illegal block number");
851 assert(MBBNumbering[N] && "Block was removed from the machine function!");
852 return MBBNumbering[N];
853 }
854
855 /// Should we be emitting segmented stack stuff for the function
856 bool shouldSplitStack() const;
857
858 /// getNumBlockIDs - Return the number of MBB ID's allocated.
859 unsigned getNumBlockIDs() const { return (unsigned)MBBNumbering.size(); }
860
861 /// RenumberBlocks - This discards all of the MachineBasicBlock numbers and
862 /// recomputes them. This guarantees that the MBB numbers are sequential,
863 /// dense, and match the ordering of the blocks within the function. If a
864 /// specific MachineBasicBlock is specified, only that block and those after
865 /// it are renumbered.
866 void RenumberBlocks(MachineBasicBlock *MBBFrom = nullptr);
867
868 /// print - Print out the MachineFunction in a format suitable for debugging
869 /// to the specified stream.
870 void print(raw_ostream &OS, const SlotIndexes* = nullptr) const;
871
872 /// viewCFG - This function is meant for use from the debugger. You can just
873 /// say 'call F->viewCFG()' and a ghostview window should pop up from the
874 /// program, displaying the CFG of the current function with the code for each
875 /// basic block inside. This depends on there being a 'dot' and 'gv' program
876 /// in your path.
877 void viewCFG() const;
878
879 /// viewCFGOnly - This function is meant for use from the debugger. It works
880 /// just like viewCFG, but it does not include the contents of basic blocks
881 /// into the nodes, just the label. If you are only interested in the CFG
882 /// this can make the graph smaller.
883 ///
884 void viewCFGOnly() const;
885
886 /// dump - Print the current MachineFunction to cerr, useful for debugger use.
887 void dump() const;
888
889 /// Run the current MachineFunction through the machine code verifier, useful
890 /// for debugger use.
891 /// \returns true if no problems were found.
892 bool verify(Pass *p = nullptr, const char *Banner = nullptr,
893 bool AbortOnError = true) const;
894
895 /// Run the current MachineFunction through the machine code verifier, useful
896 /// for debugger use.
897 /// \returns true if no problems were found.
898 bool verify(LiveIntervals *LiveInts, SlotIndexes *Indexes,
899 const char *Banner = nullptr, bool AbortOnError = true) const;
900
901 // Provide accessors for the MachineBasicBlock list...
902 using iterator = BasicBlockListType::iterator;
903 using const_iterator = BasicBlockListType::const_iterator;
904 using const_reverse_iterator = BasicBlockListType::const_reverse_iterator;
905 using reverse_iterator = BasicBlockListType::reverse_iterator;
906
907 /// Support for MachineBasicBlock::getNextNode().
908 static BasicBlockListType MachineFunction::*
909 getSublistAccess(MachineBasicBlock *) {
910 return &MachineFunction::BasicBlocks;
911 }
912
913 /// addLiveIn - Add the specified physical register as a live-in value and
914 /// create a corresponding virtual register for it.
915 Register addLiveIn(MCRegister PReg, const TargetRegisterClass *RC);
916
917 //===--------------------------------------------------------------------===//
918 // BasicBlock accessor functions.
919 //
920 iterator begin() { return BasicBlocks.begin(); }
921 const_iterator begin() const { return BasicBlocks.begin(); }
922 iterator end () { return BasicBlocks.end(); }
923 const_iterator end () const { return BasicBlocks.end(); }
924
925 reverse_iterator rbegin() { return BasicBlocks.rbegin(); }
926 const_reverse_iterator rbegin() const { return BasicBlocks.rbegin(); }
927 reverse_iterator rend () { return BasicBlocks.rend(); }
928 const_reverse_iterator rend () const { return BasicBlocks.rend(); }
929
930 unsigned size() const { return (unsigned)BasicBlocks.size();}
931 bool empty() const { return BasicBlocks.empty(); }
932 const MachineBasicBlock &front() const { return BasicBlocks.front(); }
933 MachineBasicBlock &front() { return BasicBlocks.front(); }
934 const MachineBasicBlock & back() const { return BasicBlocks.back(); }
935 MachineBasicBlock & back() { return BasicBlocks.back(); }
936
937 void push_back (MachineBasicBlock *MBB) { BasicBlocks.push_back (val: MBB); }
938 void push_front(MachineBasicBlock *MBB) { BasicBlocks.push_front(val: MBB); }
939 void insert(iterator MBBI, MachineBasicBlock *MBB) {
940 BasicBlocks.insert(where: MBBI, New: MBB);
941 }
942 void splice(iterator InsertPt, iterator MBBI) {
943 BasicBlocks.splice(where: InsertPt, L2&: BasicBlocks, first: MBBI);
944 }
945 void splice(iterator InsertPt, MachineBasicBlock *MBB) {
946 BasicBlocks.splice(where: InsertPt, L2&: BasicBlocks, N: MBB);
947 }
948 void splice(iterator InsertPt, iterator MBBI, iterator MBBE) {
949 BasicBlocks.splice(where: InsertPt, L2&: BasicBlocks, first: MBBI, last: MBBE);
950 }
951
952 void remove(iterator MBBI) { BasicBlocks.remove(IT&: MBBI); }
953 void remove(MachineBasicBlock *MBBI) { BasicBlocks.remove(IT: MBBI); }
954 void erase(iterator MBBI) { BasicBlocks.erase(where: MBBI); }
955 void erase(MachineBasicBlock *MBBI) { BasicBlocks.erase(IT: MBBI); }
956
957 template <typename Comp>
958 void sort(Comp comp) {
959 BasicBlocks.sort(comp);
960 }
961
962 /// Return the number of \p MachineInstrs in this \p MachineFunction.
963 unsigned getInstructionCount() const {
964 unsigned InstrCount = 0;
965 for (const MachineBasicBlock &MBB : BasicBlocks)
966 InstrCount += MBB.size();
967 return InstrCount;
968 }
969
970 //===--------------------------------------------------------------------===//
971 // Internal functions used to automatically number MachineBasicBlocks
972
973 /// Adds the MBB to the internal numbering. Returns the unique number
974 /// assigned to the MBB.
975 unsigned addToMBBNumbering(MachineBasicBlock *MBB) {
976 MBBNumbering.push_back(x: MBB);
977 return (unsigned)MBBNumbering.size()-1;
978 }
979
980 /// removeFromMBBNumbering - Remove the specific machine basic block from our
981 /// tracker, this is only really to be used by the MachineBasicBlock
982 /// implementation.
983 void removeFromMBBNumbering(unsigned N) {
984 assert(N < MBBNumbering.size() && "Illegal basic block #");
985 MBBNumbering[N] = nullptr;
986 }
987
988 /// CreateMachineInstr - Allocate a new MachineInstr. Use this instead
989 /// of `new MachineInstr'.
990 MachineInstr *CreateMachineInstr(const MCInstrDesc &MCID, DebugLoc DL,
991 bool NoImplicit = false);
992
993 /// Create a new MachineInstr which is a copy of \p Orig, identical in all
994 /// ways except the instruction has no parent, prev, or next. Bundling flags
995 /// are reset.
996 ///
997 /// Note: Clones a single instruction, not whole instruction bundles.
998 /// Does not perform target specific adjustments; consider using
999 /// TargetInstrInfo::duplicate() instead.
1000 MachineInstr *CloneMachineInstr(const MachineInstr *Orig);
1001
1002 /// Clones instruction or the whole instruction bundle \p Orig and insert
1003 /// into \p MBB before \p InsertBefore.
1004 ///
1005 /// Note: Does not perform target specific adjustments; consider using
1006 /// TargetInstrInfo::duplicate() intead.
1007 MachineInstr &
1008 cloneMachineInstrBundle(MachineBasicBlock &MBB,
1009 MachineBasicBlock::iterator InsertBefore,
1010 const MachineInstr &Orig);
1011
1012 /// DeleteMachineInstr - Delete the given MachineInstr.
1013 void deleteMachineInstr(MachineInstr *MI);
1014
1015 /// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this
1016 /// instead of `new MachineBasicBlock'. Sets `MachineBasicBlock::BBID` if
1017 /// basic-block-sections is enabled for the function.
1018 MachineBasicBlock *
1019 CreateMachineBasicBlock(const BasicBlock *BB = nullptr,
1020 std::optional<UniqueBBID> BBID = std::nullopt);
1021
1022 /// DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
1023 void deleteMachineBasicBlock(MachineBasicBlock *MBB);
1024
1025 /// getMachineMemOperand - Allocate a new MachineMemOperand.
1026 /// MachineMemOperands are owned by the MachineFunction and need not be
1027 /// explicitly deallocated.
1028 MachineMemOperand *getMachineMemOperand(
1029 MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,
1030 Align base_alignment, const AAMDNodes &AAInfo = AAMDNodes(),
1031 const MDNode *Ranges = nullptr, SyncScope::ID SSID = SyncScope::System,
1032 AtomicOrdering Ordering = AtomicOrdering::NotAtomic,
1033 AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);
1034
1035 MachineMemOperand *getMachineMemOperand(
1036 MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, LLT MemTy,
1037 Align base_alignment, const AAMDNodes &AAInfo = AAMDNodes(),
1038 const MDNode *Ranges = nullptr, SyncScope::ID SSID = SyncScope::System,
1039 AtomicOrdering Ordering = AtomicOrdering::NotAtomic,
1040 AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);
1041
1042 /// getMachineMemOperand - Allocate a new MachineMemOperand by copying
1043 /// an existing one, adjusting by an offset and using the given size.
1044 /// MachineMemOperands are owned by the MachineFunction and need not be
1045 /// explicitly deallocated.
1046 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1047 int64_t Offset, LLT Ty);
1048 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1049 int64_t Offset, uint64_t Size) {
1050 return getMachineMemOperand(
1051 MMO, Offset, Ty: Size == ~UINT64_C(0) ? LLT() : LLT::scalar(SizeInBits: 8 * Size));
1052 }
1053
1054 /// getMachineMemOperand - Allocate a new MachineMemOperand by copying
1055 /// an existing one, replacing only the MachinePointerInfo and size.
1056 /// MachineMemOperands are owned by the MachineFunction and need not be
1057 /// explicitly deallocated.
1058 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1059 const MachinePointerInfo &PtrInfo,
1060 uint64_t Size);
1061 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1062 const MachinePointerInfo &PtrInfo,
1063 LLT Ty);
1064
1065 /// Allocate a new MachineMemOperand by copying an existing one,
1066 /// replacing only AliasAnalysis information. MachineMemOperands are owned
1067 /// by the MachineFunction and need not be explicitly deallocated.
1068 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1069 const AAMDNodes &AAInfo);
1070
1071 /// Allocate a new MachineMemOperand by copying an existing one,
1072 /// replacing the flags. MachineMemOperands are owned
1073 /// by the MachineFunction and need not be explicitly deallocated.
1074 MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
1075 MachineMemOperand::Flags Flags);
1076
1077 using OperandCapacity = ArrayRecycler<MachineOperand>::Capacity;
1078
1079 /// Allocate an array of MachineOperands. This is only intended for use by
1080 /// internal MachineInstr functions.
1081 MachineOperand *allocateOperandArray(OperandCapacity Cap) {
1082 return OperandRecycler.allocate(Cap, Allocator);
1083 }
1084
1085 /// Dellocate an array of MachineOperands and recycle the memory. This is
1086 /// only intended for use by internal MachineInstr functions.
1087 /// Cap must be the same capacity that was used to allocate the array.
1088 void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array) {
1089 OperandRecycler.deallocate(Cap, Ptr: Array);
1090 }
1091
1092 /// Allocate and initialize a register mask with @p NumRegister bits.
1093 uint32_t *allocateRegMask();
1094
1095 ArrayRef<int> allocateShuffleMask(ArrayRef<int> Mask);
1096
1097 /// Allocate and construct an extra info structure for a `MachineInstr`.
1098 ///
1099 /// This is allocated on the function's allocator and so lives the life of
1100 /// the function.
1101 MachineInstr::ExtraInfo *createMIExtraInfo(
1102 ArrayRef<MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol = nullptr,
1103 MCSymbol *PostInstrSymbol = nullptr, MDNode *HeapAllocMarker = nullptr,
1104 MDNode *PCSections = nullptr, uint32_t CFIType = 0);
1105
1106 /// Allocate a string and populate it with the given external symbol name.
1107 const char *createExternalSymbolName(StringRef Name);
1108
1109 //===--------------------------------------------------------------------===//
1110 // Label Manipulation.
1111
1112 /// getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
1113 /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
1114 /// normal 'L' label is returned.
1115 MCSymbol *getJTISymbol(unsigned JTI, MCContext &Ctx,
1116 bool isLinkerPrivate = false) const;
1117
1118 /// getPICBaseSymbol - Return a function-local symbol to represent the PIC
1119 /// base.
1120 MCSymbol *getPICBaseSymbol() const;
1121
1122 /// Returns a reference to a list of cfi instructions in the function's
1123 /// prologue. Used to construct frame maps for debug and exception handling
1124 /// comsumers.
1125 const std::vector<MCCFIInstruction> &getFrameInstructions() const {
1126 return FrameInstructions;
1127 }
1128
1129 [[nodiscard]] unsigned addFrameInst(const MCCFIInstruction &Inst);
1130
1131 /// Returns a reference to a list of symbols immediately following calls to
1132 /// _setjmp in the function. Used to construct the longjmp target table used
1133 /// by Windows Control Flow Guard.
1134 const std::vector<MCSymbol *> &getLongjmpTargets() const {
1135 return LongjmpTargets;
1136 }
1137
1138 /// Add the specified symbol to the list of valid longjmp targets for Windows
1139 /// Control Flow Guard.
1140 void addLongjmpTarget(MCSymbol *Target) { LongjmpTargets.push_back(x: Target); }
1141
1142 /// Returns a reference to a list of symbols that we have catchrets.
1143 /// Used to construct the catchret target table used by Windows EHCont Guard.
1144 const std::vector<MCSymbol *> &getCatchretTargets() const {
1145 return CatchretTargets;
1146 }
1147
1148 /// Add the specified symbol to the list of valid catchret targets for Windows
1149 /// EHCont Guard.
1150 void addCatchretTarget(MCSymbol *Target) {
1151 CatchretTargets.push_back(x: Target);
1152 }
1153
1154 /// \name Exception Handling
1155 /// \{
1156
1157 bool callsEHReturn() const { return CallsEHReturn; }
1158 void setCallsEHReturn(bool b) { CallsEHReturn = b; }
1159
1160 bool callsUnwindInit() const { return CallsUnwindInit; }
1161 void setCallsUnwindInit(bool b) { CallsUnwindInit = b; }
1162
1163 bool hasEHCatchret() const { return HasEHCatchret; }
1164 void setHasEHCatchret(bool V) { HasEHCatchret = V; }
1165
1166 bool hasEHScopes() const { return HasEHScopes; }
1167 void setHasEHScopes(bool V) { HasEHScopes = V; }
1168
1169 bool hasEHFunclets() const { return HasEHFunclets; }
1170 void setHasEHFunclets(bool V) { HasEHFunclets = V; }
1171
1172 bool isOutlined() const { return IsOutlined; }
1173 void setIsOutlined(bool V) { IsOutlined = V; }
1174
1175 /// Find or create an LandingPadInfo for the specified MachineBasicBlock.
1176 LandingPadInfo &getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad);
1177
1178 /// Return a reference to the landing pad info for the current function.
1179 const std::vector<LandingPadInfo> &getLandingPads() const {
1180 return LandingPads;
1181 }
1182
1183 /// Provide the begin and end labels of an invoke style call and associate it
1184 /// with a try landing pad block.
1185 void addInvoke(MachineBasicBlock *LandingPad,
1186 MCSymbol *BeginLabel, MCSymbol *EndLabel);
1187
1188 /// Add a new panding pad, and extract the exception handling information from
1189 /// the landingpad instruction. Returns the label ID for the landing pad
1190 /// entry.
1191 MCSymbol *addLandingPad(MachineBasicBlock *LandingPad);
1192
1193 /// Return the type id for the specified typeinfo. This is function wide.
1194 unsigned getTypeIDFor(const GlobalValue *TI);
1195
1196 /// Return the id of the filter encoded by TyIds. This is function wide.
1197 int getFilterIDFor(ArrayRef<unsigned> TyIds);
1198
1199 /// Map the landing pad's EH symbol to the call site indexes.
1200 void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef<unsigned> Sites);
1201
1202 /// Return if there is any wasm exception handling.
1203 bool hasAnyWasmLandingPadIndex() const {
1204 return !WasmLPadToIndexMap.empty();
1205 }
1206
1207 /// Map the landing pad to its index. Used for Wasm exception handling.
1208 void setWasmLandingPadIndex(const MachineBasicBlock *LPad, unsigned Index) {
1209 WasmLPadToIndexMap[LPad] = Index;
1210 }
1211
1212 /// Returns true if the landing pad has an associate index in wasm EH.
1213 bool hasWasmLandingPadIndex(const MachineBasicBlock *LPad) const {
1214 return WasmLPadToIndexMap.count(Val: LPad);
1215 }
1216
1217 /// Get the index in wasm EH for a given landing pad.
1218 unsigned getWasmLandingPadIndex(const MachineBasicBlock *LPad) const {
1219 assert(hasWasmLandingPadIndex(LPad));
1220 return WasmLPadToIndexMap.lookup(Val: LPad);
1221 }
1222
1223 bool hasAnyCallSiteLandingPad() const {
1224 return !LPadToCallSiteMap.empty();
1225 }
1226
1227 /// Get the call site indexes for a landing pad EH symbol.
1228 SmallVectorImpl<unsigned> &getCallSiteLandingPad(MCSymbol *Sym) {
1229 assert(hasCallSiteLandingPad(Sym) &&
1230 "missing call site number for landing pad!");
1231 return LPadToCallSiteMap[Sym];
1232 }
1233
1234 /// Return true if the landing pad Eh symbol has an associated call site.
1235 bool hasCallSiteLandingPad(MCSymbol *Sym) {
1236 return !LPadToCallSiteMap[Sym].empty();
1237 }
1238
1239 bool hasAnyCallSiteLabel() const {
1240 return !CallSiteMap.empty();
1241 }
1242
1243 /// Map the begin label for a call site.
1244 void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site) {
1245 CallSiteMap[BeginLabel] = Site;
1246 }
1247
1248 /// Get the call site number for a begin label.
1249 unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) const {
1250 assert(hasCallSiteBeginLabel(BeginLabel) &&
1251 "Missing call site number for EH_LABEL!");
1252 return CallSiteMap.lookup(Val: BeginLabel);
1253 }
1254
1255 /// Return true if the begin label has a call site number associated with it.
1256 bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) const {
1257 return CallSiteMap.count(Val: BeginLabel);
1258 }
1259
1260 /// Record annotations associated with a particular label.
1261 void addCodeViewAnnotation(MCSymbol *Label, MDNode *MD) {
1262 CodeViewAnnotations.push_back(x: {Label, MD});
1263 }
1264
1265 ArrayRef<std::pair<MCSymbol *, MDNode *>> getCodeViewAnnotations() const {
1266 return CodeViewAnnotations;
1267 }
1268
1269 /// Return a reference to the C++ typeinfo for the current function.
1270 const std::vector<const GlobalValue *> &getTypeInfos() const {
1271 return TypeInfos;
1272 }
1273
1274 /// Return a reference to the typeids encoding filters used in the current
1275 /// function.
1276 const std::vector<unsigned> &getFilterIds() const {
1277 return FilterIds;
1278 }
1279
1280 /// \}
1281
1282 /// Collect information used to emit debugging information of a variable in a
1283 /// stack slot.
1284 void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
1285 int Slot, const DILocation *Loc) {
1286 VariableDbgInfos.emplace_back(Args&: Var, Args&: Expr, Args&: Slot, Args&: Loc);
1287 }
1288
1289 /// Collect information used to emit debugging information of a variable in
1290 /// the entry value of a register.
1291 void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
1292 MCRegister Reg, const DILocation *Loc) {
1293 VariableDbgInfos.emplace_back(Args&: Var, Args&: Expr, Args&: Reg, Args&: Loc);
1294 }
1295
1296 VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfos; }
1297 const VariableDbgInfoMapTy &getVariableDbgInfo() const {
1298 return VariableDbgInfos;
1299 }
1300
1301 /// Returns the collection of variables for which we have debug info and that
1302 /// have been assigned a stack slot.
1303 auto getInStackSlotVariableDbgInfo() {
1304 return make_filter_range(Range&: getVariableDbgInfo(), Pred: [](auto &VarInfo) {
1305 return VarInfo.inStackSlot();
1306 });
1307 }
1308
1309 /// Returns the collection of variables for which we have debug info and that
1310 /// have been assigned a stack slot.
1311 auto getInStackSlotVariableDbgInfo() const {
1312 return make_filter_range(Range: getVariableDbgInfo(), Pred: [](const auto &VarInfo) {
1313 return VarInfo.inStackSlot();
1314 });
1315 }
1316
1317 /// Returns the collection of variables for which we have debug info and that
1318 /// have been assigned an entry value register.
1319 auto getEntryValueVariableDbgInfo() const {
1320 return make_filter_range(Range: getVariableDbgInfo(), Pred: [](const auto &VarInfo) {
1321 return VarInfo.inEntryValueRegister();
1322 });
1323 }
1324
1325 /// Start tracking the arguments passed to the call \p CallI.
1326 void addCallArgsForwardingRegs(const MachineInstr *CallI,
1327 CallSiteInfoImpl &&CallInfo) {
1328 assert(CallI->isCandidateForCallSiteEntry());
1329 bool Inserted =
1330 CallSitesInfo.try_emplace(Key: CallI, Args: std::move(CallInfo)).second;
1331 (void)Inserted;
1332 assert(Inserted && "Call site info not unique");
1333 }
1334
1335 const CallSiteInfoMap &getCallSitesInfo() const {
1336 return CallSitesInfo;
1337 }
1338
1339 /// Following functions update call site info. They should be called before
1340 /// removing, replacing or copying call instruction.
1341
1342 /// Erase the call site info for \p MI. It is used to remove a call
1343 /// instruction from the instruction stream.
1344 void eraseCallSiteInfo(const MachineInstr *MI);
1345 /// Copy the call site info from \p Old to \ New. Its usage is when we are
1346 /// making a copy of the instruction that will be inserted at different point
1347 /// of the instruction stream.
1348 void copyCallSiteInfo(const MachineInstr *Old,
1349 const MachineInstr *New);
1350
1351 /// Move the call site info from \p Old to \New call site info. This function
1352 /// is used when we are replacing one call instruction with another one to
1353 /// the same callee.
1354 void moveCallSiteInfo(const MachineInstr *Old,
1355 const MachineInstr *New);
1356
1357 unsigned getNewDebugInstrNum() {
1358 return ++DebugInstrNumberingCount;
1359 }
1360};
1361
1362//===--------------------------------------------------------------------===//
1363// GraphTraits specializations for function basic block graphs (CFGs)
1364//===--------------------------------------------------------------------===//
1365
1366// Provide specializations of GraphTraits to be able to treat a
1367// machine function as a graph of machine basic blocks... these are
1368// the same as the machine basic block iterators, except that the root
1369// node is implicitly the first node of the function.
1370//
1371template <> struct GraphTraits<MachineFunction*> :
1372 public GraphTraits<MachineBasicBlock*> {
1373 static NodeRef getEntryNode(MachineFunction *F) { return &F->front(); }
1374
1375 // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
1376 using nodes_iterator = pointer_iterator<MachineFunction::iterator>;
1377
1378 static nodes_iterator nodes_begin(MachineFunction *F) {
1379 return nodes_iterator(F->begin());
1380 }
1381
1382 static nodes_iterator nodes_end(MachineFunction *F) {
1383 return nodes_iterator(F->end());
1384 }
1385
1386 static unsigned size (MachineFunction *F) { return F->size(); }
1387};
1388template <> struct GraphTraits<const MachineFunction*> :
1389 public GraphTraits<const MachineBasicBlock*> {
1390 static NodeRef getEntryNode(const MachineFunction *F) { return &F->front(); }
1391
1392 // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
1393 using nodes_iterator = pointer_iterator<MachineFunction::const_iterator>;
1394
1395 static nodes_iterator nodes_begin(const MachineFunction *F) {
1396 return nodes_iterator(F->begin());
1397 }
1398
1399 static nodes_iterator nodes_end (const MachineFunction *F) {
1400 return nodes_iterator(F->end());
1401 }
1402
1403 static unsigned size (const MachineFunction *F) {
1404 return F->size();
1405 }
1406};
1407
1408// Provide specializations of GraphTraits to be able to treat a function as a
1409// graph of basic blocks... and to walk it in inverse order. Inverse order for
1410// a function is considered to be when traversing the predecessor edges of a BB
1411// instead of the successor edges.
1412//
1413template <> struct GraphTraits<Inverse<MachineFunction*>> :
1414 public GraphTraits<Inverse<MachineBasicBlock*>> {
1415 static NodeRef getEntryNode(Inverse<MachineFunction *> G) {
1416 return &G.Graph->front();
1417 }
1418};
1419template <> struct GraphTraits<Inverse<const MachineFunction*>> :
1420 public GraphTraits<Inverse<const MachineBasicBlock*>> {
1421 static NodeRef getEntryNode(Inverse<const MachineFunction *> G) {
1422 return &G.Graph->front();
1423 }
1424};
1425
1426void verifyMachineFunction(const std::string &Banner,
1427 const MachineFunction &MF);
1428
1429} // end namespace llvm
1430
1431#endif // LLVM_CODEGEN_MACHINEFUNCTION_H
1432

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