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