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