1//===-- VERegisterInfo.cpp - VE Register Information ----------------------===//
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// This file contains the VE implementation of the TargetRegisterInfo class.
10//
11//===----------------------------------------------------------------------===//
12
13#include "VERegisterInfo.h"
14#include "VE.h"
15#include "VESubtarget.h"
16#include "llvm/ADT/BitVector.h"
17#include "llvm/CodeGen/MachineFrameInfo.h"
18#include "llvm/CodeGen/MachineFunction.h"
19#include "llvm/CodeGen/MachineInstrBuilder.h"
20#include "llvm/CodeGen/TargetInstrInfo.h"
21#include "llvm/IR/Type.h"
22#include "llvm/Support/Debug.h"
23
24using namespace llvm;
25
26#define DEBUG_TYPE "ve-register-info"
27
28#define GET_REGINFO_TARGET_DESC
29#include "VEGenRegisterInfo.inc"
30
31// VE uses %s10 == %lp to keep return address
32VERegisterInfo::VERegisterInfo() : VEGenRegisterInfo(VE::SX10) {}
33
34const MCPhysReg *
35VERegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
36 switch (MF->getFunction().getCallingConv()) {
37 case CallingConv::Fast:
38 // Being explicit (same as standard CC).
39 default:
40 return CSR_SaveList;
41 case CallingConv::PreserveAll:
42 return CSR_preserve_all_SaveList;
43 }
44}
45
46const uint32_t *VERegisterInfo::getCallPreservedMask(const MachineFunction &MF,
47 CallingConv::ID CC) const {
48 switch (CC) {
49 case CallingConv::Fast:
50 // Being explicit (same as standard CC).
51 default:
52 return CSR_RegMask;
53 case CallingConv::PreserveAll:
54 return CSR_preserve_all_RegMask;
55 }
56}
57
58const uint32_t *VERegisterInfo::getNoPreservedMask() const {
59 return CSR_NoRegs_RegMask;
60}
61
62BitVector VERegisterInfo::getReservedRegs(const MachineFunction &MF) const {
63 BitVector Reserved(getNumRegs());
64
65 const Register ReservedRegs[] = {
66 VE::SX8, // Stack limit
67 VE::SX9, // Frame pointer
68 VE::SX10, // Link register (return address)
69 VE::SX11, // Stack pointer
70
71 // FIXME: maybe not need to be reserved
72 VE::SX12, // Outer register
73 VE::SX13, // Id register for dynamic linker
74
75 VE::SX14, // Thread pointer
76 VE::SX15, // Global offset table register
77 VE::SX16, // Procedure linkage table register
78 VE::SX17, // Linkage-area register
79 // sx18-sx33 are callee-saved registers
80 // sx34-sx63 are temporary registers
81 };
82
83 for (auto R : ReservedRegs)
84 for (MCRegAliasIterator ItAlias(R, this, true); ItAlias.isValid();
85 ++ItAlias)
86 Reserved.set(*ItAlias);
87
88 // Reserve constant registers.
89 Reserved.set(VE::VM0);
90 Reserved.set(VE::VMP0);
91
92 return Reserved;
93}
94
95static unsigned offsetToDisp(MachineInstr &MI) {
96 // Default offset in instruction's operands (reg+reg+imm).
97 unsigned OffDisp = 2;
98
99#define RRCAS_multi_cases(NAME) NAME##rir : case NAME##rii
100
101 {
102 using namespace llvm::VE;
103 switch (MI.getOpcode()) {
104 case INLINEASM:
105 case RRCAS_multi_cases(TS1AML):
106 case RRCAS_multi_cases(TS1AMW):
107 case RRCAS_multi_cases(CASL):
108 case RRCAS_multi_cases(CASW):
109 // These instructions use AS format (reg+imm).
110 OffDisp = 1;
111 break;
112 }
113 }
114#undef RRCAS_multi_cases
115
116 return OffDisp;
117}
118
119namespace {
120class EliminateFrameIndex {
121 const TargetInstrInfo &TII;
122 const TargetRegisterInfo &TRI;
123 const DebugLoc &DL;
124 MachineBasicBlock &MBB;
125 MachineBasicBlock::iterator II;
126 Register clobber;
127
128 // Some helper functions for the ease of instruction building.
129 MachineFunction &getFunc() const { return *MBB.getParent(); }
130 inline MCRegister getSubReg(MCRegister Reg, unsigned Idx) const {
131 return TRI.getSubReg(Reg, Idx);
132 }
133 inline const MCInstrDesc &get(unsigned Opcode) const {
134 return TII.get(Opcode);
135 }
136 inline MachineInstrBuilder build(const MCInstrDesc &MCID, Register DestReg) {
137 return BuildMI(BB&: MBB, I: II, MIMD: DL, MCID, DestReg);
138 }
139 inline MachineInstrBuilder build(unsigned InstOpc, Register DestReg) {
140 return build(MCID: get(Opcode: InstOpc), DestReg);
141 }
142 inline MachineInstrBuilder build(const MCInstrDesc &MCID) {
143 return BuildMI(BB&: MBB, I: II, MIMD: DL, MCID);
144 }
145 inline MachineInstrBuilder build(unsigned InstOpc) {
146 return build(MCID: get(Opcode: InstOpc));
147 }
148
149 // Calculate an address of frame index from a frame register and a given
150 // offset if the offset doesn't fit in the immediate field. Use a clobber
151 // register to hold calculated address.
152 void prepareReplaceFI(MachineInstr &MI, Register &FrameReg, int64_t &Offset,
153 int64_t Bytes = 0);
154 // Replace the frame index in \p MI with a frame register and a given offset
155 // if it fits in the immediate field. Otherwise, use pre-calculated address
156 // in a clobber register.
157 void replaceFI(MachineInstr &MI, Register FrameReg, int64_t Offset,
158 int FIOperandNum);
159
160 // Expand and eliminate Frame Index of pseudo STQrii and LDQrii.
161 void processSTQ(MachineInstr &MI, Register FrameReg, int64_t Offset,
162 int FIOperandNum);
163 void processLDQ(MachineInstr &MI, Register FrameReg, int64_t Offset,
164 int FIOperandNum);
165 // Expand and eliminate Frame Index of pseudo STVMrii and LDVMrii.
166 void processSTVM(MachineInstr &MI, Register FrameReg, int64_t Offset,
167 int FIOperandNum);
168 void processLDVM(MachineInstr &MI, Register FrameReg, int64_t Offset,
169 int FIOperandNum);
170 // Expand and eliminate Frame Index of pseudo STVM512rii and LDVM512rii.
171 void processSTVM512(MachineInstr &MI, Register FrameReg, int64_t Offset,
172 int FIOperandNum);
173 void processLDVM512(MachineInstr &MI, Register FrameReg, int64_t Offset,
174 int FIOperandNum);
175
176public:
177 EliminateFrameIndex(const TargetInstrInfo &TII, const TargetRegisterInfo &TRI,
178 const DebugLoc &DL, MachineBasicBlock &MBB,
179 MachineBasicBlock::iterator II)
180 : TII(TII), TRI(TRI), DL(DL), MBB(MBB), II(II), clobber(VE::SX13) {}
181
182 // Expand and eliminate Frame Index from MI
183 void processMI(MachineInstr &MI, Register FrameReg, int64_t Offset,
184 int FIOperandNum);
185};
186} // namespace
187
188// Prepare the frame index if it doesn't fit in the immediate field. Use
189// clobber register to hold calculated address.
190void EliminateFrameIndex::prepareReplaceFI(MachineInstr &MI, Register &FrameReg,
191 int64_t &Offset, int64_t Bytes) {
192 if (isInt<32>(x: Offset) && isInt<32>(x: Offset + Bytes)) {
193 // If the offset is small enough to fit in the immediate field, directly
194 // encode it. So, nothing to prepare here.
195 return;
196 }
197
198 // If the offset doesn't fit, emit following codes. This clobbers SX13
199 // which we always know is available here.
200 // lea %clobber, Offset@lo
201 // and %clobber, %clobber, (32)0
202 // lea.sl %clobber, Offset@hi(FrameReg, %clobber)
203 build(InstOpc: VE::LEAzii, DestReg: clobber).addImm(Val: 0).addImm(Val: 0).addImm(Val: Lo_32(Value: Offset));
204 build(InstOpc: VE::ANDrm, DestReg: clobber).addReg(RegNo: clobber).addImm(Val: M0(Val: 32));
205 build(InstOpc: VE::LEASLrri, DestReg: clobber)
206 .addReg(RegNo: clobber)
207 .addReg(RegNo: FrameReg)
208 .addImm(Val: Hi_32(Value: Offset));
209
210 // Use clobber register as a frame register and 0 offset
211 FrameReg = clobber;
212 Offset = 0;
213}
214
215// Replace the frame index in \p MI with a proper byte and framereg offset.
216void EliminateFrameIndex::replaceFI(MachineInstr &MI, Register FrameReg,
217 int64_t Offset, int FIOperandNum) {
218 assert(isInt<32>(Offset));
219
220 // The offset must be small enough to fit in the immediate field after
221 // call of prepareReplaceFI. Therefore, we directly encode it.
222 MI.getOperand(i: FIOperandNum).ChangeToRegister(Reg: FrameReg, isDef: false);
223 MI.getOperand(i: FIOperandNum + offsetToDisp(MI)).ChangeToImmediate(ImmVal: Offset);
224}
225
226void EliminateFrameIndex::processSTQ(MachineInstr &MI, Register FrameReg,
227 int64_t Offset, int FIOperandNum) {
228 assert(MI.getOpcode() == VE::STQrii);
229 LLVM_DEBUG(dbgs() << "processSTQ: "; MI.dump());
230
231 prepareReplaceFI(MI, FrameReg, Offset, Bytes: 8);
232
233 Register SrcReg = MI.getOperand(i: 3).getReg();
234 Register SrcHiReg = getSubReg(Reg: SrcReg, Idx: VE::sub_even);
235 Register SrcLoReg = getSubReg(Reg: SrcReg, Idx: VE::sub_odd);
236 // VE stores HiReg to 8(addr) and LoReg to 0(addr)
237 MachineInstr *StMI =
238 build(InstOpc: VE::STrii).addReg(RegNo: FrameReg).addImm(Val: 0).addImm(Val: 0).addReg(RegNo: SrcLoReg);
239 replaceFI(MI&: *StMI, FrameReg, Offset, FIOperandNum: 0);
240 // Mutate to 'hi' store.
241 MI.setDesc(get(Opcode: VE::STrii));
242 MI.getOperand(i: 3).setReg(SrcHiReg);
243 Offset += 8;
244 replaceFI(MI, FrameReg, Offset, FIOperandNum);
245}
246
247void EliminateFrameIndex::processLDQ(MachineInstr &MI, Register FrameReg,
248 int64_t Offset, int FIOperandNum) {
249 assert(MI.getOpcode() == VE::LDQrii);
250 LLVM_DEBUG(dbgs() << "processLDQ: "; MI.dump());
251
252 prepareReplaceFI(MI, FrameReg, Offset, Bytes: 8);
253
254 Register DestReg = MI.getOperand(i: 0).getReg();
255 Register DestHiReg = getSubReg(Reg: DestReg, Idx: VE::sub_even);
256 Register DestLoReg = getSubReg(Reg: DestReg, Idx: VE::sub_odd);
257 // VE loads HiReg from 8(addr) and LoReg from 0(addr)
258 MachineInstr *StMI =
259 build(InstOpc: VE::LDrii, DestReg: DestLoReg).addReg(RegNo: FrameReg).addImm(Val: 0).addImm(Val: 0);
260 replaceFI(MI&: *StMI, FrameReg, Offset, FIOperandNum: 1);
261 MI.setDesc(get(Opcode: VE::LDrii));
262 MI.getOperand(i: 0).setReg(DestHiReg);
263 Offset += 8;
264 replaceFI(MI, FrameReg, Offset, FIOperandNum);
265}
266
267void EliminateFrameIndex::processSTVM(MachineInstr &MI, Register FrameReg,
268 int64_t Offset, int FIOperandNum) {
269 assert(MI.getOpcode() == VE::STVMrii);
270 LLVM_DEBUG(dbgs() << "processSTVM: "; MI.dump());
271
272 // Original MI is:
273 // STVMrii frame-index, 0, offset, reg (, memory operand)
274 // Convert it to:
275 // SVMi tmp-reg, reg, 0
276 // STrii frame-reg, 0, offset, tmp-reg
277 // SVMi tmp-reg, reg, 1
278 // STrii frame-reg, 0, offset+8, tmp-reg
279 // SVMi tmp-reg, reg, 2
280 // STrii frame-reg, 0, offset+16, tmp-reg
281 // SVMi tmp-reg, reg, 3
282 // STrii frame-reg, 0, offset+24, tmp-reg
283
284 prepareReplaceFI(MI, FrameReg, Offset, Bytes: 24);
285
286 Register SrcReg = MI.getOperand(i: 3).getReg();
287 bool isKill = MI.getOperand(i: 3).isKill();
288 // FIXME: it would be better to scavenge a register here instead of
289 // reserving SX16 all of the time.
290 Register TmpReg = VE::SX16;
291 for (int i = 0; i < 3; ++i) {
292 build(InstOpc: VE::SVMmr, DestReg: TmpReg).addReg(RegNo: SrcReg).addImm(Val: i);
293 MachineInstr *StMI =
294 build(InstOpc: VE::STrii).addReg(RegNo: FrameReg).addImm(Val: 0).addImm(Val: 0).addReg(
295 RegNo: TmpReg, Flags: getKillRegState(B: true));
296 replaceFI(MI&: *StMI, FrameReg, Offset, FIOperandNum: 0);
297 Offset += 8;
298 }
299 build(InstOpc: VE::SVMmr, DestReg: TmpReg).addReg(RegNo: SrcReg, Flags: getKillRegState(B: isKill)).addImm(Val: 3);
300 MI.setDesc(get(Opcode: VE::STrii));
301 MI.getOperand(i: 3).ChangeToRegister(Reg: TmpReg, isDef: false, isImp: false, isKill: true);
302 replaceFI(MI, FrameReg, Offset, FIOperandNum);
303}
304
305void EliminateFrameIndex::processLDVM(MachineInstr &MI, Register FrameReg,
306 int64_t Offset, int FIOperandNum) {
307 assert(MI.getOpcode() == VE::LDVMrii);
308 LLVM_DEBUG(dbgs() << "processLDVM: "; MI.dump());
309
310 // Original MI is:
311 // LDVMri reg, frame-index, 0, offset (, memory operand)
312 // Convert it to:
313 // LDrii tmp-reg, frame-reg, 0, offset
314 // LVMir vm, 0, tmp-reg
315 // LDrii tmp-reg, frame-reg, 0, offset+8
316 // LVMir_m vm, 1, tmp-reg, vm
317 // LDrii tmp-reg, frame-reg, 0, offset+16
318 // LVMir_m vm, 2, tmp-reg, vm
319 // LDrii tmp-reg, frame-reg, 0, offset+24
320 // LVMir_m vm, 3, tmp-reg, vm
321
322 prepareReplaceFI(MI, FrameReg, Offset, Bytes: 24);
323
324 Register DestReg = MI.getOperand(i: 0).getReg();
325 // FIXME: it would be better to scavenge a register here instead of
326 // reserving SX16 all of the time.
327 unsigned TmpReg = VE::SX16;
328 for (int i = 0; i < 4; ++i) {
329 if (i != 3) {
330 MachineInstr *StMI =
331 build(InstOpc: VE::LDrii, DestReg: TmpReg).addReg(RegNo: FrameReg).addImm(Val: 0).addImm(Val: 0);
332 replaceFI(MI&: *StMI, FrameReg, Offset, FIOperandNum: 1);
333 Offset += 8;
334 } else {
335 // Last LDrii replace the target instruction.
336 MI.setDesc(get(Opcode: VE::LDrii));
337 MI.getOperand(i: 0).ChangeToRegister(Reg: TmpReg, isDef: true);
338 }
339 // First LVM is LVMir. Others are LVMir_m. Last LVM places at the
340 // next of the target instruction.
341 if (i == 0)
342 build(InstOpc: VE::LVMir, DestReg).addImm(Val: i).addReg(RegNo: TmpReg, Flags: getKillRegState(B: true));
343 else if (i != 3)
344 build(InstOpc: VE::LVMir_m, DestReg)
345 .addImm(Val: i)
346 .addReg(RegNo: TmpReg, Flags: getKillRegState(B: true))
347 .addReg(RegNo: DestReg);
348 else
349 BuildMI(BB&: *MI.getParent(), I: std::next(x: II), MIMD: DL, MCID: get(Opcode: VE::LVMir_m), DestReg)
350 .addImm(Val: 3)
351 .addReg(RegNo: TmpReg, Flags: getKillRegState(B: true))
352 .addReg(RegNo: DestReg);
353 }
354 replaceFI(MI, FrameReg, Offset, FIOperandNum);
355}
356
357void EliminateFrameIndex::processSTVM512(MachineInstr &MI, Register FrameReg,
358 int64_t Offset, int FIOperandNum) {
359 assert(MI.getOpcode() == VE::STVM512rii);
360 LLVM_DEBUG(dbgs() << "processSTVM512: "; MI.dump());
361
362 prepareReplaceFI(MI, FrameReg, Offset, Bytes: 56);
363
364 Register SrcReg = MI.getOperand(i: 3).getReg();
365 Register SrcLoReg = getSubReg(Reg: SrcReg, Idx: VE::sub_vm_odd);
366 Register SrcHiReg = getSubReg(Reg: SrcReg, Idx: VE::sub_vm_even);
367 bool isKill = MI.getOperand(i: 3).isKill();
368 // FIXME: it would be better to scavenge a register here instead of
369 // reserving SX16 all of the time.
370 Register TmpReg = VE::SX16;
371 // store low part of VMP
372 MachineInstr *LastMI = nullptr;
373 for (int i = 0; i < 4; ++i) {
374 LastMI = build(InstOpc: VE::SVMmr, DestReg: TmpReg).addReg(RegNo: SrcLoReg).addImm(Val: i);
375 MachineInstr *StMI =
376 build(InstOpc: VE::STrii).addReg(RegNo: FrameReg).addImm(Val: 0).addImm(Val: 0).addReg(
377 RegNo: TmpReg, Flags: getKillRegState(B: true));
378 replaceFI(MI&: *StMI, FrameReg, Offset, FIOperandNum: 0);
379 Offset += 8;
380 }
381 if (isKill)
382 LastMI->addRegisterKilled(IncomingReg: SrcLoReg, RegInfo: &TRI, AddIfNotFound: true);
383 // store high part of VMP
384 for (int i = 0; i < 3; ++i) {
385 build(InstOpc: VE::SVMmr, DestReg: TmpReg).addReg(RegNo: SrcHiReg).addImm(Val: i);
386 MachineInstr *StMI =
387 build(InstOpc: VE::STrii).addReg(RegNo: FrameReg).addImm(Val: 0).addImm(Val: 0).addReg(
388 RegNo: TmpReg, Flags: getKillRegState(B: true));
389 replaceFI(MI&: *StMI, FrameReg, Offset, FIOperandNum: 0);
390 Offset += 8;
391 }
392 LastMI = build(InstOpc: VE::SVMmr, DestReg: TmpReg).addReg(RegNo: SrcHiReg).addImm(Val: 3);
393 if (isKill) {
394 LastMI->addRegisterKilled(IncomingReg: SrcHiReg, RegInfo: &TRI, AddIfNotFound: true);
395 // Add implicit super-register kills to the particular MI.
396 LastMI->addRegisterKilled(IncomingReg: SrcReg, RegInfo: &TRI, AddIfNotFound: true);
397 }
398 MI.setDesc(get(Opcode: VE::STrii));
399 MI.getOperand(i: 3).ChangeToRegister(Reg: TmpReg, isDef: false, isImp: false, isKill: true);
400 replaceFI(MI, FrameReg, Offset, FIOperandNum);
401}
402
403void EliminateFrameIndex::processLDVM512(MachineInstr &MI, Register FrameReg,
404 int64_t Offset, int FIOperandNum) {
405 assert(MI.getOpcode() == VE::LDVM512rii);
406 LLVM_DEBUG(dbgs() << "processLDVM512: "; MI.dump());
407
408 prepareReplaceFI(MI, FrameReg, Offset, Bytes: 56);
409
410 Register DestReg = MI.getOperand(i: 0).getReg();
411 Register DestLoReg = getSubReg(Reg: DestReg, Idx: VE::sub_vm_odd);
412 Register DestHiReg = getSubReg(Reg: DestReg, Idx: VE::sub_vm_even);
413 // FIXME: it would be better to scavenge a register here instead of
414 // reserving SX16 all of the time.
415 Register TmpReg = VE::SX16;
416 build(InstOpc: VE::IMPLICIT_DEF, DestReg);
417 for (int i = 0; i < 4; ++i) {
418 MachineInstr *LdMI =
419 build(InstOpc: VE::LDrii, DestReg: TmpReg).addReg(RegNo: FrameReg).addImm(Val: 0).addImm(Val: 0);
420 replaceFI(MI&: *LdMI, FrameReg, Offset, FIOperandNum: 1);
421 build(InstOpc: VE::LVMir_m, DestReg: DestLoReg)
422 .addImm(Val: i)
423 .addReg(RegNo: TmpReg, Flags: getKillRegState(B: true))
424 .addReg(RegNo: DestLoReg);
425 Offset += 8;
426 }
427 for (int i = 0; i < 3; ++i) {
428 MachineInstr *LdMI =
429 build(InstOpc: VE::LDrii, DestReg: TmpReg).addReg(RegNo: FrameReg).addImm(Val: 0).addImm(Val: 0);
430 replaceFI(MI&: *LdMI, FrameReg, Offset, FIOperandNum: 1);
431 build(InstOpc: VE::LVMir_m, DestReg: DestHiReg)
432 .addImm(Val: i)
433 .addReg(RegNo: TmpReg, Flags: getKillRegState(B: true))
434 .addReg(RegNo: DestHiReg);
435 Offset += 8;
436 }
437 MI.setDesc(get(Opcode: VE::LDrii));
438 MI.getOperand(i: 0).ChangeToRegister(Reg: TmpReg, isDef: true);
439 BuildMI(BB&: *MI.getParent(), I: std::next(x: II), MIMD: DL, MCID: get(Opcode: VE::LVMir_m), DestReg: DestHiReg)
440 .addImm(Val: 3)
441 .addReg(RegNo: TmpReg, Flags: getKillRegState(B: true))
442 .addReg(RegNo: DestHiReg);
443 replaceFI(MI, FrameReg, Offset, FIOperandNum);
444}
445
446void EliminateFrameIndex::processMI(MachineInstr &MI, Register FrameReg,
447 int64_t Offset, int FIOperandNum) {
448 switch (MI.getOpcode()) {
449 case VE::STQrii:
450 processSTQ(MI, FrameReg, Offset, FIOperandNum);
451 return;
452 case VE::LDQrii:
453 processLDQ(MI, FrameReg, Offset, FIOperandNum);
454 return;
455 case VE::STVMrii:
456 processSTVM(MI, FrameReg, Offset, FIOperandNum);
457 return;
458 case VE::LDVMrii:
459 processLDVM(MI, FrameReg, Offset, FIOperandNum);
460 return;
461 case VE::STVM512rii:
462 processSTVM512(MI, FrameReg, Offset, FIOperandNum);
463 return;
464 case VE::LDVM512rii:
465 processLDVM512(MI, FrameReg, Offset, FIOperandNum);
466 return;
467 }
468 prepareReplaceFI(MI, FrameReg, Offset);
469 replaceFI(MI, FrameReg, Offset, FIOperandNum);
470}
471
472bool VERegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
473 int SPAdj, unsigned FIOperandNum,
474 RegScavenger *RS) const {
475 assert(SPAdj == 0 && "Unexpected");
476
477 MachineInstr &MI = *II;
478 int FrameIndex = MI.getOperand(i: FIOperandNum).getIndex();
479
480 MachineFunction &MF = *MI.getParent()->getParent();
481 const VESubtarget &Subtarget = MF.getSubtarget<VESubtarget>();
482 const VEFrameLowering &TFI = *getFrameLowering(MF);
483 const TargetInstrInfo &TII = *Subtarget.getInstrInfo();
484 const VERegisterInfo &TRI = *Subtarget.getRegisterInfo();
485 DebugLoc DL = MI.getDebugLoc();
486 EliminateFrameIndex EFI(TII, TRI, DL, *MI.getParent(), II);
487
488 // Retrieve FrameReg and byte offset for stack slot.
489 Register FrameReg;
490 int64_t Offset =
491 TFI.getFrameIndexReference(MF, FI: FrameIndex, FrameReg).getFixed();
492 Offset += MI.getOperand(i: FIOperandNum + offsetToDisp(MI)).getImm();
493
494 EFI.processMI(MI, FrameReg, Offset, FIOperandNum);
495 return false;
496}
497
498Register VERegisterInfo::getFrameRegister(const MachineFunction &MF) const {
499 return VE::SX9;
500}
501