1 //===-- HexagonRegisterInfo.cpp - Hexagon Register Information ------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains the Hexagon implementation of the TargetRegisterInfo
11 // class.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "HexagonRegisterInfo.h"
16 #include "Hexagon.h"
17 #include "HexagonMachineFunctionInfo.h"
18 #include "HexagonSubtarget.h"
19 #include "HexagonTargetMachine.h"
20 #include "llvm/ADT/BitVector.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/CodeGen/MachineFrameInfo.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineFunctionPass.h"
25 #include "llvm/CodeGen/MachineInstrBuilder.h"
26 #include "llvm/CodeGen/MachineRegisterInfo.h"
27 #include "llvm/CodeGen/PseudoSourceValue.h"
28 #include "llvm/CodeGen/RegisterScavenging.h"
29 #include "llvm/IR/Function.h"
30 #include "llvm/IR/Type.h"
31 #include "llvm/MC/MachineLocation.h"
32 #include "llvm/Support/CommandLine.h"
33 #include "llvm/Support/Debug.h"
34 #include "llvm/Support/ErrorHandling.h"
35 #include "llvm/Support/raw_ostream.h"
36 #include "llvm/Target/TargetInstrInfo.h"
37 #include "llvm/Target/TargetMachine.h"
38 #include "llvm/Target/TargetOptions.h"
39 
40 using namespace llvm;
41 
42 HexagonRegisterInfo::HexagonRegisterInfo()
43     : HexagonGenRegisterInfo(Hexagon::R31) {}
44 
45 
46 bool HexagonRegisterInfo::isEHReturnCalleeSaveReg(unsigned R) const {
47   return R == Hexagon::R0 || R == Hexagon::R1 || R == Hexagon::R2 ||
48          R == Hexagon::R3 || R == Hexagon::D0 || R == Hexagon::D1;
49 }
50 
51 bool HexagonRegisterInfo::isCalleeSaveReg(unsigned Reg) const {
52   return Hexagon::R16 <= Reg && Reg <= Hexagon::R27;
53 }
54 
55 
56 const MCPhysReg *
57 HexagonRegisterInfo::getCallerSavedRegs(const MachineFunction *MF) const {
58   static const MCPhysReg CallerSavedRegsV4[] = {
59     Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4,
60     Hexagon::R5, Hexagon::R6, Hexagon::R7, Hexagon::R8, Hexagon::R9,
61     Hexagon::R10, Hexagon::R11, Hexagon::R12, Hexagon::R13, Hexagon::R14,
62     Hexagon::R15, 0
63   };
64 
65   switch (MF->getSubtarget<HexagonSubtarget>().getHexagonArchVersion()) {
66   case HexagonSubtarget::V4:
67   case HexagonSubtarget::V5:
68   case HexagonSubtarget::V55:
69   case HexagonSubtarget::V60:
70     return CallerSavedRegsV4;
71   }
72   llvm_unreachable(
73     "Callee saved registers requested for unknown archtecture version");
74 }
75 
76 
77 const MCPhysReg *
78 HexagonRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
79   static const MCPhysReg CalleeSavedRegsV3[] = {
80     Hexagon::R16,   Hexagon::R17,   Hexagon::R18,   Hexagon::R19,
81     Hexagon::R20,   Hexagon::R21,   Hexagon::R22,   Hexagon::R23,
82     Hexagon::R24,   Hexagon::R25,   Hexagon::R26,   Hexagon::R27, 0
83   };
84 
85   // Functions that contain a call to __builtin_eh_return also save the first 4
86   // parameter registers.
87   static const MCPhysReg CalleeSavedRegsV3EHReturn[] = {
88     Hexagon::R0,    Hexagon::R1,    Hexagon::R2,    Hexagon::R3,
89     Hexagon::R16,   Hexagon::R17,   Hexagon::R18,   Hexagon::R19,
90     Hexagon::R20,   Hexagon::R21,   Hexagon::R22,   Hexagon::R23,
91     Hexagon::R24,   Hexagon::R25,   Hexagon::R26,   Hexagon::R27, 0
92   };
93 
94   bool HasEHReturn = MF->getInfo<HexagonMachineFunctionInfo>()->hasEHReturn();
95 
96   switch (MF->getSubtarget<HexagonSubtarget>().getHexagonArchVersion()) {
97   case HexagonSubtarget::V4:
98   case HexagonSubtarget::V5:
99   case HexagonSubtarget::V55:
100   case HexagonSubtarget::V60:
101     return HasEHReturn ? CalleeSavedRegsV3EHReturn : CalleeSavedRegsV3;
102   }
103 
104   llvm_unreachable("Callee saved registers requested for unknown architecture "
105                    "version");
106 }
107 
108 
109 BitVector HexagonRegisterInfo::getReservedRegs(const MachineFunction &MF)
110   const {
111   BitVector Reserved(getNumRegs());
112   Reserved.set(Hexagon::R29);
113   Reserved.set(Hexagon::R30);
114   Reserved.set(Hexagon::R31);
115   Reserved.set(Hexagon::PC);
116   Reserved.set(Hexagon::D14);
117   Reserved.set(Hexagon::D15);
118   Reserved.set(Hexagon::LC0);
119   Reserved.set(Hexagon::LC1);
120   Reserved.set(Hexagon::SA0);
121   Reserved.set(Hexagon::SA1);
122   Reserved.set(Hexagon::UGP);
123   Reserved.set(Hexagon::GP);
124   Reserved.set(Hexagon::CS0);
125   Reserved.set(Hexagon::CS1);
126   Reserved.set(Hexagon::CS);
127   return Reserved;
128 }
129 
130 
131 void HexagonRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
132                                               int SPAdj, unsigned FIOp,
133                                               RegScavenger *RS) const {
134   //
135   // Hexagon_TODO: Do we need to enforce this for Hexagon?
136   assert(SPAdj == 0 && "Unexpected");
137 
138   MachineInstr &MI = *II;
139   MachineBasicBlock &MB = *MI.getParent();
140   MachineFunction &MF = *MB.getParent();
141   auto &HST = MF.getSubtarget<HexagonSubtarget>();
142   auto &HII = *HST.getInstrInfo();
143   auto &HFI = *HST.getFrameLowering();
144 
145   unsigned BP = 0;
146   int FI = MI.getOperand(FIOp).getIndex();
147   // Select the base pointer (BP) and calculate the actual offset from BP
148   // to the beginning of the object at index FI.
149   int Offset = HFI.getFrameIndexReference(MF, FI, BP);
150   // Add the offset from the instruction.
151   int RealOffset = Offset + MI.getOperand(FIOp+1).getImm();
152   bool IsKill = false;
153 
154   unsigned Opc = MI.getOpcode();
155   switch (Opc) {
156     case Hexagon::TFR_FIA:
157       MI.setDesc(HII.get(Hexagon::A2_addi));
158       MI.getOperand(FIOp).ChangeToImmediate(RealOffset);
159       MI.RemoveOperand(FIOp+1);
160       return;
161     case Hexagon::TFR_FI:
162       // Set up the instruction for updating below.
163       MI.setDesc(HII.get(Hexagon::A2_addi));
164       break;
165   }
166 
167   if (!HII.isValidOffset(Opc, RealOffset)) {
168     // If the offset is not valid, calculate the address in a temporary
169     // register and use it with offset 0.
170     auto &MRI = MF.getRegInfo();
171     unsigned TmpR = MRI.createVirtualRegister(&Hexagon::IntRegsRegClass);
172     DebugLoc DL = MI.getDebugLoc();
173     BuildMI(MB, II, DL, HII.get(Hexagon::A2_addi), TmpR)
174       .addReg(BP)
175       .addImm(RealOffset);
176     BP = TmpR;
177     RealOffset = 0;
178     IsKill = true;
179   }
180 
181   MI.getOperand(FIOp).ChangeToRegister(BP, false, false, IsKill);
182   MI.getOperand(FIOp+1).ChangeToImmediate(RealOffset);
183 }
184 
185 
186 unsigned HexagonRegisterInfo::getRARegister() const {
187   return Hexagon::R31;
188 }
189 
190 
191 unsigned HexagonRegisterInfo::getFrameRegister(const MachineFunction
192                                                &MF) const {
193   const HexagonFrameLowering *TFI = getFrameLowering(MF);
194   if (TFI->hasFP(MF))
195     return getFrameRegister();
196   return getStackRegister();
197 }
198 
199 
200 unsigned HexagonRegisterInfo::getFrameRegister() const {
201   return Hexagon::R30;
202 }
203 
204 
205 unsigned HexagonRegisterInfo::getStackRegister() const {
206   return Hexagon::R29;
207 }
208 
209 
210 bool HexagonRegisterInfo::useFPForScavengingIndex(const MachineFunction &MF)
211       const {
212   return MF.getSubtarget<HexagonSubtarget>().getFrameLowering()->hasFP(MF);
213 }
214 
215 
216 unsigned HexagonRegisterInfo::getFirstCallerSavedNonParamReg() const {
217   return Hexagon::R6;
218 }
219 
220 
221 #define GET_REGINFO_TARGET_DESC
222 #include "HexagonGenRegisterInfo.inc"
223