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 "MipsMachineFunction.h"
  12 #include "MipsInstrInfo.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   for (StringMap<const MipsCallEntry *>::iterator
  65        I = ExternalCallEntries.begin(), E = ExternalCallEntries.end(); I != E;
  66        ++I)
  67     delete I->getValue();
  68
  69   for (const auto &Entry : GlobalCallEntries)
  70     delete Entry.second;
  71 }
  72
  73 bool MipsFunctionInfo::globalBaseRegSet() const {
  74   return GlobalBaseReg;
  75 }
  76
  77 unsigned MipsFunctionInfo::getGlobalBaseReg() {
  78   // Return if it has already been initialized.
  79   if (GlobalBaseReg)
  80     return GlobalBaseReg;
  81
  82   const TargetRegisterClass *RC =
  83       static_cast<const MipsSubtarget &>(MF.getSubtarget()).inMips16Mode()
  84           ? &Mips::CPU16RegsRegClass
  85           : static_cast<const MipsTargetMachine &>(MF.getTarget())
  86                     .getABI()
  87                     .IsN64()
  88                 ? &Mips::GPR64RegClass
  89                 : &Mips::GPR32RegClass;
  90   return GlobalBaseReg = MF.getRegInfo().createVirtualRegister(RC);
  91 }
  92
  93 bool MipsFunctionInfo::mips16SPAliasRegSet() const {
  94   return Mips16SPAliasReg;
  95 }
  96 unsigned MipsFunctionInfo::getMips16SPAliasReg() {
  97   // Return if it has already been initialized.
  98   if (Mips16SPAliasReg)
  99     return Mips16SPAliasReg;
 100
 101   const TargetRegisterClass *RC = &Mips::CPU16RegsRegClass;
 102   return Mips16SPAliasReg = MF.getRegInfo().createVirtualRegister(RC);
 103 }
 104
 105 void MipsFunctionInfo::createEhDataRegsFI() {
 106   for (int I = 0; I < 4; ++I) {
 107     const TargetRegisterClass *RC =
 108         static_cast<const MipsTargetMachine &>(MF.getTarget()).getABI().IsN64()
 109             ? &Mips::GPR64RegClass
 110             : &Mips::GPR32RegClass;
 111
 112     EhDataRegFI[I] = MF.getFrameInfo()->CreateStackObject(RC->getSize(),
 113         RC->getAlignment(), false);
 114   }
 115 }
 116
 117 bool MipsFunctionInfo::isEhDataRegFI(int FI) const {
 118   return CallsEhReturn && (FI == EhDataRegFI[0] || FI == EhDataRegFI[1]
 119                         || FI == EhDataRegFI[2] || FI == EhDataRegFI[3]);
 120 }
 121
 122 MachinePointerInfo MipsFunctionInfo::callPtrInfo(StringRef Name) {
 123   const MipsCallEntry *&E = ExternalCallEntries[Name];
 124
 125   if (!E)
 126     E = new MipsCallEntry(Name);
 127
 128   return MachinePointerInfo(E);
 129 }
 130
 131 MachinePointerInfo MipsFunctionInfo::callPtrInfo(const GlobalValue *Val) {
 132   const MipsCallEntry *&E = GlobalCallEntries[Val];
 133
 134   if (!E)
 135     E = new MipsCallEntry(Val);
 136
 137   return MachinePointerInfo(E);
 138 }
 139
 140 int MipsFunctionInfo::getMoveF64ViaSpillFI(const TargetRegisterClass *RC) {
 141   if (MoveF64ViaSpillFI == -1) {
 142     MoveF64ViaSpillFI = MF.getFrameInfo()->CreateStackObject(
 143         RC->getSize(), RC->getAlignment(), false);
 144   }
 145   return MoveF64ViaSpillFI;
 146 }
 147
 148 void MipsFunctionInfo::anchor() { }