lib/Target/Alpha/AlphaRegisterInfo.cpp

   1 //===- AlphaRegisterInfo.cpp - Alpha Register Information ---*- C++ -*-----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains the Alpha implementation of the MRegisterInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "reginfo"
  15 #include "Alpha.h"
  16 #include "AlphaRegisterInfo.h"
  17 #include "llvm/Constants.h"
  18 #include "llvm/Type.h"
  19 #include "llvm/CodeGen/ValueTypes.h"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include "llvm/CodeGen/MachineFunction.h"
  22 #include "llvm/CodeGen/MachineFrameInfo.h"
  23 #include "llvm/Target/TargetFrameInfo.h"
  24 #include "llvm/Target/TargetMachine.h"
  25 #include "llvm/Target/TargetOptions.h"
  26 #include "llvm/Support/CommandLine.h"
  27 #include "llvm/Support/Debug.h"
  28 #include "llvm/ADT/STLExtras.h"
  29 #include <cstdlib>
  30 #include <iostream>
  31 using namespace llvm;
  32
  33
  34 AlphaRegisterInfo::AlphaRegisterInfo()
  35   : AlphaGenRegisterInfo(Alpha::ADJUSTSTACKDOWN, Alpha::ADJUSTSTACKUP)
  36 {
  37 }
  38
  39 static const TargetRegisterClass *getClass(unsigned SrcReg) {
  40   if (Alpha::FPRCRegisterClass->contains(SrcReg))
  41     return Alpha::FPRCRegisterClass;
  42   assert(Alpha::GPRCRegisterClass->contains(SrcReg) && "Reg not FPR or GPR");
  43   return Alpha::GPRCRegisterClass;
  44 }
  45
  46 void
  47 AlphaRegisterInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
  48                                        MachineBasicBlock::iterator MI,
  49                                        unsigned SrcReg, int FrameIdx) const {
  50   //std::cerr << "Trying to store " << getPrettyName(SrcReg) << " to " << FrameIdx << "\n";
  51   //BuildMI(MBB, MI, Alpha::WTF, 0).addReg(SrcReg);
  52   BuildMI(MBB, MI, Alpha::STQ, 3).addReg(SrcReg).addFrameIndex(FrameIdx).addReg(Alpha::F31);
  53   //  assert(0 && "TODO");
  54 }
  55
  56 void
  57 AlphaRegisterInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
  58                                         MachineBasicBlock::iterator MI,
  59                                         unsigned DestReg, int FrameIdx) const{
  60   //std::cerr << "Trying to load " << getPrettyName(DestReg) << " to " << FrameIdx << "\n";
  61   //BuildMI(MBB, MI, Alpha::WTF, 0, DestReg);
  62   BuildMI(MBB, MI, Alpha::LDQ, 2, DestReg).addFrameIndex(FrameIdx).addReg(Alpha::F31);
  63   //  assert(0 && "TODO");
  64 }
  65
  66 void AlphaRegisterInfo::copyRegToReg(MachineBasicBlock &MBB,
  67                                      MachineBasicBlock::iterator MI,
  68                                      unsigned DestReg, unsigned SrcReg,
  69                                      const TargetRegisterClass *RC) const {
  70   //  std::cerr << "copyRegToReg " << DestReg << " <- " << SrcReg << "\n";
  71   if (RC == Alpha::GPRCRegisterClass) {
  72     BuildMI(MBB, MI, Alpha::BIS, 2, DestReg).addReg(SrcReg).addReg(SrcReg);
  73   } else if (RC == Alpha::FPRCRegisterClass) {
  74     BuildMI(MBB, MI, Alpha::CPYS, 2, DestReg).addReg(SrcReg).addReg(SrcReg);
  75   } else {
  76     std::cerr << "Attempt to copy register that is not GPR or FPR";
  77      abort();
  78   }
  79 }
  80
  81 //===----------------------------------------------------------------------===//
  82 // Stack Frame Processing methods
  83 //===----------------------------------------------------------------------===//
  84
  85 // hasFP - Return true if the specified function should have a dedicated frame
  86 // pointer register.  This is true if the function has variable sized allocas or
  87 // if frame pointer elimination is disabled.
  88 //
  89 static bool hasFP(MachineFunction &MF) {
  90   MachineFrameInfo *MFI = MF.getFrameInfo();
  91   return MFI->hasVarSizedObjects();
  92 }
  93
  94 void AlphaRegisterInfo::
  95 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
  96                               MachineBasicBlock::iterator I) const {
  97   if (hasFP(MF)) {
  98     assert(0 && "TODO");
  99     // If we have a frame pointer, turn the adjcallstackup instruction into a
 100     // 'sub ESP, <amt>' and the adjcallstackdown instruction into 'add ESP,
 101     // <amt>'
 102     MachineInstr *Old = I;
 103     unsigned Amount = Old->getOperand(0).getImmedValue();
 104     if (Amount != 0) {
 105       // We need to keep the stack aligned properly.  To do this, we round the
 106       // amount of space needed for the outgoing arguments up to the next
 107       // alignment boundary.
 108       unsigned Align = MF.getTarget().getFrameInfo()->getStackAlignment();
 109       Amount = (Amount+Align-1)/Align*Align;
 110
 111 //    MachineInstr *New;
 112 //       if (Old->getOpcode() == X86::ADJCALLSTACKDOWN) {
 113 //      New=BuildMI(X86::SUB32ri, 1, X86::ESP, MachineOperand::UseAndDef)
 114 //               .addZImm(Amount);
 115 //       } else {
 116 //      assert(Old->getOpcode() == X86::ADJCALLSTACKUP);
 117 //      New=BuildMI(X86::ADD32ri, 1, X86::ESP, MachineOperand::UseAndDef)
 118 //               .addZImm(Amount);
 119 //       }
 120
 121       // Replace the pseudo instruction with a new instruction...
 122       MBB.insert(I, New);
 123     }
 124   }
 125
 126   MBB.erase(I);
 127 }
 128
 129 void
 130 AlphaRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II) const {
 131   unsigned i = 0;
 132   MachineInstr &MI = *II;
 133   MachineBasicBlock &MBB = *MI.getParent();
 134   MachineFunction &MF = *MBB.getParent();
 135
 136   while (!MI.getOperand(i).isFrameIndex()) {
 137     ++i;
 138     assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!");
 139   }
 140
 141   int FrameIndex = MI.getOperand(i).getFrameIndex();
 142
 143   // Add the base register of R30 (SP) or R15 (FP).
 144   MI.SetMachineOperandReg(i + 1, hasFP(MF) ? Alpha::R15 : Alpha::R30);
 145
 146   // Now add the frame object offset to the offset from r1.
 147   int Offset = MF.getFrameInfo()->getObjectOffset(FrameIndex);
 148
 149   // If we're not using a Frame Pointer that has been set to the value of the
 150   // SP before having the stack size subtracted from it, then add the stack size
 151   // to Offset to get the correct offset.
 152   Offset += MF.getFrameInfo()->getStackSize();
 153
 154    if (Offset > 32767 || Offset < -32768) {
 155      std::cerr << "Offset needs to be " << Offset << "\n";
 156      assert(0 && "stack too big");
 157    } else {
 158      MI.SetMachineOperandConst(i, MachineOperand::MO_SignExtendedImmed, Offset);
 159    }
 160 }
 161
 162
 163 void AlphaRegisterInfo::emitPrologue(MachineFunction &MF) const {
 164   MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
 165   MachineBasicBlock::iterator MBBI = MBB.begin();
 166   MachineFrameInfo *MFI = MF.getFrameInfo();
 167   MachineInstr *MI;
 168
 169   //handle GOP offset
 170   MI = BuildMI(Alpha::LDGP, 0);
 171   MBB.insert(MBBI, MI);
 172
 173   // Get the number of bytes to allocate from the FrameInfo
 174   unsigned NumBytes = MFI->getStackSize();
 175
 176   if (MFI->hasCalls()) {
 177     // We reserve argument space for call sites in the function immediately on
 178     // entry to the current function.  This eliminates the need for add/sub
 179     // brackets around call sites.
 180     NumBytes += MFI->getMaxCallFrameSize();
 181     std::cerr << "Added " << MFI->getMaxCallFrameSize() << " to the stack due to calls\n";
 182   }
 183
 184   // Do we need to allocate space on the stack?
 185   if (NumBytes == 0) return;
 186
 187   // Add the size of R30 to  NumBytes size for the store of R30 to the
 188   // stack
 189 //   std::cerr << "Spillsize of R30 is " << getSpillSize(Alpha::R30) << "\n";
 190 //   NumBytes = NumBytes + getSpillSize(Alpha::R30)/8;
 191
 192   // Update frame info to pretend that this is part of the stack...
 193   MFI->setStackSize(NumBytes);
 194
 195   // adjust stack pointer: r30 -= numbytes
 196
 197   if (NumBytes <= 32767) {
 198     MI=BuildMI(Alpha::LDA, 2, Alpha::R30).addImm(-NumBytes).addReg(Alpha::R30);
 199     MBB.insert(MBBI, MI);
 200   } else if ((unsigned long)NumBytes <= (unsigned long)32767 * (unsigned long)65536) {
 201     long y = NumBytes / 65536;
 202     if (NumBytes % 65536 > 32767)
 203       ++y;
 204     MI=BuildMI(Alpha::LDAH, 2, Alpha::R30).addImm(-y).addReg(Alpha::R30);
 205     MBB.insert(MBBI, MI);
 206     MI=BuildMI(Alpha::LDA, 2, Alpha::R30).addImm(-(NumBytes - y * 65536)).addReg(Alpha::R30);
 207     MBB.insert(MBBI, MI);
 208   } else {
 209     std::cerr << "Too big a stack frame at " << NumBytes << "\n";
 210     abort();
 211   }
 212 }
 213
 214 void AlphaRegisterInfo::emitEpilogue(MachineFunction &MF,
 215                                      MachineBasicBlock &MBB) const {
 216   const MachineFrameInfo *MFI = MF.getFrameInfo();
 217   MachineBasicBlock::iterator MBBI = prior(MBB.end());
 218   MachineInstr *MI;
 219   assert((MBBI->getOpcode() == Alpha::RET || MBBI->getOpcode() == Alpha::RETURN) &&
 220          "Can only insert epilog into returning blocks");
 221
 222   // Get the number of bytes allocated from the FrameInfo...
 223   unsigned NumBytes = MFI->getStackSize();
 224
 225    if (NumBytes != 0)
 226      {
 227        if (NumBytes <= 32767) {
 228          MI=BuildMI(Alpha::LDA, 2, Alpha::R30).addImm(NumBytes).addReg(Alpha::R30);
 229          MBB.insert(MBBI, MI);
 230        } else if ((unsigned long)NumBytes <= (unsigned long)32767 * (unsigned long)65536) {
 231          long y = NumBytes / 65536;
 232          if (NumBytes % 65536 > 32767)
 233            ++y;
 234          MI=BuildMI(Alpha::LDAH, 2, Alpha::R30).addImm(y).addReg(Alpha::R30);
 235          MBB.insert(MBBI, MI);
 236          MI=BuildMI(Alpha::LDA, 2, Alpha::R30).addImm(NumBytes - y * 65536).addReg(Alpha::R30);
 237          MBB.insert(MBBI, MI);
 238        } else {
 239          std::cerr << "Too big a stack frame at " << NumBytes << "\n";
 240          abort();
 241        }
 242      }
 243 }
 244
 245 #include "AlphaGenRegisterInfo.inc"
 246
 247 const TargetRegisterClass*
 248 AlphaRegisterInfo::getRegClassForType(const Type* Ty) const {
 249   switch (Ty->getTypeID()) {
 250     default:              assert(0 && "Invalid type to getClass!");
 251     case Type::BoolTyID:
 252     case Type::SByteTyID:
 253     case Type::UByteTyID:
 254     case Type::ShortTyID:
 255     case Type::UShortTyID:
 256     case Type::IntTyID:
 257     case Type::UIntTyID:
 258     case Type::PointerTyID:
 259     case Type::LongTyID:
 260     case Type::ULongTyID:  return &GPRCInstance;
 261
 262   case Type::FloatTyID:
 263   case Type::DoubleTyID: return &FPRCInstance;
 264   }
 265 }
 266
 267 std::string AlphaRegisterInfo::getPrettyName(unsigned reg)
 268 {
 269   std::string s(RegisterDescriptors[reg].Name);
 270   return s;
 271 }