lib/Target/MBlaze/MBlazeRegisterInfo.cpp

   1 //===-- MBlazeRegisterInfo.cpp - MBlaze Register Information --------------===//
   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 file contains the MBlaze implementation of the TargetRegisterInfo
  11 // class.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "mblaze-frame-info"
  16
  17 #include "MBlazeRegisterInfo.h"
  18 #include "MBlaze.h"
  19 #include "MBlazeMachineFunction.h"
  20 #include "MBlazeSubtarget.h"
  21 #include "llvm/ADT/BitVector.h"
  22 #include "llvm/ADT/STLExtras.h"
  23 #include "llvm/CodeGen/MachineFrameInfo.h"
  24 #include "llvm/CodeGen/MachineFunction.h"
  25 #include "llvm/CodeGen/MachineInstrBuilder.h"
  26 #include "llvm/CodeGen/ValueTypes.h"
  27 #include "llvm/IR/Constants.h"
  28 #include "llvm/IR/Function.h"
  29 #include "llvm/IR/Type.h"
  30 #include "llvm/Support/CommandLine.h"
  31 #include "llvm/Support/Debug.h"
  32 #include "llvm/Support/ErrorHandling.h"
  33 #include "llvm/Support/raw_ostream.h"
  34 #include "llvm/Target/TargetFrameLowering.h"
  35 #include "llvm/Target/TargetInstrInfo.h"
  36 #include "llvm/Target/TargetMachine.h"
  37 #include "llvm/Target/TargetOptions.h"
  38
  39 #define GET_REGINFO_TARGET_DESC
  40 #include "MBlazeGenRegisterInfo.inc"
  41
  42 using namespace llvm;
  43
  44 MBlazeRegisterInfo::
  45 MBlazeRegisterInfo(const MBlazeSubtarget &ST)
  46   : MBlazeGenRegisterInfo(MBlaze::R15), Subtarget(ST) {}
  47
  48 unsigned MBlazeRegisterInfo::getPICCallReg() {
  49   return MBlaze::R20;
  50 }
  51
  52 //===----------------------------------------------------------------------===//
  53 // Callee Saved Registers methods
  54 //===----------------------------------------------------------------------===//
  55
  56 /// MBlaze Callee Saved Registers
  57 const uint16_t* MBlazeRegisterInfo::
  58 getCalleeSavedRegs(const MachineFunction *MF) const {
  59   // MBlaze callee-save register range is R20 - R31
  60   static const uint16_t CalleeSavedRegs[] = {
  61     MBlaze::R20, MBlaze::R21, MBlaze::R22, MBlaze::R23,
  62     MBlaze::R24, MBlaze::R25, MBlaze::R26, MBlaze::R27,
  63     MBlaze::R28, MBlaze::R29, MBlaze::R30, MBlaze::R31,
  64     0
  65   };
  66
  67   return CalleeSavedRegs;
  68 }
  69
  70 BitVector MBlazeRegisterInfo::
  71 getReservedRegs(const MachineFunction &MF) const {
  72   BitVector Reserved(getNumRegs());
  73   Reserved.set(MBlaze::R0);
  74   Reserved.set(MBlaze::R1);
  75   Reserved.set(MBlaze::R2);
  76   Reserved.set(MBlaze::R13);
  77   Reserved.set(MBlaze::R14);
  78   Reserved.set(MBlaze::R15);
  79   Reserved.set(MBlaze::R16);
  80   Reserved.set(MBlaze::R17);
  81   Reserved.set(MBlaze::R18);
  82   Reserved.set(MBlaze::R19);
  83   return Reserved;
  84 }
  85
  86 // FrameIndex represent objects inside a abstract stack.
  87 // We must replace FrameIndex with an stack/frame pointer
  88 // direct reference.
  89 void MBlazeRegisterInfo::
  90 eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj,
  91                     unsigned FIOperandNum, RegScavenger *RS) const {
  92   MachineInstr &MI = *II;
  93   MachineFunction &MF = *MI.getParent()->getParent();
  94   MachineFrameInfo *MFI = MF.getFrameInfo();
  95   unsigned OFIOperandNum = FIOperandNum == 2 ? 1 : 2;
  96
  97   DEBUG(dbgs() << "\nFunction : " << MF.getName() << "\n";
  98         dbgs() << "<--------->\n" << MI);
  99
 100   int FrameIndex = MI.getOperand(FIOperandNum).getIndex();
 101   int stackSize  = MFI->getStackSize();
 102   int spOffset   = MFI->getObjectOffset(FrameIndex);
 103
 104   DEBUG(MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>();
 105         dbgs() << "FrameIndex : " << FrameIndex << "\n"
 106                << "spOffset   : " << spOffset << "\n"
 107                << "stackSize  : " << stackSize << "\n"
 108                << "isFixed    : " << MFI->isFixedObjectIndex(FrameIndex) << "\n"
 109                << "isLiveIn   : " << MBlazeFI->isLiveIn(FrameIndex) << "\n"
 110                << "isSpill    : " << MFI->isSpillSlotObjectIndex(FrameIndex)
 111                << "\n" );
 112
 113   // as explained on LowerFormalArguments, detect negative offsets
 114   // and adjust SPOffsets considering the final stack size.
 115   int Offset = (spOffset < 0) ? (stackSize - spOffset) : spOffset;
 116   Offset += MI.getOperand(OFIOperandNum).getImm();
 117
 118   DEBUG(dbgs() << "Offset     : " << Offset << "\n" << "<--------->\n");
 119
 120   MI.getOperand(OFIOperandNum).ChangeToImmediate(Offset);
 121   MI.getOperand(FIOperandNum).ChangeToRegister(getFrameRegister(MF), false);
 122 }
 123
 124 void MBlazeRegisterInfo::
 125 processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *) const {
 126   // Set the stack offset where GP must be saved/loaded from.
 127   MachineFrameInfo *MFI = MF.getFrameInfo();
 128   MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>();
 129   if (MBlazeFI->needGPSaveRestore())
 130     MFI->setObjectOffset(MBlazeFI->getGPFI(), MBlazeFI->getGPStackOffset());
 131 }
 132
 133 unsigned MBlazeRegisterInfo::getFrameRegister(const MachineFunction &MF) const {
 134   const TargetFrameLowering *TFI = MF.getTarget().getFrameLowering();
 135
 136   return TFI->hasFP(MF) ? MBlaze::R19 : MBlaze::R1;
 137 }
 138
 139 unsigned MBlazeRegisterInfo::getEHExceptionRegister() const {
 140   llvm_unreachable("What is the exception register");
 141 }
 142
 143 unsigned MBlazeRegisterInfo::getEHHandlerRegister() const {
 144   llvm_unreachable("What is the exception handler register");
 145 }