LCOV - code coverage report
Current view: top level - include/llvm/CodeGen - MachineFunction.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 83 85 97.6 %
Date: 2017-09-14 15:23:50 Functions: 29 41 70.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/CodeGen/MachineFunction.h ---------------------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // Collect native machine code for a function.  This class contains a list of
      11             : // MachineBasicBlock instances that make up the current compiled function.
      12             : //
      13             : // This class also contains pointers to various classes which hold
      14             : // target-specific information about the generated code.
      15             : //
      16             : //===----------------------------------------------------------------------===//
      17             : 
      18             : #ifndef LLVM_CODEGEN_MACHINEFUNCTION_H
      19             : #define LLVM_CODEGEN_MACHINEFUNCTION_H
      20             : 
      21             : #include "llvm/ADT/ArrayRef.h"
      22             : #include "llvm/ADT/BitVector.h"
      23             : #include "llvm/ADT/DenseMap.h"
      24             : #include "llvm/ADT/GraphTraits.h"
      25             : #include "llvm/ADT/Optional.h"
      26             : #include "llvm/ADT/SmallVector.h"
      27             : #include "llvm/ADT/StringRef.h"
      28             : #include "llvm/ADT/ilist.h"
      29             : #include "llvm/ADT/iterator.h"
      30             : #include "llvm/Analysis/EHPersonalities.h"
      31             : #include "llvm/CodeGen/MachineBasicBlock.h"
      32             : #include "llvm/CodeGen/MachineInstr.h"
      33             : #include "llvm/CodeGen/MachineMemOperand.h"
      34             : #include "llvm/IR/DebugLoc.h"
      35             : #include "llvm/IR/Instructions.h"
      36             : #include "llvm/IR/Metadata.h"
      37             : #include "llvm/MC/MCDwarf.h"
      38             : #include "llvm/MC/MCSymbol.h"
      39             : #include "llvm/Support/Allocator.h"
      40             : #include "llvm/Support/ArrayRecycler.h"
      41             : #include "llvm/Support/AtomicOrdering.h"
      42             : #include "llvm/Support/Compiler.h"
      43             : #include "llvm/Support/ErrorHandling.h"
      44             : #include "llvm/Support/Recycler.h"
      45             : #include <cassert>
      46             : #include <cstdint>
      47             : #include <memory>
      48             : #include <utility>
      49             : #include <vector>
      50             : 
      51             : namespace llvm {
      52             : 
      53             : class BasicBlock;
      54             : class BlockAddress;
      55             : class DataLayout;
      56             : class DIExpression;
      57             : class DILocalVariable;
      58             : class DILocation;
      59             : class Function;
      60             : class GlobalValue;
      61             : class MachineConstantPool;
      62             : class MachineFrameInfo;
      63             : class MachineFunction;
      64             : class MachineJumpTableInfo;
      65             : class MachineModuleInfo;
      66             : class MachineRegisterInfo;
      67             : class MCContext;
      68             : class MCInstrDesc;
      69             : class Pass;
      70             : class PseudoSourceValueManager;
      71             : class raw_ostream;
      72             : class SlotIndexes;
      73             : class TargetMachine;
      74             : class TargetRegisterClass;
      75             : class TargetSubtargetInfo;
      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* MBB);
      84             :   void removeNodeFromList(MachineBasicBlock* MBB);
      85             : 
      86             :   template <class Iterator>
      87             :   void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator) {
      88           0 :     llvm_unreachable("Never transfer between lists");
      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             :   /// \brief 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 Ty>
     104      112284 :   static Ty *create(BumpPtrAllocator &Allocator, MachineFunction &MF) {
     105      256299 :     return new (Allocator.Allocate<Ty>()) Ty(MF);
     106             :   }
     107             : };
     108             : 
     109             : /// Properties which a MachineFunction may have at a given point in time.
     110             : /// Each of these has checking code in the MachineVerifier, and passes can
     111             : /// require that a property be set.
     112    38929933 : class MachineFunctionProperties {
     113             :   // Possible TODO: Allow targets to extend this (perhaps by allowing the
     114             :   // constructor to specify the size of the bit vector)
     115             :   // Possible TODO: Allow requiring the negative (e.g. VRegsAllocated could be
     116             :   // stated as the negative of "has vregs"
     117             : 
     118             : public:
     119             :   // The properties are stated in "positive" form; i.e. a pass could require
     120             :   // that the property hold, but not that it does not hold.
     121             : 
     122             :   // Property descriptions:
     123             :   // IsSSA: True when the machine function is in SSA form and virtual registers
     124             :   //  have a single def.
     125             :   // NoPHIs: The machine function does not contain any PHI instruction.
     126             :   // TracksLiveness: True when tracking register liveness accurately.
     127             :   //  While this property is set, register liveness information in basic block
     128             :   //  live-in lists and machine instruction operands (e.g. kill flags, implicit
     129             :   //  defs) is accurate. This means it can be used to change the code in ways
     130             :   //  that affect the values in registers, for example by the register
     131             :   //  scavenger.
     132             :   //  When this property is clear, liveness is no longer reliable.
     133             :   // NoVRegs: The machine function does not use any virtual registers.
     134             :   // Legalized: In GlobalISel: the MachineLegalizer ran and all pre-isel generic
     135             :   //  instructions have been legalized; i.e., all instructions are now one of:
     136             :   //   - generic and always legal (e.g., COPY)
     137             :   //   - target-specific
     138             :   //   - legal pre-isel generic instructions.
     139             :   // RegBankSelected: In GlobalISel: the RegBankSelect pass ran and all generic
     140             :   //  virtual registers have been assigned to a register bank.
     141             :   // Selected: In GlobalISel: the InstructionSelect pass ran and all pre-isel
     142             :   //  generic instructions have been eliminated; i.e., all instructions are now
     143             :   //  target-specific or non-pre-isel generic instructions (e.g., COPY).
     144             :   //  Since only pre-isel generic instructions can have generic virtual register
     145             :   //  operands, this also means that all generic virtual registers have been
     146             :   //  constrained to virtual registers (assigned to register classes) and that
     147             :   //  all sizes attached to them have been eliminated.
     148             :   enum class Property : unsigned {
     149             :     IsSSA,
     150             :     NoPHIs,
     151             :     TracksLiveness,
     152             :     NoVRegs,
     153             :     FailedISel,
     154             :     Legalized,
     155             :     RegBankSelected,
     156             :     Selected,
     157             :     LastProperty = Selected,
     158             :   };
     159             : 
     160             :   bool hasProperty(Property P) const {
     161   233701606 :     return Properties[static_cast<unsigned>(P)];
     162             :   }
     163             : 
     164             :   MachineFunctionProperties &set(Property P) {
     165     1427718 :     Properties.set(static_cast<unsigned>(P));
     166             :     return *this;
     167             :   }
     168             : 
     169             :   MachineFunctionProperties &reset(Property P) {
     170      635688 :     Properties.reset(static_cast<unsigned>(P));
     171             :     return *this;
     172             :   }
     173             : 
     174             :   /// Reset all the properties.
     175             :   MachineFunctionProperties &reset() {
     176      290826 :     Properties.reset();
     177             :     return *this;
     178             :   }
     179             : 
     180             :   MachineFunctionProperties &set(const MachineFunctionProperties &MFP) {
     181    14021500 :     Properties |= MFP.Properties;
     182             :     return *this;
     183             :   }
     184             : 
     185             :   MachineFunctionProperties &reset(const MachineFunctionProperties &MFP) {
     186    14021500 :     Properties.reset(MFP.Properties);
     187             :     return *this;
     188             :   }
     189             : 
     190             :   // Returns true if all properties set in V (i.e. required by a pass) are set
     191             :   // in this.
     192             :   bool verifyRequiredProperties(const MachineFunctionProperties &V) const {
     193             :     return !V.Properties.test(Properties);
     194             :   }
     195             : 
     196             :   /// Print the MachineFunctionProperties in human-readable form.
     197             :   void print(raw_ostream &OS) const;
     198             : 
     199             : private:
     200             :   BitVector Properties =
     201             :       BitVector(static_cast<unsigned>(Property::LastProperty)+1);
     202             : };
     203             : 
     204             : struct SEHHandler {
     205             :   /// Filter or finally function. Null indicates a catch-all.
     206             :   const Function *FilterOrFinally;
     207             : 
     208             :   /// Address of block to recover at. Null for a finally handler.
     209             :   const BlockAddress *RecoverBA;
     210             : };
     211             : 
     212             : /// This structure is used to retain landing pad info for the current function.
     213      575490 : struct LandingPadInfo {
     214             :   MachineBasicBlock *LandingPadBlock;      // Landing pad block.
     215             :   SmallVector<MCSymbol *, 1> BeginLabels;  // Labels prior to invoke.
     216             :   SmallVector<MCSymbol *, 1> EndLabels;    // Labels after invoke.
     217             :   SmallVector<SEHHandler, 1> SEHHandlers;  // SEH handlers active at this lpad.
     218             :   MCSymbol *LandingPadLabel = nullptr;     // Label at beginning of landing pad.
     219             :   std::vector<int> TypeIds;                // List of type ids (filters negative).
     220             : 
     221             :   explicit LandingPadInfo(MachineBasicBlock *MBB)
     222      108760 :       : LandingPadBlock(MBB) {}
     223             : };
     224             : 
     225             : class MachineFunction {
     226             :   const Function *Fn;
     227             :   const TargetMachine &Target;
     228             :   const TargetSubtargetInfo *STI;
     229             :   MCContext &Ctx;
     230             :   MachineModuleInfo &MMI;
     231             : 
     232             :   // RegInfo - Information about each register in use in the function.
     233             :   MachineRegisterInfo *RegInfo;
     234             : 
     235             :   // Used to keep track of target-specific per-machine function information for
     236             :   // the target implementation.
     237             :   MachineFunctionInfo *MFInfo;
     238             : 
     239             :   // Keep track of objects allocated on the stack.
     240             :   MachineFrameInfo *FrameInfo;
     241             : 
     242             :   // Keep track of constants which are spilled to memory
     243             :   MachineConstantPool *ConstantPool;
     244             : 
     245             :   // Keep track of jump tables for switch instructions
     246             :   MachineJumpTableInfo *JumpTableInfo;
     247             : 
     248             :   // Keeps track of Windows exception handling related data. This will be null
     249             :   // for functions that aren't using a funclet-based EH personality.
     250             :   WinEHFuncInfo *WinEHInfo = nullptr;
     251             : 
     252             :   // Function-level unique numbering for MachineBasicBlocks.  When a
     253             :   // MachineBasicBlock is inserted into a MachineFunction is it automatically
     254             :   // numbered and this vector keeps track of the mapping from ID's to MBB's.
     255             :   std::vector<MachineBasicBlock*> MBBNumbering;
     256             : 
     257             :   // Pool-allocate MachineFunction-lifetime and IR objects.
     258             :   BumpPtrAllocator Allocator;
     259             : 
     260             :   // Allocation management for instructions in function.
     261             :   Recycler<MachineInstr> InstructionRecycler;
     262             : 
     263             :   // Allocation management for operand arrays on instructions.
     264             :   ArrayRecycler<MachineOperand> OperandRecycler;
     265             : 
     266             :   // Allocation management for basic blocks in function.
     267             :   Recycler<MachineBasicBlock> BasicBlockRecycler;
     268             : 
     269             :   // List of machine basic blocks in function
     270             :   using BasicBlockListType = ilist<MachineBasicBlock>;
     271             :   BasicBlockListType BasicBlocks;
     272             : 
     273             :   /// FunctionNumber - This provides a unique ID for each function emitted in
     274             :   /// this translation unit.
     275             :   ///
     276             :   unsigned FunctionNumber;
     277             : 
     278             :   /// Alignment - The alignment of the function.
     279             :   unsigned Alignment;
     280             : 
     281             :   /// ExposesReturnsTwice - True if the function calls setjmp or related
     282             :   /// functions with attribute "returns twice", but doesn't have
     283             :   /// the attribute itself.
     284             :   /// This is used to limit optimizations which cannot reason
     285             :   /// about the control flow of such functions.
     286             :   bool ExposesReturnsTwice = false;
     287             : 
     288             :   /// True if the function includes any inline assembly.
     289             :   bool HasInlineAsm = false;
     290             : 
     291             :   /// True if any WinCFI instruction have been emitted in this function.
     292             :   Optional<bool> HasWinCFI;
     293             : 
     294             :   /// Current high-level properties of the IR of the function (e.g. is in SSA
     295             :   /// form or whether registers have been allocated)
     296             :   MachineFunctionProperties Properties;
     297             : 
     298             :   // Allocation management for pseudo source values.
     299             :   std::unique_ptr<PseudoSourceValueManager> PSVManager;
     300             : 
     301             :   /// List of moves done by a function's prolog.  Used to construct frame maps
     302             :   /// by debug and exception handling consumers.
     303             :   std::vector<MCCFIInstruction> FrameInstructions;
     304             : 
     305             :   /// \name Exception Handling
     306             :   /// \{
     307             : 
     308             :   /// List of LandingPadInfo describing the landing pad information.
     309             :   std::vector<LandingPadInfo> LandingPads;
     310             : 
     311             :   /// Map a landing pad's EH symbol to the call site indexes.
     312             :   DenseMap<MCSymbol*, SmallVector<unsigned, 4>> LPadToCallSiteMap;
     313             : 
     314             :   /// Map of invoke call site index values to associated begin EH_LABEL.
     315             :   DenseMap<MCSymbol*, unsigned> CallSiteMap;
     316             : 
     317             :   /// CodeView label annotations.
     318             :   std::vector<std::pair<MCSymbol *, MDNode *>> CodeViewAnnotations;
     319             : 
     320             :   bool CallsEHReturn = false;
     321             :   bool CallsUnwindInit = false;
     322             :   bool HasEHFunclets = false;
     323             : 
     324             :   /// List of C++ TypeInfo used.
     325             :   std::vector<const GlobalValue *> TypeInfos;
     326             : 
     327             :   /// List of typeids encoding filters used.
     328             :   std::vector<unsigned> FilterIds;
     329             : 
     330             :   /// List of the indices in FilterIds corresponding to filter terminators.
     331             :   std::vector<unsigned> FilterEnds;
     332             : 
     333             :   EHPersonality PersonalityTypeCache = EHPersonality::Unknown;
     334             : 
     335             :   /// \}
     336             : 
     337             :   /// Clear all the members of this MachineFunction, but the ones used
     338             :   /// to initialize again the MachineFunction.
     339             :   /// More specifically, this deallocates all the dynamically allocated
     340             :   /// objects and get rid of all the XXXInfo data structure, but keep
     341             :   /// unchanged the references to Fn, Target, MMI, and FunctionNumber.
     342             :   void clear();
     343             :   /// Allocate and initialize the different members.
     344             :   /// In particular, the XXXInfo data structure.
     345             :   /// \pre Fn, Target, MMI, and FunctionNumber are properly set.
     346             :   void init();
     347             : 
     348             : public:
     349             :   struct VariableDbgInfo {
     350             :     const DILocalVariable *Var;
     351             :     const DIExpression *Expr;
     352             :     unsigned Slot;
     353             :     const DILocation *Loc;
     354             : 
     355             :     VariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
     356             :                     unsigned Slot, const DILocation *Loc)
     357         561 :         : Var(Var), Expr(Expr), Slot(Slot), Loc(Loc) {}
     358             :   };
     359             :   using VariableDbgInfoMapTy = SmallVector<VariableDbgInfo, 4>;
     360             :   VariableDbgInfoMapTy VariableDbgInfos;
     361             : 
     362             :   MachineFunction(const Function *Fn, const TargetMachine &TM,
     363             :                   unsigned FunctionNum, MachineModuleInfo &MMI);
     364             :   MachineFunction(const MachineFunction &) = delete;
     365             :   MachineFunction &operator=(const MachineFunction &) = delete;
     366             :   ~MachineFunction();
     367             : 
     368             :   /// Reset the instance as if it was just created.
     369             :   void reset() {
     370          93 :     clear();
     371          93 :     init();
     372             :   }
     373             : 
     374             :   MachineModuleInfo &getMMI() const { return MMI; }
     375             :   MCContext &getContext() const { return Ctx; }
     376             : 
     377      638206 :   PseudoSourceValueManager &getPSVManager() const { return *PSVManager; }
     378             : 
     379             :   /// Return the DataLayout attached to the Module associated to this MF.
     380             :   const DataLayout &getDataLayout() const;
     381             : 
     382             :   /// getFunction - Return the LLVM function that this machine code represents
     383             :   const Function *getFunction() const { return Fn; }
     384             : 
     385             :   /// getName - Return the name of the corresponding LLVM function.
     386             :   StringRef getName() const;
     387             : 
     388             :   /// getFunctionNumber - Return a unique ID for the current function.
     389             :   unsigned getFunctionNumber() const { return FunctionNumber; }
     390             : 
     391             :   /// getTarget - Return the target machine this machine code is compiled with
     392             :   const TargetMachine &getTarget() const { return Target; }
     393             : 
     394             :   /// getSubtarget - Return the subtarget for which this machine code is being
     395             :   /// compiled.
     396             :   const TargetSubtargetInfo &getSubtarget() const { return *STI; }
     397       12313 :   void setSubtarget(const TargetSubtargetInfo *ST) { STI = ST; }
     398             : 
     399             :   /// getSubtarget - This method returns a pointer to the specified type of
     400             :   /// TargetSubtargetInfo.  In debug builds, it verifies that the object being
     401             :   /// returned is of the correct type.
     402             :   template<typename STC> const STC &getSubtarget() const {
     403             :     return *static_cast<const STC *>(STI);
     404             :   }
     405             : 
     406             :   /// getRegInfo - Return information about the registers currently in use.
     407             :   MachineRegisterInfo &getRegInfo() { return *RegInfo; }
     408             :   const MachineRegisterInfo &getRegInfo() const { return *RegInfo; }
     409             : 
     410             :   /// getFrameInfo - Return the frame info object for the current function.
     411             :   /// This object contains information about objects allocated on the stack
     412             :   /// frame of the current function in an abstract way.
     413             :   MachineFrameInfo &getFrameInfo() { return *FrameInfo; }
     414             :   const MachineFrameInfo &getFrameInfo() const { return *FrameInfo; }
     415             : 
     416             :   /// getJumpTableInfo - Return the jump table info object for the current
     417             :   /// function.  This object contains information about jump tables in the
     418             :   /// current function.  If the current function has no jump tables, this will
     419             :   /// return null.
     420             :   const MachineJumpTableInfo *getJumpTableInfo() const { return JumpTableInfo; }
     421             :   MachineJumpTableInfo *getJumpTableInfo() { return JumpTableInfo; }
     422             : 
     423             :   /// getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it
     424             :   /// does already exist, allocate one.
     425             :   MachineJumpTableInfo *getOrCreateJumpTableInfo(unsigned JTEntryKind);
     426             : 
     427             :   /// getConstantPool - Return the constant pool object for the current
     428             :   /// function.
     429             :   MachineConstantPool *getConstantPool() { return ConstantPool; }
     430             :   const MachineConstantPool *getConstantPool() const { return ConstantPool; }
     431             : 
     432             :   /// getWinEHFuncInfo - Return information about how the current function uses
     433             :   /// Windows exception handling. Returns null for functions that don't use
     434             :   /// funclets for exception handling.
     435             :   const WinEHFuncInfo *getWinEHFuncInfo() const { return WinEHInfo; }
     436             :   WinEHFuncInfo *getWinEHFuncInfo() { return WinEHInfo; }
     437             : 
     438             :   /// getAlignment - Return the alignment (log2, not bytes) of the function.
     439             :   unsigned getAlignment() const { return Alignment; }
     440             : 
     441             :   /// setAlignment - Set the alignment (log2, not bytes) of the function.
     442       17678 :   void setAlignment(unsigned A) { Alignment = A; }
     443             : 
     444             :   /// ensureAlignment - Make sure the function is at least 1 << A bytes aligned.
     445             :   void ensureAlignment(unsigned A) {
     446        1178 :     if (Alignment < A) Alignment = A;
     447             :   }
     448             : 
     449             :   /// exposesReturnsTwice - Returns true if the function calls setjmp or
     450             :   /// any other similar functions with attribute "returns twice" without
     451             :   /// having the attribute itself.
     452             :   bool exposesReturnsTwice() const {
     453             :     return ExposesReturnsTwice;
     454             :   }
     455             : 
     456             :   /// setCallsSetJmp - Set a flag that indicates if there's a call to
     457             :   /// a "returns twice" function.
     458             :   void setExposesReturnsTwice(bool B) {
     459      144502 :     ExposesReturnsTwice = B;
     460             :   }
     461             : 
     462             :   /// Returns true if the function contains any inline assembly.
     463             :   bool hasInlineAsm() const {
     464             :     return HasInlineAsm;
     465             :   }
     466             : 
     467             :   /// Set a flag that indicates that the function contains inline assembly.
     468             :   void setHasInlineAsm(bool B) {
     469      153214 :     HasInlineAsm = B;
     470             :   }
     471             : 
     472             :   bool hasWinCFI() const {
     473             :     assert(HasWinCFI.hasValue() && "HasWinCFI not set yet!");
     474        2096 :     return *HasWinCFI;
     475             :   }
     476      282708 :   void setHasWinCFI(bool v) { HasWinCFI = v; }
     477             : 
     478             :   /// Get the function properties
     479        1416 :   const MachineFunctionProperties &getProperties() const { return Properties; }
     480        2144 :   MachineFunctionProperties &getProperties() { return Properties; }
     481             : 
     482             :   /// getInfo - Keep track of various per-function pieces of information for
     483             :   /// backends that would like to do so.
     484             :   ///
     485             :   template<typename Ty>
     486     1385109 :   Ty *getInfo() {
     487     4997968 :     if (!MFInfo)
     488      173668 :       MFInfo = Ty::template create<Ty>(Allocator, *this);
     489     5020037 :     return static_cast<Ty*>(MFInfo);
     490             :   }
     491             : 
     492             :   template<typename Ty>
     493             :   const Ty *getInfo() const {
     494     3014062 :      return const_cast<MachineFunction*>(this)->getInfo<Ty>();
     495             :   }
     496             : 
     497             :   /// getBlockNumbered - MachineBasicBlocks are automatically numbered when they
     498             :   /// are inserted into the machine function.  The block number for a machine
     499             :   /// basic block can be found by using the MBB::getNumber method, this method
     500             :   /// provides the inverse mapping.
     501             :   MachineBasicBlock *getBlockNumbered(unsigned N) const {
     502             :     assert(N < MBBNumbering.size() && "Illegal block number");
     503             :     assert(MBBNumbering[N] && "Block was removed from the machine function!");
     504     9871182 :     return MBBNumbering[N];
     505             :   }
     506             : 
     507             :   /// Should we be emitting segmented stack stuff for the function
     508             :   bool shouldSplitStack() const;
     509             : 
     510             :   /// getNumBlockIDs - Return the number of MBB ID's allocated.
     511    14740224 :   unsigned getNumBlockIDs() const { return (unsigned)MBBNumbering.size(); }
     512             : 
     513             :   /// RenumberBlocks - This discards all of the MachineBasicBlock numbers and
     514             :   /// recomputes them.  This guarantees that the MBB numbers are sequential,
     515             :   /// dense, and match the ordering of the blocks within the function.  If a
     516             :   /// specific MachineBasicBlock is specified, only that block and those after
     517             :   /// it are renumbered.
     518             :   void RenumberBlocks(MachineBasicBlock *MBBFrom = nullptr);
     519             : 
     520             :   /// print - Print out the MachineFunction in a format suitable for debugging
     521             :   /// to the specified stream.
     522             :   void print(raw_ostream &OS, const SlotIndexes* = nullptr) const;
     523             : 
     524             :   /// viewCFG - This function is meant for use from the debugger.  You can just
     525             :   /// say 'call F->viewCFG()' and a ghostview window should pop up from the
     526             :   /// program, displaying the CFG of the current function with the code for each
     527             :   /// basic block inside.  This depends on there being a 'dot' and 'gv' program
     528             :   /// in your path.
     529             :   void viewCFG() const;
     530             : 
     531             :   /// viewCFGOnly - This function is meant for use from the debugger.  It works
     532             :   /// just like viewCFG, but it does not include the contents of basic blocks
     533             :   /// into the nodes, just the label.  If you are only interested in the CFG
     534             :   /// this can make the graph smaller.
     535             :   ///
     536             :   void viewCFGOnly() const;
     537             : 
     538             :   /// dump - Print the current MachineFunction to cerr, useful for debugger use.
     539             :   void dump() const;
     540             : 
     541             :   /// Run the current MachineFunction through the machine code verifier, useful
     542             :   /// for debugger use.
     543             :   /// \returns true if no problems were found.
     544             :   bool verify(Pass *p = nullptr, const char *Banner = nullptr,
     545             :               bool AbortOnError = true) const;
     546             : 
     547             :   // Provide accessors for the MachineBasicBlock list...
     548             :   using iterator = BasicBlockListType::iterator;
     549             :   using const_iterator = BasicBlockListType::const_iterator;
     550             :   using const_reverse_iterator = BasicBlockListType::const_reverse_iterator;
     551             :   using reverse_iterator = BasicBlockListType::reverse_iterator;
     552             : 
     553             :   /// Support for MachineBasicBlock::getNextNode().
     554             :   static BasicBlockListType MachineFunction::*
     555             :   getSublistAccess(MachineBasicBlock *) {
     556             :     return &MachineFunction::BasicBlocks;
     557             :   }
     558             : 
     559             :   /// addLiveIn - Add the specified physical register as a live-in value and
     560             :   /// create a corresponding virtual register for it.
     561             :   unsigned addLiveIn(unsigned PReg, const TargetRegisterClass *RC);
     562             : 
     563             :   //===--------------------------------------------------------------------===//
     564             :   // BasicBlock accessor functions.
     565             :   //
     566    17976888 :   iterator                 begin()       { return BasicBlocks.begin(); }
     567    14355636 :   const_iterator           begin() const { return BasicBlocks.begin(); }
     568    22062416 :   iterator                 end  ()       { return BasicBlocks.end();   }
     569    13089294 :   const_iterator           end  () const { return BasicBlocks.end();   }
     570             : 
     571      614018 :   reverse_iterator        rbegin()       { return BasicBlocks.rbegin(); }
     572        3932 :   const_reverse_iterator  rbegin() const { return BasicBlocks.rbegin(); }
     573      612832 :   reverse_iterator        rend  ()       { return BasicBlocks.rend();   }
     574             :   const_reverse_iterator  rend  () const { return BasicBlocks.rend();   }
     575             : 
     576     2089418 :   unsigned                  size() const { return (unsigned)BasicBlocks.size();}
     577     7866336 :   bool                     empty() const { return BasicBlocks.empty(); }
     578     8202462 :   const MachineBasicBlock &front() const { return BasicBlocks.front(); }
     579     4640456 :         MachineBasicBlock &front()       { return BasicBlocks.front(); }
     580      235980 :   const MachineBasicBlock & back() const { return BasicBlocks.back(); }
     581       46702 :         MachineBasicBlock & back()       { return BasicBlocks.back(); }
     582             : 
     583      565640 :   void push_back (MachineBasicBlock *MBB) { BasicBlocks.push_back (MBB); }
     584         544 :   void push_front(MachineBasicBlock *MBB) { BasicBlocks.push_front(MBB); }
     585             :   void insert(iterator MBBI, MachineBasicBlock *MBB) {
     586       44839 :     BasicBlocks.insert(MBBI, MBB);
     587             :   }
     588             :   void splice(iterator InsertPt, iterator MBBI) {
     589       35009 :     BasicBlocks.splice(InsertPt, BasicBlocks, MBBI);
     590             :   }
     591             :   void splice(iterator InsertPt, MachineBasicBlock *MBB) {
     592      160894 :     BasicBlocks.splice(InsertPt, BasicBlocks, MBB);
     593             :   }
     594             :   void splice(iterator InsertPt, iterator MBBI, iterator MBBE) {
     595           0 :     BasicBlocks.splice(InsertPt, BasicBlocks, MBBI, MBBE);
     596             :   }
     597             : 
     598             :   void remove(iterator MBBI) { BasicBlocks.remove(MBBI); }
     599        1684 :   void remove(MachineBasicBlock *MBBI) { BasicBlocks.remove(MBBI); }
     600          50 :   void erase(iterator MBBI) { BasicBlocks.erase(MBBI); }
     601       26164 :   void erase(MachineBasicBlock *MBBI) { BasicBlocks.erase(MBBI); }
     602             : 
     603             :   template <typename Comp>
     604             :   void sort(Comp comp) {
     605          67 :     BasicBlocks.sort(comp);
     606             :   }
     607             : 
     608             :   //===--------------------------------------------------------------------===//
     609             :   // Internal functions used to automatically number MachineBasicBlocks
     610             : 
     611             :   /// \brief Adds the MBB to the internal numbering. Returns the unique number
     612             :   /// assigned to the MBB.
     613             :   unsigned addToMBBNumbering(MachineBasicBlock *MBB) {
     614      305763 :     MBBNumbering.push_back(MBB);
     615      611526 :     return (unsigned)MBBNumbering.size()-1;
     616             :   }
     617             : 
     618             :   /// removeFromMBBNumbering - Remove the specific machine basic block from our
     619             :   /// tracker, this is only really to be used by the MachineBasicBlock
     620             :   /// implementation.
     621             :   void removeFromMBBNumbering(unsigned N) {
     622             :     assert(N < MBBNumbering.size() && "Illegal basic block #");
     623      611318 :     MBBNumbering[N] = nullptr;
     624             :   }
     625             : 
     626             :   /// CreateMachineInstr - Allocate a new MachineInstr. Use this instead
     627             :   /// of `new MachineInstr'.
     628             :   MachineInstr *CreateMachineInstr(const MCInstrDesc &MCID, const DebugLoc &DL,
     629             :                                    bool NoImp = false);
     630             : 
     631             :   /// Create a new MachineInstr which is a copy of \p Orig, identical in all
     632             :   /// ways except the instruction has no parent, prev, or next. Bundling flags
     633             :   /// are reset.
     634             :   ///
     635             :   /// Note: Clones a single instruction, not whole instruction bundles.
     636             :   /// Does not perform target specific adjustments; consider using
     637             :   /// TargetInstrInfo::duplicate() instead.
     638             :   MachineInstr *CloneMachineInstr(const MachineInstr *Orig);
     639             : 
     640             :   /// Clones instruction or the whole instruction bundle \p Orig and insert
     641             :   /// into \p MBB before \p InsertBefore.
     642             :   ///
     643             :   /// Note: Does not perform target specific adjustments; consider using
     644             :   /// TargetInstrInfo::duplicate() intead.
     645             :   MachineInstr &CloneMachineInstrBundle(MachineBasicBlock &MBB,
     646             :       MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig);
     647             : 
     648             :   /// DeleteMachineInstr - Delete the given MachineInstr.
     649             :   void DeleteMachineInstr(MachineInstr *MI);
     650             : 
     651             :   /// CreateMachineBasicBlock - Allocate a new MachineBasicBlock. Use this
     652             :   /// instead of `new MachineBasicBlock'.
     653             :   MachineBasicBlock *CreateMachineBasicBlock(const BasicBlock *bb = nullptr);
     654             : 
     655             :   /// DeleteMachineBasicBlock - Delete the given MachineBasicBlock.
     656             :   void DeleteMachineBasicBlock(MachineBasicBlock *MBB);
     657             : 
     658             :   /// getMachineMemOperand - Allocate a new MachineMemOperand.
     659             :   /// MachineMemOperands are owned by the MachineFunction and need not be
     660             :   /// explicitly deallocated.
     661             :   MachineMemOperand *getMachineMemOperand(
     662             :       MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, uint64_t s,
     663             :       unsigned base_alignment, const AAMDNodes &AAInfo = AAMDNodes(),
     664             :       const MDNode *Ranges = nullptr,
     665             :       SyncScope::ID SSID = SyncScope::System,
     666             :       AtomicOrdering Ordering = AtomicOrdering::NotAtomic,
     667             :       AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic);
     668             : 
     669             :   /// getMachineMemOperand - Allocate a new MachineMemOperand by copying
     670             :   /// an existing one, adjusting by an offset and using the given size.
     671             :   /// MachineMemOperands are owned by the MachineFunction and need not be
     672             :   /// explicitly deallocated.
     673             :   MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
     674             :                                           int64_t Offset, uint64_t Size);
     675             : 
     676             :   /// Allocate a new MachineMemOperand by copying an existing one,
     677             :   /// replacing only AliasAnalysis information. MachineMemOperands are owned
     678             :   /// by the MachineFunction and need not be explicitly deallocated.
     679             :   MachineMemOperand *getMachineMemOperand(const MachineMemOperand *MMO,
     680             :                                           const AAMDNodes &AAInfo);
     681             : 
     682             :   using OperandCapacity = ArrayRecycler<MachineOperand>::Capacity;
     683             : 
     684             :   /// Allocate an array of MachineOperands. This is only intended for use by
     685             :   /// internal MachineInstr functions.
     686             :   MachineOperand *allocateOperandArray(OperandCapacity Cap) {
     687     7768750 :     return OperandRecycler.allocate(Cap, Allocator);
     688             :   }
     689             : 
     690             :   /// Dellocate an array of MachineOperands and recycle the memory. This is
     691             :   /// only intended for use by internal MachineInstr functions.
     692             :   /// Cap must be the same capacity that was used to allocate the array.
     693             :   void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array) {
     694     9341440 :     OperandRecycler.deallocate(Cap, Array);
     695             :   }
     696             : 
     697             :   /// \brief Allocate and initialize a register mask with @p NumRegister bits.
     698         220 :   uint32_t *allocateRegisterMask(unsigned NumRegister) {
     699         220 :     unsigned Size = (NumRegister + 31) / 32;
     700         440 :     uint32_t *Mask = Allocator.Allocate<uint32_t>(Size);
     701        2426 :     for (unsigned i = 0; i != Size; ++i)
     702        2206 :       Mask[i] = 0;
     703         220 :     return Mask;
     704             :   }
     705             : 
     706             :   /// allocateMemRefsArray - Allocate an array to hold MachineMemOperand
     707             :   /// pointers.  This array is owned by the MachineFunction.
     708             :   MachineInstr::mmo_iterator allocateMemRefsArray(unsigned long Num);
     709             : 
     710             :   /// extractLoadMemRefs - Allocate an array and populate it with just the
     711             :   /// load information from the given MachineMemOperand sequence.
     712             :   std::pair<MachineInstr::mmo_iterator,
     713             :             MachineInstr::mmo_iterator>
     714             :     extractLoadMemRefs(MachineInstr::mmo_iterator Begin,
     715             :                        MachineInstr::mmo_iterator End);
     716             : 
     717             :   /// extractStoreMemRefs - Allocate an array and populate it with just the
     718             :   /// store information from the given MachineMemOperand sequence.
     719             :   std::pair<MachineInstr::mmo_iterator,
     720             :             MachineInstr::mmo_iterator>
     721             :     extractStoreMemRefs(MachineInstr::mmo_iterator Begin,
     722             :                         MachineInstr::mmo_iterator End);
     723             : 
     724             :   /// Allocate a string and populate it with the given external symbol name.
     725             :   const char *createExternalSymbolName(StringRef Name);
     726             : 
     727             :   //===--------------------------------------------------------------------===//
     728             :   // Label Manipulation.
     729             : 
     730             :   /// getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
     731             :   /// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
     732             :   /// normal 'L' label is returned.
     733             :   MCSymbol *getJTISymbol(unsigned JTI, MCContext &Ctx,
     734             :                          bool isLinkerPrivate = false) const;
     735             : 
     736             :   /// getPICBaseSymbol - Return a function-local symbol to represent the PIC
     737             :   /// base.
     738             :   MCSymbol *getPICBaseSymbol() const;
     739             : 
     740             :   /// Returns a reference to a list of cfi instructions in the function's
     741             :   /// prologue.  Used to construct frame maps for debug and exception handling
     742             :   /// comsumers.
     743             :   const std::vector<MCCFIInstruction> &getFrameInstructions() const {
     744             :     return FrameInstructions;
     745             :   }
     746             : 
     747             :   LLVM_NODISCARD unsigned addFrameInst(const MCCFIInstruction &Inst) {
     748      230572 :     FrameInstructions.push_back(Inst);
     749      461144 :     return FrameInstructions.size() - 1;
     750             :   }
     751             : 
     752             :   /// \name Exception Handling
     753             :   /// \{
     754             : 
     755             :   bool callsEHReturn() const { return CallsEHReturn; }
     756          29 :   void setCallsEHReturn(bool b) { CallsEHReturn = b; }
     757             : 
     758             :   bool callsUnwindInit() const { return CallsUnwindInit; }
     759          15 :   void setCallsUnwindInit(bool b) { CallsUnwindInit = b; }
     760             : 
     761             :   bool hasEHFunclets() const { return HasEHFunclets; }
     762         238 :   void setHasEHFunclets(bool V) { HasEHFunclets = V; }
     763             : 
     764             :   /// Find or create an LandingPadInfo for the specified MachineBasicBlock.
     765             :   LandingPadInfo &getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad);
     766             : 
     767             :   /// Remap landing pad labels and remove any deleted landing pads.
     768             :   void tidyLandingPads(DenseMap<MCSymbol*, uintptr_t> *LPMap = nullptr);
     769             : 
     770             :   /// Return a reference to the landing pad info for the current function.
     771             :   const std::vector<LandingPadInfo> &getLandingPads() const {
     772             :     return LandingPads;
     773             :   }
     774             : 
     775             :   /// Provide the begin and end labels of an invoke style call and associate it
     776             :   /// with a try landing pad block.
     777             :   void addInvoke(MachineBasicBlock *LandingPad,
     778             :                  MCSymbol *BeginLabel, MCSymbol *EndLabel);
     779             : 
     780             :   /// Add a new panding pad.  Returns the label ID for the landing pad entry.
     781             :   MCSymbol *addLandingPad(MachineBasicBlock *LandingPad);
     782             : 
     783             :   /// Provide the catch typeinfo for a landing pad.
     784             :   void addCatchTypeInfo(MachineBasicBlock *LandingPad,
     785             :                         ArrayRef<const GlobalValue *> TyInfo);
     786             : 
     787             :   /// Provide the filter typeinfo for a landing pad.
     788             :   void addFilterTypeInfo(MachineBasicBlock *LandingPad,
     789             :                          ArrayRef<const GlobalValue *> TyInfo);
     790             : 
     791             :   /// Add a cleanup action for a landing pad.
     792             :   void addCleanup(MachineBasicBlock *LandingPad);
     793             : 
     794             :   void addSEHCatchHandler(MachineBasicBlock *LandingPad, const Function *Filter,
     795             :                           const BlockAddress *RecoverLabel);
     796             : 
     797             :   void addSEHCleanupHandler(MachineBasicBlock *LandingPad,
     798             :                             const Function *Cleanup);
     799             : 
     800             :   /// Return the type id for the specified typeinfo.  This is function wide.
     801             :   unsigned getTypeIDFor(const GlobalValue *TI);
     802             : 
     803             :   /// Return the id of the filter encoded by TyIds.  This is function wide.
     804             :   int getFilterIDFor(std::vector<unsigned> &TyIds);
     805             : 
     806             :   /// Map the landing pad's EH symbol to the call site indexes.
     807             :   void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef<unsigned> Sites);
     808             : 
     809             :   /// Get the call site indexes for a landing pad EH symbol.
     810             :   SmallVectorImpl<unsigned> &getCallSiteLandingPad(MCSymbol *Sym) {
     811             :     assert(hasCallSiteLandingPad(Sym) &&
     812             :            "missing call site number for landing pad!");
     813         242 :     return LPadToCallSiteMap[Sym];
     814             :   }
     815             : 
     816             :   /// Return true if the landing pad Eh symbol has an associated call site.
     817             :   bool hasCallSiteLandingPad(MCSymbol *Sym) {
     818         242 :     return !LPadToCallSiteMap[Sym].empty();
     819             :   }
     820             : 
     821             :   /// Map the begin label for a call site.
     822             :   void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site) {
     823         330 :     CallSiteMap[BeginLabel] = Site;
     824             :   }
     825             : 
     826             :   /// Get the call site number for a begin label.
     827             :   unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) const {
     828             :     assert(hasCallSiteBeginLabel(BeginLabel) &&
     829             :            "Missing call site number for EH_LABEL!");
     830         330 :     return CallSiteMap.lookup(BeginLabel);
     831             :   }
     832             : 
     833             :   /// Return true if the begin label has a call site number associated with it.
     834             :   bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) const {
     835             :     return CallSiteMap.count(BeginLabel);
     836             :   }
     837             : 
     838             :   /// Record annotations associated with a particular label.
     839             :   void addCodeViewAnnotation(MCSymbol *Label, MDNode *MD) {
     840           3 :     CodeViewAnnotations.push_back({Label, MD});
     841             :   }
     842             : 
     843             :   ArrayRef<std::pair<MCSymbol *, MDNode *>> getCodeViewAnnotations() const {
     844         258 :     return CodeViewAnnotations;
     845             :   }
     846             : 
     847             :   /// Return a reference to the C++ typeinfo for the current function.
     848             :   const std::vector<const GlobalValue *> &getTypeInfos() const {
     849        4942 :     return TypeInfos;
     850             :   }
     851             : 
     852             :   /// Return a reference to the typeids encoding filters used in the current
     853             :   /// function.
     854             :   const std::vector<unsigned> &getFilterIds() const {
     855        4942 :     return FilterIds;
     856             :   }
     857             : 
     858             :   /// \}
     859             : 
     860             :   /// Collect information used to emit debugging information of a variable.
     861             :   void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
     862             :                           unsigned Slot, const DILocation *Loc) {
     863         561 :     VariableDbgInfos.emplace_back(Var, Expr, Slot, Loc);
     864             :   }
     865             : 
     866      138628 :   VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfos; }
     867             :   const VariableDbgInfoMapTy &getVariableDbgInfo() const {
     868             :     return VariableDbgInfos;
     869             :   }
     870             : };
     871             : 
     872             : /// \name Exception Handling
     873             : /// \{
     874             : 
     875             : /// Extract the exception handling information from the landingpad instruction
     876             : /// and add them to the specified machine module info.
     877             : void addLandingPadInfo(const LandingPadInst &I, MachineBasicBlock &MBB);
     878             : 
     879             : /// \}
     880             : 
     881             : //===--------------------------------------------------------------------===//
     882             : // GraphTraits specializations for function basic block graphs (CFGs)
     883             : //===--------------------------------------------------------------------===//
     884             : 
     885             : // Provide specializations of GraphTraits to be able to treat a
     886             : // machine function as a graph of machine basic blocks... these are
     887             : // the same as the machine basic block iterators, except that the root
     888             : // node is implicitly the first node of the function.
     889             : //
     890             : template <> struct GraphTraits<MachineFunction*> :
     891             :   public GraphTraits<MachineBasicBlock*> {
     892     1236887 :   static NodeRef getEntryNode(MachineFunction *F) { return &F->front(); }
     893             : 
     894             :   // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
     895             :   using nodes_iterator = pointer_iterator<MachineFunction::iterator>;
     896             : 
     897             :   static nodes_iterator nodes_begin(MachineFunction *F) {
     898      838114 :     return nodes_iterator(F->begin());
     899             :   }
     900             : 
     901             :   static nodes_iterator nodes_end(MachineFunction *F) {
     902      829886 :     return nodes_iterator(F->end());
     903             :   }
     904             : 
     905             :   static unsigned       size       (MachineFunction *F) { return F->size(); }
     906             : };
     907             : template <> struct GraphTraits<const MachineFunction*> :
     908             :   public GraphTraits<const MachineBasicBlock*> {
     909     1130414 :   static NodeRef getEntryNode(const MachineFunction *F) { return &F->front(); }
     910             : 
     911             :   // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
     912             :   using nodes_iterator = pointer_iterator<MachineFunction::const_iterator>;
     913             : 
     914             :   static nodes_iterator nodes_begin(const MachineFunction *F) {
     915             :     return nodes_iterator(F->begin());
     916             :   }
     917             : 
     918             :   static nodes_iterator nodes_end  (const MachineFunction *F) {
     919             :     return nodes_iterator(F->end());
     920             :   }
     921             : 
     922             :   static unsigned       size       (const MachineFunction *F)  {
     923             :     return F->size();
     924             :   }
     925             : };
     926             : 
     927             : // Provide specializations of GraphTraits to be able to treat a function as a
     928             : // graph of basic blocks... and to walk it in inverse order.  Inverse order for
     929             : // a function is considered to be when traversing the predecessor edges of a BB
     930             : // instead of the successor edges.
     931             : //
     932             : template <> struct GraphTraits<Inverse<MachineFunction*>> :
     933             :   public GraphTraits<Inverse<MachineBasicBlock*>> {
     934             :   static NodeRef getEntryNode(Inverse<MachineFunction *> G) {
     935             :     return &G.Graph->front();
     936             :   }
     937             : };
     938             : template <> struct GraphTraits<Inverse<const MachineFunction*>> :
     939             :   public GraphTraits<Inverse<const MachineBasicBlock*>> {
     940             :   static NodeRef getEntryNode(Inverse<const MachineFunction *> G) {
     941             :     return &G.Graph->front();
     942             :   }
     943             : };
     944             : 
     945             : } // end namespace llvm
     946             : 
     947             : #endif // LLVM_CODEGEN_MACHINEFUNCTION_H

Generated by: LCOV version 1.13