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 | |
44 | namespace llvm { |
45 | |
46 | class BasicBlock; |
47 | class BlockAddress; |
48 | class DataLayout; |
49 | class DebugLoc; |
50 | struct DenormalMode; |
51 | class DIExpression; |
52 | class DILocalVariable; |
53 | class DILocation; |
54 | class Function; |
55 | class GISelChangeObserver; |
56 | class GlobalValue; |
57 | class LLVMTargetMachine; |
58 | class MachineConstantPool; |
59 | class MachineFrameInfo; |
60 | class MachineFunction; |
61 | class MachineJumpTableInfo; |
62 | class MachineModuleInfo; |
63 | class MachineRegisterInfo; |
64 | class MCContext; |
65 | class MCInstrDesc; |
66 | class MCSymbol; |
67 | class MCSection; |
68 | class Pass; |
69 | class PseudoSourceValueManager; |
70 | class raw_ostream; |
71 | class SlotIndexes; |
72 | class StringRef; |
73 | class TargetRegisterClass; |
74 | class TargetSubtargetInfo; |
75 | struct WasmEHFuncInfo; |
76 | struct WinEHFuncInfo; |
77 | |
78 | template <> struct ilist_alloc_traits<MachineBasicBlock> { |
79 | void deleteNode(MachineBasicBlock *MBB); |
80 | }; |
81 | |
82 | template <> 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. |
96 | struct 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. |
129 | class 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 | |
135 | public: |
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 | |
233 | private: |
234 | BitVector Properties = |
235 | BitVector(static_cast<unsigned>(Property::LastProperty)+1); |
236 | }; |
237 | |
238 | struct 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. |
247 | struct 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 | |
259 | class 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 | |
410 | public: |
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 | |
488 | private: |
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 | |
505 | public: |
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 | // |
1371 | template <> 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 | }; |
1388 | template <> 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 | // |
1413 | template <> struct GraphTraits<Inverse<MachineFunction*>> : |
1414 | public GraphTraits<Inverse<MachineBasicBlock*>> { |
1415 | static NodeRef getEntryNode(Inverse<MachineFunction *> G) { |
1416 | return &G.Graph->front(); |
1417 | } |
1418 | }; |
1419 | template <> 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 | |
1426 | void verifyMachineFunction(const std::string &Banner, |
1427 | const MachineFunction &MF); |
1428 | |
1429 | } // end namespace llvm |
1430 | |
1431 | #endif // LLVM_CODEGEN_MACHINEFUNCTION_H |
1432 | |