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