LCOV - code coverage report
Current view: top level - lib/CodeGen - MachineFrameInfo.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 112 113 99.1 %
Date: 2018-06-17 00:07:59 Functions: 10 10 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- MachineFrameInfo.cpp ---------------------------------------------===//
       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             : /// \file Implements MachineFrameInfo that manages the stack frame.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/CodeGen/MachineFrameInfo.h"
      15             : 
      16             : #include "llvm/ADT/BitVector.h"
      17             : #include "llvm/CodeGen/MachineFunction.h"
      18             : #include "llvm/CodeGen/MachineRegisterInfo.h"
      19             : #include "llvm/CodeGen/TargetFrameLowering.h"
      20             : #include "llvm/CodeGen/TargetInstrInfo.h"
      21             : #include "llvm/CodeGen/TargetRegisterInfo.h"
      22             : #include "llvm/CodeGen/TargetSubtargetInfo.h"
      23             : #include "llvm/Config/llvm-config.h"
      24             : #include "llvm/Support/Debug.h"
      25             : #include "llvm/Support/raw_ostream.h"
      26             : #include <cassert>
      27             : 
      28             : #define DEBUG_TYPE "codegen"
      29             : 
      30             : using namespace llvm;
      31             : 
      32      447805 : void MachineFrameInfo::ensureMaxAlignment(unsigned Align) {
      33             :   if (!StackRealignable)
      34             :     assert(Align <= StackAlignment &&
      35             :            "For targets without stack realignment, Align is out of limit!");
      36      447805 :   if (MaxAlignment < Align) MaxAlignment = Align;
      37      447805 : }
      38             : 
      39             : /// Clamp the alignment if requested and emit a warning.
      40             : static inline unsigned clampStackAlignment(bool ShouldClamp, unsigned Align,
      41             :                                            unsigned StackAlign) {
      42      389546 :   if (!ShouldClamp || Align <= StackAlign)
      43             :     return Align;
      44             :   LLVM_DEBUG(dbgs() << "Warning: requested alignment " << Align
      45             :                     << " exceeds the stack alignment " << StackAlign
      46             :                     << " when stack realignment is off" << '\n');
      47             :   return StackAlign;
      48             : }
      49             : 
      50      214469 : int MachineFrameInfo::CreateStackObject(uint64_t Size, unsigned Alignment,
      51             :                                         bool IsSpillSlot,
      52             :                                         const AllocaInst *Alloca,
      53             :                                         uint8_t StackID) {
      54             :   assert(Size != 0 && "Cannot allocate zero size stack objects!");
      55      214469 :   Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
      56      428938 :   Objects.push_back(StackObject(Size, Alignment, 0, false, IsSpillSlot, Alloca,
      57      214469 :                                 !IsSpillSlot, StackID));
      58      428938 :   int Index = (int)Objects.size() - NumFixedObjects - 1;
      59             :   assert(Index >= 0 && "Bad frame index!");
      60      214469 :   ensureMaxAlignment(Alignment);
      61      214469 :   return Index;
      62             : }
      63             : 
      64       69655 : int MachineFrameInfo::CreateSpillStackObject(uint64_t Size,
      65             :                                              unsigned Alignment) {
      66       69655 :   Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
      67       69655 :   CreateStackObject(Size, Alignment, true);
      68      139310 :   int Index = (int)Objects.size() - NumFixedObjects - 1;
      69       69655 :   ensureMaxAlignment(Alignment);
      70       69655 :   return Index;
      71             : }
      72             : 
      73         482 : int MachineFrameInfo::CreateVariableSizedObject(unsigned Alignment,
      74             :                                                 const AllocaInst *Alloca) {
      75         482 :   HasVarSizedObjects = true;
      76         482 :   Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
      77         964 :   Objects.push_back(StackObject(0, Alignment, 0, false, false, Alloca, true));
      78         482 :   ensureMaxAlignment(Alignment);
      79         964 :   return (int)Objects.size()-NumFixedObjects-1;
      80             : }
      81             : 
      82       38134 : int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset,
      83             :                                         bool IsImmutable, bool IsAliased) {
      84             :   assert(Size != 0 && "Cannot allocate zero size fixed stack objects!");
      85             :   // The alignment of the frame index can be determined from its offset from
      86             :   // the incoming frame position.  If the frame object is at offset 32 and
      87             :   // the stack is guaranteed to be 16-byte aligned, then we know that the
      88             :   // object is 16-byte aligned. Note that unlike the non-fixed case, if the
      89             :   // stack needs realignment, we can't assume that the stack will in fact be
      90             :   // aligned.
      91       76268 :   unsigned Alignment = MinAlign(SPOffset, ForcedRealign ? 1 : StackAlignment);
      92       38134 :   Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
      93             :   Objects.insert(Objects.begin(),
      94       38134 :                  StackObject(Size, Alignment, SPOffset, IsImmutable,
      95             :                              /*isSpillSlot=*/false, /*Alloca=*/nullptr,
      96       38134 :                              IsAliased));
      97       38134 :   return -++NumFixedObjects;
      98             : }
      99             : 
     100       66806 : int MachineFrameInfo::CreateFixedSpillStackObject(uint64_t Size,
     101             :                                                   int64_t SPOffset,
     102             :                                                   bool IsImmutable) {
     103      133612 :   unsigned Alignment = MinAlign(SPOffset, ForcedRealign ? 1 : StackAlignment);
     104       66806 :   Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
     105             :   Objects.insert(Objects.begin(),
     106       66806 :                  StackObject(Size, Alignment, SPOffset, IsImmutable,
     107             :                              /*IsSpillSlot=*/true, /*Alloca=*/nullptr,
     108       66806 :                              /*IsAliased=*/false));
     109       66806 :   return -++NumFixedObjects;
     110             : }
     111             : 
     112     1959698 : BitVector MachineFrameInfo::getPristineRegs(const MachineFunction &MF) const {
     113     1959698 :   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
     114     1959698 :   BitVector BV(TRI->getNumRegs());
     115             : 
     116             :   // Before CSI is calculated, no registers are considered pristine. They can be
     117             :   // freely used and PEI will make sure they are saved.
     118     1959698 :   if (!isCalleeSavedInfoValid())
     119             :     return BV;
     120             : 
     121      700420 :   const MachineRegisterInfo &MRI = MF.getRegInfo();
     122    16120098 :   for (const MCPhysReg *CSR = MRI.getCalleeSavedRegs(); CSR && *CSR;
     123             :        ++CSR)
     124    15419678 :     BV.set(*CSR);
     125             : 
     126             :   // Saved CSRs are not pristine.
     127      700420 :   for (auto &I : getCalleeSavedInfo())
     128     2781059 :     for (MCSubRegIterator S(I.getReg(), TRI, true); S.isValid(); ++S)
     129             :       BV.reset(*S);
     130             : 
     131             :   return BV;
     132             : }
     133             : 
     134       82637 : unsigned MachineFrameInfo::estimateStackSize(const MachineFunction &MF) const {
     135       82637 :   const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
     136       82637 :   const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
     137       82637 :   unsigned MaxAlign = getMaxAlignment();
     138             :   int Offset = 0;
     139             : 
     140             :   // This code is very, very similar to PEI::calculateFrameObjectOffsets().
     141             :   // It really should be refactored to share code. Until then, changes
     142             :   // should keep in mind that there's tight coupling between the two.
     143             : 
     144      187722 :   for (int i = getObjectIndexBegin(); i != 0; ++i) {
     145       11224 :     int FixedOff = -getObjectOffset(i);
     146       11224 :     if (FixedOff > Offset) Offset = FixedOff;
     147             :   }
     148      192249 :   for (unsigned i = 0, e = getObjectIndexEnd(); i != e; ++i) {
     149       54806 :     if (isDeadObjectIndex(i))
     150         318 :       continue;
     151       54488 :     Offset += getObjectSize(i);
     152       54488 :     unsigned Align = getObjectAlignment(i);
     153             :     // Adjust to alignment boundary
     154       54488 :     Offset = (Offset+Align-1)/Align*Align;
     155             : 
     156       54488 :     MaxAlign = std::max(Align, MaxAlign);
     157             :   }
     158             : 
     159       82637 :   if (adjustsStack() && TFI->hasReservedCallFrame(MF))
     160        9580 :     Offset += getMaxCallFrameSize();
     161             : 
     162             :   // Round up the size to a multiple of the alignment.  If the function has
     163             :   // any calls or alloca's, align to the target's StackAlignment value to
     164             :   // ensure that the callee's frame or the alloca data is suitably aligned;
     165             :   // otherwise, for leaf functions, align to the TransientStackAlignment
     166             :   // value.
     167             :   unsigned StackAlign;
     168      155436 :   if (adjustsStack() || hasVarSizedObjects() ||
     169       73421 :       (RegInfo->needsStackRealignment(MF) && getObjectIndexEnd() != 0))
     170       10401 :     StackAlign = TFI->getStackAlignment();
     171             :   else
     172       72236 :     StackAlign = TFI->getTransientStackAlignment();
     173             : 
     174             :   // If the frame pointer is eliminated, all frame offsets will be relative to
     175             :   // SP not FP. Align to MaxAlign so this works.
     176       82637 :   StackAlign = std::max(StackAlign, MaxAlign);
     177       82637 :   unsigned AlignMask = StackAlign - 1;
     178       82637 :   Offset = (Offset + AlignMask) & ~uint64_t(AlignMask);
     179             : 
     180       82637 :   return (unsigned)Offset;
     181             : }
     182             : 
     183       28977 : void MachineFrameInfo::computeMaxCallFrameSize(const MachineFunction &MF) {
     184       28977 :   const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
     185       28977 :   unsigned FrameSetupOpcode = TII.getCallFrameSetupOpcode();
     186       28977 :   unsigned FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
     187             :   assert(FrameSetupOpcode != ~0u && FrameDestroyOpcode != ~0u &&
     188             :          "Can only compute MaxCallFrameSize if Setup/Destroy opcode are known");
     189             : 
     190       28977 :   MaxCallFrameSize = 0;
     191       65242 :   for (const MachineBasicBlock &MBB : MF) {
     192      385418 :     for (const MachineInstr &MI : MBB) {
     193      312888 :       unsigned Opcode = MI.getOpcode();
     194      312888 :       if (Opcode == FrameSetupOpcode || Opcode == FrameDestroyOpcode) {
     195       18532 :         unsigned Size = TII.getFrameSize(MI);
     196       37064 :         MaxCallFrameSize = std::max(MaxCallFrameSize, Size);
     197       18532 :         AdjustsStack = true;
     198      294356 :       } else if (MI.isInlineAsm()) {
     199             :         // Some inline asm's need a stack frame, as indicated by operand 1.
     200        3665 :         unsigned ExtraInfo = MI.getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
     201        3665 :         if (ExtraInfo & InlineAsm::Extra_IsAlignStack)
     202           1 :           AdjustsStack = true;
     203             :       }
     204             :     }
     205             :   }
     206       28977 : }
     207             : 
     208        1691 : void MachineFrameInfo::print(const MachineFunction &MF, raw_ostream &OS) const{
     209        1691 :   if (Objects.empty()) return;
     210             : 
     211         278 :   const TargetFrameLowering *FI = MF.getSubtarget().getFrameLowering();
     212         278 :   int ValOffset = (FI ? FI->getOffsetOfLocalArea() : 0);
     213             : 
     214         278 :   OS << "Frame Objects:\n";
     215             : 
     216        1139 :   for (unsigned i = 0, e = Objects.size(); i != e; ++i) {
     217         583 :     const StackObject &SO = Objects[i];
     218        1166 :     OS << "  fi#" << (int)(i-NumFixedObjects) << ": ";
     219             : 
     220         583 :     if (SO.StackID != 0)
     221           0 :       OS << "id=" << static_cast<unsigned>(SO.StackID) << ' ';
     222             : 
     223         584 :     if (SO.Size == ~0ULL) {
     224           1 :       OS << "dead\n";
     225           1 :       continue;
     226             :     }
     227         582 :     if (SO.Size == 0)
     228           1 :       OS << "variable sized";
     229             :     else
     230         581 :       OS << "size=" << SO.Size;
     231         582 :     OS << ", align=" << SO.Alignment;
     232             : 
     233         582 :     if (i < NumFixedObjects)
     234          21 :       OS << ", fixed";
     235         582 :     if (i < NumFixedObjects || SO.SPOffset != -1) {
     236         582 :       int64_t Off = SO.SPOffset - ValOffset;
     237         582 :       OS << ", at location [SP";
     238         582 :       if (Off > 0)
     239          27 :         OS << "+" << Off;
     240         555 :       else if (Off < 0)
     241         531 :         OS << Off;
     242         582 :       OS << "]";
     243             :     }
     244         582 :     OS << "\n";
     245             :   }
     246             : }
     247             : 
     248             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
     249             : LLVM_DUMP_METHOD void MachineFrameInfo::dump(const MachineFunction &MF) const {
     250             :   print(MF, dbgs());
     251             : }
     252             : #endif

Generated by: LCOV version 1.13