llvm/lib/Target/SystemZ/SystemZRegisterInfo.h

   1 //===-- SystemZRegisterInfo.h - SystemZ register information ----*- C++ -*-===//
   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 #ifndef LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZREGISTERINFO_H
  10 #define LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZREGISTERINFO_H
  11
  12 #include "SystemZ.h"
  13 #include "llvm/CodeGen/TargetRegisterInfo.h"
  14
  15 #define GET_REGINFO_HEADER
  16 #include "SystemZGenRegisterInfo.inc"
  17
  18 namespace llvm {
  19
  20 class LiveIntervals;
  21
  22 namespace SystemZ {
  23 // Return the subreg to use for referring to the even and odd registers
  24 // in a GR128 pair.  Is32Bit says whether we want a GR32 or GR64.
  25 inline unsigned even128(bool Is32bit) {
  26   return Is32bit ? subreg_hl32 : subreg_h64;
  27 }
  28 inline unsigned odd128(bool Is32bit) {
  29   return Is32bit ? subreg_l32 : subreg_l64;
  30 }
  31
  32 // Reg should be a 32-bit GPR.  Return true if it is a high register rather
  33 // than a low register.
  34 inline bool isHighReg(unsigned int Reg) {
  35   if (SystemZ::GRH32BitRegClass.contains(Reg))
  36     return true;
  37   assert(SystemZ::GR32BitRegClass.contains(Reg) && "Invalid GRX32");
  38   return false;
  39 }
  40 } // end namespace SystemZ
  41
  42 /// A SystemZ-specific class detailing special use registers
  43 /// particular for calling conventions.
  44 /// It is abstract, all calling conventions must override and
  45 /// define the pure virtual member function defined in this class.
  46 class SystemZCallingConventionRegisters {
  47 public:
  48   /// \returns the register that keeps the
  49   /// return function address.
  50   virtual int getReturnFunctionAddressRegister() = 0;
  51
  52   /// \returns the register that keeps the
  53   /// stack pointer address.
  54   virtual int getStackPointerRegister() = 0;
  55
  56   /// \returns the register that keeps the
  57   /// frame pointer address.
  58   virtual int getFramePointerRegister() = 0;
  59
  60   /// \returns an array of all the callee saved registers.
  61   virtual const MCPhysReg *
  62   getCalleeSavedRegs(const MachineFunction *MF) const = 0;
  63
  64   /// \returns the mask of all the call preserved registers.
  65   virtual const uint32_t *getCallPreservedMask(const MachineFunction &MF,
  66                                                CallingConv::ID CC) const = 0;
  67
  68   /// Destroys the object. Bogus destructor allowing derived classes
  69   /// to override it.
  70   virtual ~SystemZCallingConventionRegisters(){};
  71 };
  72
  73 /// XPLINK64 calling convention specific use registers
  74 /// Particular to z/OS when in 64 bit mode
  75 class SystemZXPLINK64Registers : public SystemZCallingConventionRegisters {
  76 public:
  77   int getReturnFunctionAddressRegister() override final {
  78     return SystemZ::R7D;
  79   };
  80
  81   int getStackPointerRegister() override final { return SystemZ::R4D; };
  82
  83   int getFramePointerRegister() override final { return SystemZ::R8D; };
  84
  85   const MCPhysReg *
  86   getCalleeSavedRegs(const MachineFunction *MF) const override final;
  87
  88   const uint32_t *getCallPreservedMask(const MachineFunction &MF,
  89                                        CallingConv::ID CC) const override final;
  90
  91   /// Destroys the object. Bogus destructor overriding base class destructor
  92   ~SystemZXPLINK64Registers(){};
  93 };
  94
  95 /// ELF calling convention specific use registers
  96 /// Particular when on zLinux in 64 bit mode
  97 class SystemZELFRegisters : public SystemZCallingConventionRegisters {
  98 public:
  99   int getReturnFunctionAddressRegister() override final {
 100     return SystemZ::R14D;
 101   };
 102
 103   int getStackPointerRegister() override final { return SystemZ::R15D; };
 104
 105   int getFramePointerRegister() override final { return SystemZ::R11D; };
 106
 107   const MCPhysReg *
 108   getCalleeSavedRegs(const MachineFunction *MF) const override final;
 109
 110   const uint32_t *getCallPreservedMask(const MachineFunction &MF,
 111                                        CallingConv::ID CC) const override final;
 112
 113   /// Destroys the object. Bogus destructor overriding base class destructor
 114   ~SystemZELFRegisters(){};
 115 };
 116
 117 struct SystemZRegisterInfo : public SystemZGenRegisterInfo {
 118 public:
 119   SystemZRegisterInfo(unsigned int RA);
 120
 121   /// getPointerRegClass - Return the register class to use to hold pointers.
 122   /// This is currently only used by LOAD_STACK_GUARD, which requires a non-%r0
 123   /// register, hence ADDR64.
 124   const TargetRegisterClass *
 125   getPointerRegClass(const MachineFunction &MF,
 126                      unsigned Kind=0) const override {
 127     return &SystemZ::ADDR64BitRegClass;
 128   }
 129
 130   /// getCrossCopyRegClass - Returns a legal register class to copy a register
 131   /// in the specified class to or from. Returns NULL if it is possible to copy
 132   /// between a two registers of the specified class.
 133   const TargetRegisterClass *
 134   getCrossCopyRegClass(const TargetRegisterClass *RC) const override;
 135
 136   bool getRegAllocationHints(Register VirtReg, ArrayRef<MCPhysReg> Order,
 137                              SmallVectorImpl<MCPhysReg> &Hints,
 138                              const MachineFunction &MF, const VirtRegMap *VRM,
 139                              const LiveRegMatrix *Matrix) const override;
 140
 141   // Override TargetRegisterInfo.h.
 142   bool requiresRegisterScavenging(const MachineFunction &MF) const override {
 143     return true;
 144   }
 145   bool requiresFrameIndexScavenging(const MachineFunction &MF) const override {
 146     return true;
 147   }
 148   const MCPhysReg *getCalleeSavedRegs(const MachineFunction *MF) const override;
 149   const uint32_t *getCallPreservedMask(const MachineFunction &MF,
 150                                        CallingConv::ID CC) const override;
 151   BitVector getReservedRegs(const MachineFunction &MF) const override;
 152   void eliminateFrameIndex(MachineBasicBlock::iterator MI,
 153                            int SPAdj, unsigned FIOperandNum,
 154                            RegScavenger *RS) const override;
 155
 156   /// SrcRC and DstRC will be morphed into NewRC if this returns true.
 157  bool shouldCoalesce(MachineInstr *MI,
 158                       const TargetRegisterClass *SrcRC,
 159                       unsigned SubReg,
 160                       const TargetRegisterClass *DstRC,
 161                       unsigned DstSubReg,
 162                       const TargetRegisterClass *NewRC,
 163                       LiveIntervals &LIS) const override;
 164
 165   Register getFrameRegister(const MachineFunction &MF) const override;
 166 };
 167
 168 } // end namespace llvm
 169
 170 #endif