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