contrib/llvm-project/llvm/lib/Target/PowerPC/PPCFrameLowering.h

   1 //===-- PPCFrameLowering.h - Define frame lowering for PowerPC --*- 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 //
  10 //===----------------------------------------------------------------------===//
  11
  12 #ifndef LLVM_LIB_TARGET_POWERPC_PPCFRAMELOWERING_H
  13 #define LLVM_LIB_TARGET_POWERPC_PPCFRAMELOWERING_H
  14
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/CodeGen/TargetFrameLowering.h"
  17 #include "llvm/Target/TargetMachine.h"
  18
  19 namespace llvm {
  20 class PPCSubtarget;
  21
  22 class PPCFrameLowering: public TargetFrameLowering {
  23   const PPCSubtarget &Subtarget;
  24   const unsigned ReturnSaveOffset;
  25   const unsigned TOCSaveOffset;
  26   const unsigned FramePointerSaveOffset;
  27   const unsigned LinkageSize;
  28   const unsigned BasePointerSaveOffset;
  29   const unsigned CRSaveOffset;
  30
  31   /**
  32    * Find register[s] that can be used in function prologue and epilogue
  33    *
  34    * Find register[s] that can be use as scratch register[s] in function
  35    * prologue and epilogue to save various registers (Link Register, Base
  36    * Pointer, etc.). Prefer R0/R12, if available. Otherwise choose whatever
  37    * register[s] are available.
  38    *
  39    * This method will return true if it is able to find enough unique scratch
  40    * registers (1 or 2 depending on the requirement). If it is unable to find
  41    * enough available registers in the block, it will return false and set
  42    * any passed output parameter that corresponds to a required unique register
  43    * to PPC::NoRegister.
  44    *
  45    * \param[in] MBB The machine basic block to find an available register for
  46    * \param[in] UseAtEnd Specify whether the scratch register will be used at
  47    *                     the end of the basic block (i.e., will the scratch
  48    *                     register kill a register defined in the basic block)
  49    * \param[in] TwoUniqueRegsRequired Specify whether this basic block will
  50    *                                  require two unique scratch registers.
  51    * \param[out] SR1 The scratch register to use
  52    * \param[out] SR2 The second scratch register. If this pointer is not null
  53    *                 the function will attempt to set it to an available
  54    *                 register regardless of whether there is a hard requirement
  55    *                 for two unique scratch registers.
  56    * \return true if the required number of registers was found.
  57    *         false if the required number of scratch register weren't available.
  58    *         If either output parameter refers to a required scratch register
  59    *         that isn't available, it will be set to an invalid value.
  60    */
  61   bool findScratchRegister(MachineBasicBlock *MBB,
  62                            bool UseAtEnd,
  63                            bool TwoUniqueRegsRequired = false,
  64                            Register *SR1 = nullptr,
  65                            Register *SR2 = nullptr) const;
  66   bool twoUniqueScratchRegsRequired(MachineBasicBlock *MBB) const;
  67
  68   /**
  69    * Create branch instruction for PPC::TCRETURN* (tail call return)
  70    *
  71    * \param[in] MBB that is terminated by PPC::TCRETURN*
  72    */
  73   void createTailCallBranchInstr(MachineBasicBlock &MBB) const;
  74
  75   /**
  76     * Check if the conditions are correct to allow for the stack update
  77     * to be moved past the CSR save/restore code.
  78     */
  79   bool stackUpdateCanBeMoved(MachineFunction &MF) const;
  80
  81 public:
  82   PPCFrameLowering(const PPCSubtarget &STI);
  83
  84   /**
  85    * Determine the frame layout and update the machine function.
  86    */
  87   unsigned determineFrameLayoutAndUpdate(MachineFunction &MF,
  88                                          bool UseEstimate = false) const;
  89
  90   /**
  91    * Determine the frame layout but do not update the machine function.
  92    * The MachineFunction object can be const in this case as it is not
  93    * modified.
  94    */
  95   unsigned determineFrameLayout(const MachineFunction &MF,
  96                                 bool UseEstimate = false,
  97                                 unsigned *NewMaxCallFrameSize = nullptr) const;
  98
  99   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
 100   /// the function.
 101   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
 102   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
 103   void inlineStackProbe(MachineFunction &MF,
 104                         MachineBasicBlock &PrologMBB) const override;
 105
 106   bool hasFP(const MachineFunction &MF) const override;
 107   bool needsFP(const MachineFunction &MF) const;
 108   void replaceFPWithRealFP(MachineFunction &MF) const;
 109
 110   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
 111                             RegScavenger *RS = nullptr) const override;
 112   void processFunctionBeforeFrameFinalized(MachineFunction &MF,
 113                                      RegScavenger *RS = nullptr) const override;
 114   void addScavengingSpillSlot(MachineFunction &MF, RegScavenger *RS) const;
 115
 116   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
 117                                  MachineBasicBlock::iterator MI,
 118                                  ArrayRef<CalleeSavedInfo> CSI,
 119                                  const TargetRegisterInfo *TRI) const override;
 120   /// This function will assign callee saved gprs to volatile vector registers
 121   /// for prologue spills when applicable. It returns false if there are any
 122   /// registers which were not spilled to volatile vector registers.
 123   bool
 124   assignCalleeSavedSpillSlots(MachineFunction &MF,
 125                               const TargetRegisterInfo *TRI,
 126                               std::vector<CalleeSavedInfo> &CSI) const override;
 127
 128   MachineBasicBlock::iterator
 129   eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
 130                                 MachineBasicBlock::iterator I) const override;
 131
 132   bool
 133   restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
 134                               MachineBasicBlock::iterator MI,
 135                               MutableArrayRef<CalleeSavedInfo> CSI,
 136                               const TargetRegisterInfo *TRI) const override;
 137
 138   /// targetHandlesStackFrameRounding - Returns true if the target is
 139   /// responsible for rounding up the stack frame (probably at emitPrologue
 140   /// time).
 141   bool targetHandlesStackFrameRounding() const override { return true; }
 142
 143   /// getReturnSaveOffset - Return the previous frame offset to save the
 144   /// return address.
 145   unsigned getReturnSaveOffset() const { return ReturnSaveOffset; }
 146
 147   /// getTOCSaveOffset - Return the previous frame offset to save the
 148   /// TOC register -- 64-bit SVR4 ABI only.
 149   unsigned getTOCSaveOffset() const;
 150
 151   /// getFramePointerSaveOffset - Return the previous frame offset to save the
 152   /// frame pointer.
 153   unsigned getFramePointerSaveOffset() const;
 154
 155   /// getBasePointerSaveOffset - Return the previous frame offset to save the
 156   /// base pointer.
 157   unsigned getBasePointerSaveOffset() const;
 158
 159   /// getLinkageSize - Return the size of the PowerPC ABI linkage area.
 160   ///
 161   unsigned getLinkageSize() const { return LinkageSize; }
 162
 163   const SpillSlot *
 164   getCalleeSavedSpillSlots(unsigned &NumEntries) const override;
 165
 166   bool enableShrinkWrapping(const MachineFunction &MF) const override;
 167
 168   /// Methods used by shrink wrapping to determine if MBB can be used for the
 169   /// function prologue/epilogue.
 170   bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
 171   bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override;
 172 };
 173 } // End llvm namespace
 174
 175 #endif