contrib/llvm-project/llvm/lib/Target/VE/VERegisterInfo.cpp

   1 //===-- VERegisterInfo.cpp - VE Register Information ----------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file contains the VE implementation of the TargetRegisterInfo class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "VERegisterInfo.h"
  14 #include "VE.h"
  15 #include "VESubtarget.h"
  16 #include "llvm/ADT/BitVector.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/CodeGen/MachineFrameInfo.h"
  19 #include "llvm/CodeGen/MachineFunction.h"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include "llvm/CodeGen/MachineRegisterInfo.h"
  22 #include "llvm/CodeGen/TargetInstrInfo.h"
  23 #include "llvm/IR/Type.h"
  24 #include "llvm/Support/CommandLine.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26
  27 using namespace llvm;
  28
  29 #define GET_REGINFO_TARGET_DESC
  30 #include "VEGenRegisterInfo.inc"
  31
  32 // VE uses %s10 == %lp to keep return address
  33 VERegisterInfo::VERegisterInfo() : VEGenRegisterInfo(VE::SX10) {}
  34
  35 const MCPhysReg *
  36 VERegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
  37   return CSR_SaveList;
  38 }
  39
  40 const uint32_t *VERegisterInfo::getCallPreservedMask(const MachineFunction &MF,
  41                                                      CallingConv::ID CC) const {
  42   return CSR_RegMask;
  43 }
  44
  45 const uint32_t *VERegisterInfo::getNoPreservedMask() const {
  46   return CSR_NoRegs_RegMask;
  47 }
  48
  49 BitVector VERegisterInfo::getReservedRegs(const MachineFunction &MF) const {
  50   BitVector Reserved(getNumRegs());
  51   Reserved.set(VE::SX8);  // stack limit
  52   Reserved.set(VE::SX9);  // frame pointer
  53   Reserved.set(VE::SX10); // link register (return address)
  54   Reserved.set(VE::SX11); // stack pointer
  55
  56   Reserved.set(VE::SX12); // outer register
  57   Reserved.set(VE::SX13); // id register for dynamic linker
  58
  59   Reserved.set(VE::SX14); // thread pointer
  60   Reserved.set(VE::SX15); // global offset table register
  61   Reserved.set(VE::SX16); // procedure linkage table register
  62   Reserved.set(VE::SX17); // linkage-area register
  63
  64   // sx18-sx33 are callee-saved registers
  65   // sx34-sx63 are temporary registers
  66
  67   return Reserved;
  68 }
  69
  70 bool VERegisterInfo::isConstantPhysReg(unsigned PhysReg) const { return false; }
  71
  72 const TargetRegisterClass *
  73 VERegisterInfo::getPointerRegClass(const MachineFunction &MF,
  74                                    unsigned Kind) const {
  75   return &VE::I64RegClass;
  76 }
  77
  78 static void replaceFI(MachineFunction &MF, MachineBasicBlock::iterator II,
  79                       MachineInstr &MI, const DebugLoc &dl,
  80                       unsigned FIOperandNum, int Offset, unsigned FramePtr) {
  81   // Replace frame index with a frame pointer reference directly.
  82   // VE has 32 bit offset field, so no need to expand a target instruction.
  83   // Directly encode it.
  84   MI.getOperand(FIOperandNum).ChangeToRegister(FramePtr, false);
  85   MI.getOperand(FIOperandNum + 1).ChangeToImmediate(Offset);
  86 }
  87
  88 void VERegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
  89                                          int SPAdj, unsigned FIOperandNum,
  90                                          RegScavenger *RS) const {
  91   assert(SPAdj == 0 && "Unexpected");
  92
  93   MachineInstr &MI = *II;
  94   DebugLoc dl = MI.getDebugLoc();
  95   int FrameIndex = MI.getOperand(FIOperandNum).getIndex();
  96   MachineFunction &MF = *MI.getParent()->getParent();
  97   const VEFrameLowering *TFI = getFrameLowering(MF);
  98
  99   unsigned FrameReg;
 100   int Offset;
 101   Offset = TFI->getFrameIndexReference(MF, FrameIndex, FrameReg);
 102
 103   Offset += MI.getOperand(FIOperandNum + 1).getImm();
 104
 105   replaceFI(MF, II, MI, dl, FIOperandNum, Offset, FrameReg);
 106 }
 107
 108 Register VERegisterInfo::getFrameRegister(const MachineFunction &MF) const {
 109   return VE::SX9;
 110 }
 111
 112 // VE has no architectural need for stack realignment support,
 113 // except that LLVM unfortunately currently implements overaligned
 114 // stack objects by depending upon stack realignment support.
 115 // If that ever changes, this can probably be deleted.
 116 bool VERegisterInfo::canRealignStack(const MachineFunction &MF) const {
 117   if (!TargetRegisterInfo::canRealignStack(MF))
 118     return false;
 119
 120   // VE always has a fixed frame pointer register, so don't need to
 121   // worry about needing to reserve it. [even if we don't have a frame
 122   // pointer for our frame, it still cannot be used for other things,
 123   // or register window traps will be SADNESS.]
 124
 125   // If there's a reserved call frame, we can use VE to access locals.
 126   if (getFrameLowering(MF)->hasReservedCallFrame(MF))
 127     return true;
 128
 129   // Otherwise, we'd need a base pointer, but those aren't implemented
 130   // for VE at the moment.
 131
 132   return false;
 133 }