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 171