lib/Target/Mips/MipsMachineFunction.cpp

   1 //===-- MipsMachineFunctionInfo.cpp - Private data used for Mips ----------===//
   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 #include "MCTargetDesc/MipsBaseInfo.h"
  11 #include "MipsInstrInfo.h"
  12 #include "MipsMachineFunction.h"
  13 #include "MipsSubtarget.h"
  14 #include "MipsTargetMachine.h"
  15 #include "llvm/CodeGen/MachineInstrBuilder.h"
  16 #include "llvm/CodeGen/MachineRegisterInfo.h"
  17 #include "llvm/IR/Function.h"
  18 #include "llvm/Support/CommandLine.h"
  19 #include "llvm/Support/raw_ostream.h"
  20
  21 using namespace llvm;
  22
  23 static cl::opt<bool>
  24 FixGlobalBaseReg("mips-fix-global-base-reg", cl::Hidden, cl::init(true),
  25                  cl::desc("Always use $gp as the global base register."));
  26
  27 // class MipsCallEntry.
  28 MipsCallEntry::MipsCallEntry(StringRef N) {
  29 #ifndef NDEBUG
  30   Name = N;
  31   Val = nullptr;
  32 #endif
  33 }
  34
  35 MipsCallEntry::MipsCallEntry(const GlobalValue *V) {
  36 #ifndef NDEBUG
  37   Val = V;
  38 #endif
  39 }
  40
  41 bool MipsCallEntry::isConstant(const MachineFrameInfo *) const {
  42   return false;
  43 }
  44
  45 bool MipsCallEntry::isAliased(const MachineFrameInfo *) const {
  46   return false;
  47 }
  48
  49 bool MipsCallEntry::mayAlias(const MachineFrameInfo *) const {
  50   return false;
  51 }
  52
  53 void MipsCallEntry::printCustom(raw_ostream &O) const {
  54   O << "MipsCallEntry: ";
  55 #ifndef NDEBUG
  56   if (Val)
  57     O << Val->getName();
  58   else
  59     O << Name;
  60 #endif
  61 }
  62
  63 MipsFunctionInfo::~MipsFunctionInfo() {}
  64
  65 bool MipsFunctionInfo::globalBaseRegSet() const {
  66   return GlobalBaseReg;
  67 }
  68
  69 unsigned MipsFunctionInfo::getGlobalBaseReg() {
  70   // Return if it has already been initialized.
  71   if (GlobalBaseReg)
  72     return GlobalBaseReg;
  73
  74   MipsSubtarget const &STI =
  75       static_cast<const MipsSubtarget &>(MF.getSubtarget());
  76
  77   const TargetRegisterClass *RC =
  78       STI.inMips16Mode()
  79           ? &Mips::CPU16RegsRegClass
  80           : STI.inMicroMipsMode()
  81                 ? &Mips::GPRMM16RegClass
  82                 : static_cast<const MipsTargetMachine &>(MF.getTarget())
  83                           .getABI()
  84                           .IsN64()
  85                       ? &Mips::GPR64RegClass
  86                       : &Mips::GPR32RegClass;
  87   return GlobalBaseReg = MF.getRegInfo().createVirtualRegister(RC);
  88 }
  89
  90 bool MipsFunctionInfo::mips16SPAliasRegSet() const {
  91   return Mips16SPAliasReg;
  92 }
  93 unsigned MipsFunctionInfo::getMips16SPAliasReg() {
  94   // Return if it has already been initialized.
  95   if (Mips16SPAliasReg)
  96     return Mips16SPAliasReg;
  97
  98   const TargetRegisterClass *RC = &Mips::CPU16RegsRegClass;
  99   return Mips16SPAliasReg = MF.getRegInfo().createVirtualRegister(RC);
 100 }
 101
 102 void MipsFunctionInfo::createEhDataRegsFI() {
 103   for (int I = 0; I < 4; ++I) {
 104     const TargetRegisterClass *RC =
 105         static_cast<const MipsTargetMachine &>(MF.getTarget()).getABI().IsN64()
 106             ? &Mips::GPR64RegClass
 107             : &Mips::GPR32RegClass;
 108
 109     EhDataRegFI[I] = MF.getFrameInfo()->CreateStackObject(RC->getSize(),
 110         RC->getAlignment(), false);
 111   }
 112 }
 113
 114 bool MipsFunctionInfo::isEhDataRegFI(int FI) const {
 115   return CallsEhReturn && (FI == EhDataRegFI[0] || FI == EhDataRegFI[1]
 116                         || FI == EhDataRegFI[2] || FI == EhDataRegFI[3]);
 117 }
 118
 119 MachinePointerInfo MipsFunctionInfo::callPtrInfo(StringRef Name) {
 120   std::unique_ptr<const MipsCallEntry> &E = ExternalCallEntries[Name];
 121
 122   if (!E)
 123     E = llvm::make_unique<MipsCallEntry>(Name);
 124
 125   return MachinePointerInfo(E.get());
 126 }
 127
 128 MachinePointerInfo MipsFunctionInfo::callPtrInfo(const GlobalValue *Val) {
 129   std::unique_ptr<const MipsCallEntry> &E = GlobalCallEntries[Val];
 130
 131   if (!E)
 132     E = llvm::make_unique<MipsCallEntry>(Val);
 133
 134   return MachinePointerInfo(E.get());
 135 }
 136
 137 int MipsFunctionInfo::getMoveF64ViaSpillFI(const TargetRegisterClass *RC) {
 138   if (MoveF64ViaSpillFI == -1) {
 139     MoveF64ViaSpillFI = MF.getFrameInfo()->CreateStackObject(
 140         RC->getSize(), RC->getAlignment(), false);
 141   }
 142   return MoveF64ViaSpillFI;
 143 }
 144
 145 void MipsFunctionInfo::anchor() { }