lib/CodeGen/LocalStackSlotAllocation.cpp

   1 //===- LocalStackSlotAllocation.cpp - Pre-allocate locals to stack slots --===//
   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 // This pass assigns local frame indices to stack slots relative to one another
  11 // and allocates additional base registers to access them when the target
  12 // estimates the are likely to be out of range of stack pointer and frame
  13 // pointer relative addressing.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #define DEBUG_TYPE "localstackalloc"
  18 #include "llvm/Constants.h"
  19 #include "llvm/DerivedTypes.h"
  20 #include "llvm/Instructions.h"
  21 #include "llvm/Intrinsics.h"
  22 #include "llvm/ADT/Statistic.h"
  23 #include "llvm/LLVMContext.h"
  24 #include "llvm/Module.h"
  25 #include "llvm/Pass.h"
  26 #include "llvm/ADT/SmallSet.h"
  27 #include "llvm/CodeGen/MachineFrameInfo.h"
  28 #include "llvm/CodeGen/MachineFunction.h"
  29 #include "llvm/CodeGen/MachineFunctionPass.h"
  30 #include "llvm/CodeGen/Passes.h"
  31 #include "llvm/Support/Debug.h"
  32 #include "llvm/Support/ErrorHandling.h"
  33 #include "llvm/Support/raw_ostream.h"
  34 #include "llvm/Target/TargetRegisterInfo.h"
  35 #include "llvm/Target/TargetFrameInfo.h"
  36
  37 using namespace llvm;
  38
  39 STATISTIC(NumAllocations, "Number of frame indices processed");
  40
  41 namespace {
  42   class LocalStackSlotPass: public MachineFunctionPass {
  43     int64_t LocalStackSize;
  44
  45     void calculateFrameObjectOffsets(MachineFunction &Fn);
  46   public:
  47     static char ID; // Pass identification, replacement for typeid
  48     explicit LocalStackSlotPass() : MachineFunctionPass(ID) { }
  49     bool runOnMachineFunction(MachineFunction &MF);
  50
  51     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  52       AU.setPreservesCFG();
  53       MachineFunctionPass::getAnalysisUsage(AU);
  54     }
  55     const char *getPassName() const {
  56       return "Local Stack Slot Allocation";
  57     }
  58
  59   private:
  60   };
  61 } // end anonymous namespace
  62
  63 char LocalStackSlotPass::ID = 0;
  64
  65 FunctionPass *llvm::createLocalStackSlotAllocationPass() {
  66   return new LocalStackSlotPass();
  67 }
  68
  69 bool LocalStackSlotPass::runOnMachineFunction(MachineFunction &MF) {
  70   calculateFrameObjectOffsets(MF);
  71   DEBUG(dbgs() << LocalStackSize << " bytes of local storage pre-allocated\n");
  72   return true;
  73 }
  74
  75 /// AdjustStackOffset - Helper function used to adjust the stack frame offset.
  76 static inline void
  77 AdjustStackOffset(MachineFrameInfo *MFI, int FrameIdx, int64_t &Offset,
  78                   unsigned &MaxAlign) {
  79   unsigned Align = MFI->getObjectAlignment(FrameIdx);
  80
  81   // If the alignment of this object is greater than that of the stack, then
  82   // increase the stack alignment to match.
  83   MaxAlign = std::max(MaxAlign, Align);
  84
  85   // Adjust to alignment boundary.
  86   Offset = (Offset + Align - 1) / Align * Align;
  87
  88   DEBUG(dbgs() << "Allocate FI(" << FrameIdx << ") to local offset "
  89         << Offset << "\n");
  90   MFI->mapLocalFrameObject(FrameIdx, Offset);
  91   Offset += MFI->getObjectSize(FrameIdx);
  92
  93   ++NumAllocations;
  94 }
  95
  96 /// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
  97 /// abstract stack objects.
  98 ///
  99 void LocalStackSlotPass::calculateFrameObjectOffsets(MachineFunction &Fn) {
 100   const TargetFrameInfo &TFI = *Fn.getTarget().getFrameInfo();
 101
 102   // Loop over all of the stack objects, assigning sequential addresses...
 103   MachineFrameInfo *MFI = Fn.getFrameInfo();
 104   int64_t Offset = 0;
 105   unsigned MaxAlign = MFI->getMaxAlignment();
 106
 107   // Make sure that the stack protector comes before the local variables on the
 108   // stack.
 109   SmallSet<int, 16> LargeStackObjs;
 110   if (MFI->getStackProtectorIndex() >= 0) {
 111     AdjustStackOffset(MFI, MFI->getStackProtectorIndex(), Offset, MaxAlign);
 112
 113     // Assign large stack objects first.
 114     for (unsigned i = 0, e = MFI->getObjectIndexEnd(); i != e; ++i) {
 115       if (MFI->isDeadObjectIndex(i))
 116         continue;
 117       if (MFI->getStackProtectorIndex() == (int)i)
 118         continue;
 119       if (!MFI->MayNeedStackProtector(i))
 120         continue;
 121
 122       AdjustStackOffset(MFI, i, Offset, MaxAlign);
 123       LargeStackObjs.insert(i);
 124     }
 125   }
 126
 127   // Then assign frame offsets to stack objects that are not used to spill
 128   // callee saved registers.
 129   for (unsigned i = 0, e = MFI->getObjectIndexEnd(); i != e; ++i) {
 130     if (MFI->isDeadObjectIndex(i))
 131       continue;
 132     if (MFI->getStackProtectorIndex() == (int)i)
 133       continue;
 134     if (LargeStackObjs.count(i))
 135       continue;
 136
 137     AdjustStackOffset(MFI, i, Offset, MaxAlign);
 138   }
 139
 140   const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo();
 141   if (!RegInfo->targetHandlesStackFrameRounding()) {
 142     // If we have reserved argument space for call sites in the function
 143     // immediately on entry to the current function, count it as part of the
 144     // overall stack size.
 145     if (MFI->adjustsStack() && RegInfo->hasReservedCallFrame(Fn))
 146       Offset += MFI->getMaxCallFrameSize();
 147
 148     // Round up the size to a multiple of the alignment.  If the function has
 149     // any calls or alloca's, align to the target's StackAlignment value to
 150     // ensure that the callee's frame or the alloca data is suitably aligned;
 151     // otherwise, for leaf functions, align to the TransientStackAlignment
 152     // value.
 153     unsigned StackAlign;
 154     if (MFI->adjustsStack() || MFI->hasVarSizedObjects() ||
 155         (RegInfo->needsStackRealignment(Fn) && MFI->getObjectIndexEnd() != 0))
 156       StackAlign = TFI.getStackAlignment();
 157     else
 158       StackAlign = TFI.getTransientStackAlignment();
 159
 160     // If the frame pointer is eliminated, all frame offsets will be relative to
 161     // SP not FP. Align to MaxAlign so this works.
 162     StackAlign = std::max(StackAlign, MaxAlign);
 163     unsigned AlignMask = StackAlign - 1;
 164     Offset = (Offset + AlignMask) & ~uint64_t(AlignMask);
 165   }
 166
 167   // Remember how big this blob of stack space is
 168   LocalStackSize = Offset;
 169 }