1*da58b97aSjoerg //===-- VEInstrInfo.cpp - VE Instruction Information ----------------------===//
2*da58b97aSjoerg //
3*da58b97aSjoerg // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4*da58b97aSjoerg // See https://llvm.org/LICENSE.txt for license information.
5*da58b97aSjoerg // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6*da58b97aSjoerg //
7*da58b97aSjoerg //===----------------------------------------------------------------------===//
8*da58b97aSjoerg //
9*da58b97aSjoerg // This file contains the VE implementation of the TargetInstrInfo class.
10*da58b97aSjoerg //
11*da58b97aSjoerg //===----------------------------------------------------------------------===//
12*da58b97aSjoerg
13*da58b97aSjoerg #include "VEInstrInfo.h"
14*da58b97aSjoerg #include "VE.h"
15*da58b97aSjoerg #include "VEMachineFunctionInfo.h"
16*da58b97aSjoerg #include "VESubtarget.h"
17*da58b97aSjoerg #include "llvm/ADT/STLExtras.h"
18*da58b97aSjoerg #include "llvm/ADT/SmallVector.h"
19*da58b97aSjoerg #include "llvm/CodeGen/MachineFrameInfo.h"
20*da58b97aSjoerg #include "llvm/CodeGen/MachineInstrBuilder.h"
21*da58b97aSjoerg #include "llvm/CodeGen/MachineMemOperand.h"
22*da58b97aSjoerg #include "llvm/CodeGen/MachineRegisterInfo.h"
23*da58b97aSjoerg #include "llvm/Support/CommandLine.h"
24*da58b97aSjoerg #include "llvm/Support/Debug.h"
25*da58b97aSjoerg #include "llvm/Support/ErrorHandling.h"
26*da58b97aSjoerg #include "llvm/Support/TargetRegistry.h"
27*da58b97aSjoerg
28*da58b97aSjoerg #define DEBUG_TYPE "ve-instr-info"
29*da58b97aSjoerg
30*da58b97aSjoerg using namespace llvm;
31*da58b97aSjoerg
32*da58b97aSjoerg #define GET_INSTRINFO_CTOR_DTOR
33*da58b97aSjoerg #include "VEGenInstrInfo.inc"
34*da58b97aSjoerg
35*da58b97aSjoerg // Pin the vtable to this file.
anchor()36*da58b97aSjoerg void VEInstrInfo::anchor() {}
37*da58b97aSjoerg
VEInstrInfo(VESubtarget & ST)38*da58b97aSjoerg VEInstrInfo::VEInstrInfo(VESubtarget &ST)
39*da58b97aSjoerg : VEGenInstrInfo(VE::ADJCALLSTACKDOWN, VE::ADJCALLSTACKUP), RI() {}
40*da58b97aSjoerg
IsIntegerCC(unsigned CC)41*da58b97aSjoerg static bool IsIntegerCC(unsigned CC) { return (CC < VECC::CC_AF); }
42*da58b97aSjoerg
GetOppositeBranchCondition(VECC::CondCode CC)43*da58b97aSjoerg static VECC::CondCode GetOppositeBranchCondition(VECC::CondCode CC) {
44*da58b97aSjoerg switch (CC) {
45*da58b97aSjoerg case VECC::CC_IG:
46*da58b97aSjoerg return VECC::CC_ILE;
47*da58b97aSjoerg case VECC::CC_IL:
48*da58b97aSjoerg return VECC::CC_IGE;
49*da58b97aSjoerg case VECC::CC_INE:
50*da58b97aSjoerg return VECC::CC_IEQ;
51*da58b97aSjoerg case VECC::CC_IEQ:
52*da58b97aSjoerg return VECC::CC_INE;
53*da58b97aSjoerg case VECC::CC_IGE:
54*da58b97aSjoerg return VECC::CC_IL;
55*da58b97aSjoerg case VECC::CC_ILE:
56*da58b97aSjoerg return VECC::CC_IG;
57*da58b97aSjoerg case VECC::CC_AF:
58*da58b97aSjoerg return VECC::CC_AT;
59*da58b97aSjoerg case VECC::CC_G:
60*da58b97aSjoerg return VECC::CC_LENAN;
61*da58b97aSjoerg case VECC::CC_L:
62*da58b97aSjoerg return VECC::CC_GENAN;
63*da58b97aSjoerg case VECC::CC_NE:
64*da58b97aSjoerg return VECC::CC_EQNAN;
65*da58b97aSjoerg case VECC::CC_EQ:
66*da58b97aSjoerg return VECC::CC_NENAN;
67*da58b97aSjoerg case VECC::CC_GE:
68*da58b97aSjoerg return VECC::CC_LNAN;
69*da58b97aSjoerg case VECC::CC_LE:
70*da58b97aSjoerg return VECC::CC_GNAN;
71*da58b97aSjoerg case VECC::CC_NUM:
72*da58b97aSjoerg return VECC::CC_NAN;
73*da58b97aSjoerg case VECC::CC_NAN:
74*da58b97aSjoerg return VECC::CC_NUM;
75*da58b97aSjoerg case VECC::CC_GNAN:
76*da58b97aSjoerg return VECC::CC_LE;
77*da58b97aSjoerg case VECC::CC_LNAN:
78*da58b97aSjoerg return VECC::CC_GE;
79*da58b97aSjoerg case VECC::CC_NENAN:
80*da58b97aSjoerg return VECC::CC_EQ;
81*da58b97aSjoerg case VECC::CC_EQNAN:
82*da58b97aSjoerg return VECC::CC_NE;
83*da58b97aSjoerg case VECC::CC_GENAN:
84*da58b97aSjoerg return VECC::CC_L;
85*da58b97aSjoerg case VECC::CC_LENAN:
86*da58b97aSjoerg return VECC::CC_G;
87*da58b97aSjoerg case VECC::CC_AT:
88*da58b97aSjoerg return VECC::CC_AF;
89*da58b97aSjoerg case VECC::UNKNOWN:
90*da58b97aSjoerg return VECC::UNKNOWN;
91*da58b97aSjoerg }
92*da58b97aSjoerg llvm_unreachable("Invalid cond code");
93*da58b97aSjoerg }
94*da58b97aSjoerg
95*da58b97aSjoerg // Treat a branch relative long always instruction as unconditional branch.
96*da58b97aSjoerg // For example, br.l.t and br.l.
isUncondBranchOpcode(int Opc)97*da58b97aSjoerg static bool isUncondBranchOpcode(int Opc) {
98*da58b97aSjoerg using namespace llvm::VE;
99*da58b97aSjoerg
100*da58b97aSjoerg #define BRKIND(NAME) (Opc == NAME##a || Opc == NAME##a_nt || Opc == NAME##a_t)
101*da58b97aSjoerg // VE has other branch relative always instructions for word/double/float,
102*da58b97aSjoerg // but we use only long branches in our lower. So, sanity check it here.
103*da58b97aSjoerg assert(!BRKIND(BRCFW) && !BRKIND(BRCFD) && !BRKIND(BRCFS) &&
104*da58b97aSjoerg "Branch relative word/double/float always instructions should not be "
105*da58b97aSjoerg "used!");
106*da58b97aSjoerg return BRKIND(BRCFL);
107*da58b97aSjoerg #undef BRKIND
108*da58b97aSjoerg }
109*da58b97aSjoerg
110*da58b97aSjoerg // Treat branch relative conditional as conditional branch instructions.
111*da58b97aSjoerg // For example, brgt.l.t and brle.s.nt.
isCondBranchOpcode(int Opc)112*da58b97aSjoerg static bool isCondBranchOpcode(int Opc) {
113*da58b97aSjoerg using namespace llvm::VE;
114*da58b97aSjoerg
115*da58b97aSjoerg #define BRKIND(NAME) \
116*da58b97aSjoerg (Opc == NAME##rr || Opc == NAME##rr_nt || Opc == NAME##rr_t || \
117*da58b97aSjoerg Opc == NAME##ir || Opc == NAME##ir_nt || Opc == NAME##ir_t)
118*da58b97aSjoerg return BRKIND(BRCFL) || BRKIND(BRCFW) || BRKIND(BRCFD) || BRKIND(BRCFS);
119*da58b97aSjoerg #undef BRKIND
120*da58b97aSjoerg }
121*da58b97aSjoerg
122*da58b97aSjoerg // Treat branch long always instructions as indirect branch.
123*da58b97aSjoerg // For example, b.l.t and b.l.
isIndirectBranchOpcode(int Opc)124*da58b97aSjoerg static bool isIndirectBranchOpcode(int Opc) {
125*da58b97aSjoerg using namespace llvm::VE;
126*da58b97aSjoerg
127*da58b97aSjoerg #define BRKIND(NAME) \
128*da58b97aSjoerg (Opc == NAME##ari || Opc == NAME##ari_nt || Opc == NAME##ari_t)
129*da58b97aSjoerg // VE has other branch always instructions for word/double/float, but
130*da58b97aSjoerg // we use only long branches in our lower. So, sanity check it here.
131*da58b97aSjoerg assert(!BRKIND(BCFW) && !BRKIND(BCFD) && !BRKIND(BCFS) &&
132*da58b97aSjoerg "Branch word/double/float always instructions should not be used!");
133*da58b97aSjoerg return BRKIND(BCFL);
134*da58b97aSjoerg #undef BRKIND
135*da58b97aSjoerg }
136*da58b97aSjoerg
parseCondBranch(MachineInstr * LastInst,MachineBasicBlock * & Target,SmallVectorImpl<MachineOperand> & Cond)137*da58b97aSjoerg static void parseCondBranch(MachineInstr *LastInst, MachineBasicBlock *&Target,
138*da58b97aSjoerg SmallVectorImpl<MachineOperand> &Cond) {
139*da58b97aSjoerg Cond.push_back(MachineOperand::CreateImm(LastInst->getOperand(0).getImm()));
140*da58b97aSjoerg Cond.push_back(LastInst->getOperand(1));
141*da58b97aSjoerg Cond.push_back(LastInst->getOperand(2));
142*da58b97aSjoerg Target = LastInst->getOperand(3).getMBB();
143*da58b97aSjoerg }
144*da58b97aSjoerg
analyzeBranch(MachineBasicBlock & MBB,MachineBasicBlock * & TBB,MachineBasicBlock * & FBB,SmallVectorImpl<MachineOperand> & Cond,bool AllowModify) const145*da58b97aSjoerg bool VEInstrInfo::analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
146*da58b97aSjoerg MachineBasicBlock *&FBB,
147*da58b97aSjoerg SmallVectorImpl<MachineOperand> &Cond,
148*da58b97aSjoerg bool AllowModify) const {
149*da58b97aSjoerg MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
150*da58b97aSjoerg if (I == MBB.end())
151*da58b97aSjoerg return false;
152*da58b97aSjoerg
153*da58b97aSjoerg if (!isUnpredicatedTerminator(*I))
154*da58b97aSjoerg return false;
155*da58b97aSjoerg
156*da58b97aSjoerg // Get the last instruction in the block.
157*da58b97aSjoerg MachineInstr *LastInst = &*I;
158*da58b97aSjoerg unsigned LastOpc = LastInst->getOpcode();
159*da58b97aSjoerg
160*da58b97aSjoerg // If there is only one terminator instruction, process it.
161*da58b97aSjoerg if (I == MBB.begin() || !isUnpredicatedTerminator(*--I)) {
162*da58b97aSjoerg if (isUncondBranchOpcode(LastOpc)) {
163*da58b97aSjoerg TBB = LastInst->getOperand(0).getMBB();
164*da58b97aSjoerg return false;
165*da58b97aSjoerg }
166*da58b97aSjoerg if (isCondBranchOpcode(LastOpc)) {
167*da58b97aSjoerg // Block ends with fall-through condbranch.
168*da58b97aSjoerg parseCondBranch(LastInst, TBB, Cond);
169*da58b97aSjoerg return false;
170*da58b97aSjoerg }
171*da58b97aSjoerg return true; // Can't handle indirect branch.
172*da58b97aSjoerg }
173*da58b97aSjoerg
174*da58b97aSjoerg // Get the instruction before it if it is a terminator.
175*da58b97aSjoerg MachineInstr *SecondLastInst = &*I;
176*da58b97aSjoerg unsigned SecondLastOpc = SecondLastInst->getOpcode();
177*da58b97aSjoerg
178*da58b97aSjoerg // If AllowModify is true and the block ends with two or more unconditional
179*da58b97aSjoerg // branches, delete all but the first unconditional branch.
180*da58b97aSjoerg if (AllowModify && isUncondBranchOpcode(LastOpc)) {
181*da58b97aSjoerg while (isUncondBranchOpcode(SecondLastOpc)) {
182*da58b97aSjoerg LastInst->eraseFromParent();
183*da58b97aSjoerg LastInst = SecondLastInst;
184*da58b97aSjoerg LastOpc = LastInst->getOpcode();
185*da58b97aSjoerg if (I == MBB.begin() || !isUnpredicatedTerminator(*--I)) {
186*da58b97aSjoerg // Return now the only terminator is an unconditional branch.
187*da58b97aSjoerg TBB = LastInst->getOperand(0).getMBB();
188*da58b97aSjoerg return false;
189*da58b97aSjoerg }
190*da58b97aSjoerg SecondLastInst = &*I;
191*da58b97aSjoerg SecondLastOpc = SecondLastInst->getOpcode();
192*da58b97aSjoerg }
193*da58b97aSjoerg }
194*da58b97aSjoerg
195*da58b97aSjoerg // If there are three terminators, we don't know what sort of block this is.
196*da58b97aSjoerg if (SecondLastInst && I != MBB.begin() && isUnpredicatedTerminator(*--I))
197*da58b97aSjoerg return true;
198*da58b97aSjoerg
199*da58b97aSjoerg // If the block ends with a B and a Bcc, handle it.
200*da58b97aSjoerg if (isCondBranchOpcode(SecondLastOpc) && isUncondBranchOpcode(LastOpc)) {
201*da58b97aSjoerg parseCondBranch(SecondLastInst, TBB, Cond);
202*da58b97aSjoerg FBB = LastInst->getOperand(0).getMBB();
203*da58b97aSjoerg return false;
204*da58b97aSjoerg }
205*da58b97aSjoerg
206*da58b97aSjoerg // If the block ends with two unconditional branches, handle it. The second
207*da58b97aSjoerg // one is not executed.
208*da58b97aSjoerg if (isUncondBranchOpcode(SecondLastOpc) && isUncondBranchOpcode(LastOpc)) {
209*da58b97aSjoerg TBB = SecondLastInst->getOperand(0).getMBB();
210*da58b97aSjoerg return false;
211*da58b97aSjoerg }
212*da58b97aSjoerg
213*da58b97aSjoerg // ...likewise if it ends with an indirect branch followed by an unconditional
214*da58b97aSjoerg // branch.
215*da58b97aSjoerg if (isIndirectBranchOpcode(SecondLastOpc) && isUncondBranchOpcode(LastOpc)) {
216*da58b97aSjoerg I = LastInst;
217*da58b97aSjoerg if (AllowModify)
218*da58b97aSjoerg I->eraseFromParent();
219*da58b97aSjoerg return true;
220*da58b97aSjoerg }
221*da58b97aSjoerg
222*da58b97aSjoerg // Otherwise, can't handle this.
223*da58b97aSjoerg return true;
224*da58b97aSjoerg }
225*da58b97aSjoerg
insertBranch(MachineBasicBlock & MBB,MachineBasicBlock * TBB,MachineBasicBlock * FBB,ArrayRef<MachineOperand> Cond,const DebugLoc & DL,int * BytesAdded) const226*da58b97aSjoerg unsigned VEInstrInfo::insertBranch(MachineBasicBlock &MBB,
227*da58b97aSjoerg MachineBasicBlock *TBB,
228*da58b97aSjoerg MachineBasicBlock *FBB,
229*da58b97aSjoerg ArrayRef<MachineOperand> Cond,
230*da58b97aSjoerg const DebugLoc &DL, int *BytesAdded) const {
231*da58b97aSjoerg assert(TBB && "insertBranch must not be told to insert a fallthrough");
232*da58b97aSjoerg assert((Cond.size() == 3 || Cond.size() == 0) &&
233*da58b97aSjoerg "VE branch conditions should have three component!");
234*da58b97aSjoerg assert(!BytesAdded && "code size not handled");
235*da58b97aSjoerg if (Cond.empty()) {
236*da58b97aSjoerg // Uncondition branch
237*da58b97aSjoerg assert(!FBB && "Unconditional branch with multiple successors!");
238*da58b97aSjoerg BuildMI(&MBB, DL, get(VE::BRCFLa_t))
239*da58b97aSjoerg .addMBB(TBB);
240*da58b97aSjoerg return 1;
241*da58b97aSjoerg }
242*da58b97aSjoerg
243*da58b97aSjoerg // Conditional branch
244*da58b97aSjoerg // (BRCFir CC sy sz addr)
245*da58b97aSjoerg assert(Cond[0].isImm() && Cond[2].isReg() && "not implemented");
246*da58b97aSjoerg
247*da58b97aSjoerg unsigned opc[2];
248*da58b97aSjoerg const TargetRegisterInfo *TRI = &getRegisterInfo();
249*da58b97aSjoerg MachineFunction *MF = MBB.getParent();
250*da58b97aSjoerg const MachineRegisterInfo &MRI = MF->getRegInfo();
251*da58b97aSjoerg unsigned Reg = Cond[2].getReg();
252*da58b97aSjoerg if (IsIntegerCC(Cond[0].getImm())) {
253*da58b97aSjoerg if (TRI->getRegSizeInBits(Reg, MRI) == 32) {
254*da58b97aSjoerg opc[0] = VE::BRCFWir;
255*da58b97aSjoerg opc[1] = VE::BRCFWrr;
256*da58b97aSjoerg } else {
257*da58b97aSjoerg opc[0] = VE::BRCFLir;
258*da58b97aSjoerg opc[1] = VE::BRCFLrr;
259*da58b97aSjoerg }
260*da58b97aSjoerg } else {
261*da58b97aSjoerg if (TRI->getRegSizeInBits(Reg, MRI) == 32) {
262*da58b97aSjoerg opc[0] = VE::BRCFSir;
263*da58b97aSjoerg opc[1] = VE::BRCFSrr;
264*da58b97aSjoerg } else {
265*da58b97aSjoerg opc[0] = VE::BRCFDir;
266*da58b97aSjoerg opc[1] = VE::BRCFDrr;
267*da58b97aSjoerg }
268*da58b97aSjoerg }
269*da58b97aSjoerg if (Cond[1].isImm()) {
270*da58b97aSjoerg BuildMI(&MBB, DL, get(opc[0]))
271*da58b97aSjoerg .add(Cond[0]) // condition code
272*da58b97aSjoerg .add(Cond[1]) // lhs
273*da58b97aSjoerg .add(Cond[2]) // rhs
274*da58b97aSjoerg .addMBB(TBB);
275*da58b97aSjoerg } else {
276*da58b97aSjoerg BuildMI(&MBB, DL, get(opc[1]))
277*da58b97aSjoerg .add(Cond[0])
278*da58b97aSjoerg .add(Cond[1])
279*da58b97aSjoerg .add(Cond[2])
280*da58b97aSjoerg .addMBB(TBB);
281*da58b97aSjoerg }
282*da58b97aSjoerg
283*da58b97aSjoerg if (!FBB)
284*da58b97aSjoerg return 1;
285*da58b97aSjoerg
286*da58b97aSjoerg BuildMI(&MBB, DL, get(VE::BRCFLa_t))
287*da58b97aSjoerg .addMBB(FBB);
288*da58b97aSjoerg return 2;
289*da58b97aSjoerg }
290*da58b97aSjoerg
removeBranch(MachineBasicBlock & MBB,int * BytesRemoved) const291*da58b97aSjoerg unsigned VEInstrInfo::removeBranch(MachineBasicBlock &MBB,
292*da58b97aSjoerg int *BytesRemoved) const {
293*da58b97aSjoerg assert(!BytesRemoved && "code size not handled");
294*da58b97aSjoerg
295*da58b97aSjoerg MachineBasicBlock::iterator I = MBB.end();
296*da58b97aSjoerg unsigned Count = 0;
297*da58b97aSjoerg while (I != MBB.begin()) {
298*da58b97aSjoerg --I;
299*da58b97aSjoerg
300*da58b97aSjoerg if (I->isDebugValue())
301*da58b97aSjoerg continue;
302*da58b97aSjoerg
303*da58b97aSjoerg if (!isUncondBranchOpcode(I->getOpcode()) &&
304*da58b97aSjoerg !isCondBranchOpcode(I->getOpcode()))
305*da58b97aSjoerg break; // Not a branch
306*da58b97aSjoerg
307*da58b97aSjoerg I->eraseFromParent();
308*da58b97aSjoerg I = MBB.end();
309*da58b97aSjoerg ++Count;
310*da58b97aSjoerg }
311*da58b97aSjoerg return Count;
312*da58b97aSjoerg }
313*da58b97aSjoerg
reverseBranchCondition(SmallVectorImpl<MachineOperand> & Cond) const314*da58b97aSjoerg bool VEInstrInfo::reverseBranchCondition(
315*da58b97aSjoerg SmallVectorImpl<MachineOperand> &Cond) const {
316*da58b97aSjoerg VECC::CondCode CC = static_cast<VECC::CondCode>(Cond[0].getImm());
317*da58b97aSjoerg Cond[0].setImm(GetOppositeBranchCondition(CC));
318*da58b97aSjoerg return false;
319*da58b97aSjoerg }
320*da58b97aSjoerg
IsAliasOfSX(Register Reg)321*da58b97aSjoerg static bool IsAliasOfSX(Register Reg) {
322*da58b97aSjoerg return VE::I32RegClass.contains(Reg) || VE::I64RegClass.contains(Reg) ||
323*da58b97aSjoerg VE::F32RegClass.contains(Reg);
324*da58b97aSjoerg }
325*da58b97aSjoerg
copyPhysSubRegs(MachineBasicBlock & MBB,MachineBasicBlock::iterator I,const DebugLoc & DL,MCRegister DestReg,MCRegister SrcReg,bool KillSrc,const MCInstrDesc & MCID,unsigned int NumSubRegs,const unsigned * SubRegIdx,const TargetRegisterInfo * TRI)326*da58b97aSjoerg static void copyPhysSubRegs(MachineBasicBlock &MBB,
327*da58b97aSjoerg MachineBasicBlock::iterator I, const DebugLoc &DL,
328*da58b97aSjoerg MCRegister DestReg, MCRegister SrcReg, bool KillSrc,
329*da58b97aSjoerg const MCInstrDesc &MCID, unsigned int NumSubRegs,
330*da58b97aSjoerg const unsigned *SubRegIdx,
331*da58b97aSjoerg const TargetRegisterInfo *TRI) {
332*da58b97aSjoerg MachineInstr *MovMI = nullptr;
333*da58b97aSjoerg
334*da58b97aSjoerg for (unsigned Idx = 0; Idx != NumSubRegs; ++Idx) {
335*da58b97aSjoerg Register SubDest = TRI->getSubReg(DestReg, SubRegIdx[Idx]);
336*da58b97aSjoerg Register SubSrc = TRI->getSubReg(SrcReg, SubRegIdx[Idx]);
337*da58b97aSjoerg assert(SubDest && SubSrc && "Bad sub-register");
338*da58b97aSjoerg
339*da58b97aSjoerg if (MCID.getOpcode() == VE::ORri) {
340*da58b97aSjoerg // generate "ORri, dest, src, 0" instruction.
341*da58b97aSjoerg MachineInstrBuilder MIB =
342*da58b97aSjoerg BuildMI(MBB, I, DL, MCID, SubDest).addReg(SubSrc).addImm(0);
343*da58b97aSjoerg MovMI = MIB.getInstr();
344*da58b97aSjoerg } else if (MCID.getOpcode() == VE::ANDMmm) {
345*da58b97aSjoerg // generate "ANDM, dest, vm0, src" instruction.
346*da58b97aSjoerg MachineInstrBuilder MIB =
347*da58b97aSjoerg BuildMI(MBB, I, DL, MCID, SubDest).addReg(VE::VM0).addReg(SubSrc);
348*da58b97aSjoerg MovMI = MIB.getInstr();
349*da58b97aSjoerg } else {
350*da58b97aSjoerg llvm_unreachable("Unexpected reg-to-reg copy instruction");
351*da58b97aSjoerg }
352*da58b97aSjoerg }
353*da58b97aSjoerg // Add implicit super-register defs and kills to the last MovMI.
354*da58b97aSjoerg MovMI->addRegisterDefined(DestReg, TRI);
355*da58b97aSjoerg if (KillSrc)
356*da58b97aSjoerg MovMI->addRegisterKilled(SrcReg, TRI, true);
357*da58b97aSjoerg }
358*da58b97aSjoerg
copyPhysReg(MachineBasicBlock & MBB,MachineBasicBlock::iterator I,const DebugLoc & DL,MCRegister DestReg,MCRegister SrcReg,bool KillSrc) const359*da58b97aSjoerg void VEInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
360*da58b97aSjoerg MachineBasicBlock::iterator I, const DebugLoc &DL,
361*da58b97aSjoerg MCRegister DestReg, MCRegister SrcReg,
362*da58b97aSjoerg bool KillSrc) const {
363*da58b97aSjoerg
364*da58b97aSjoerg if (IsAliasOfSX(SrcReg) && IsAliasOfSX(DestReg)) {
365*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::ORri), DestReg)
366*da58b97aSjoerg .addReg(SrcReg, getKillRegState(KillSrc))
367*da58b97aSjoerg .addImm(0);
368*da58b97aSjoerg } else if (VE::V64RegClass.contains(DestReg, SrcReg)) {
369*da58b97aSjoerg // Generate following instructions
370*da58b97aSjoerg // %sw16 = LEA32zii 256
371*da58b97aSjoerg // VORmvl %dest, (0)1, %src, %sw16
372*da58b97aSjoerg // TODO: reuse a register if vl is already assigned to a register
373*da58b97aSjoerg // FIXME: it would be better to scavenge a register here instead of
374*da58b97aSjoerg // reserving SX16 all of the time.
375*da58b97aSjoerg const TargetRegisterInfo *TRI = &getRegisterInfo();
376*da58b97aSjoerg Register TmpReg = VE::SX16;
377*da58b97aSjoerg Register SubTmp = TRI->getSubReg(TmpReg, VE::sub_i32);
378*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::LEAzii), TmpReg)
379*da58b97aSjoerg .addImm(0)
380*da58b97aSjoerg .addImm(0)
381*da58b97aSjoerg .addImm(256);
382*da58b97aSjoerg MachineInstrBuilder MIB = BuildMI(MBB, I, DL, get(VE::VORmvl), DestReg)
383*da58b97aSjoerg .addImm(M1(0)) // Represent (0)1.
384*da58b97aSjoerg .addReg(SrcReg, getKillRegState(KillSrc))
385*da58b97aSjoerg .addReg(SubTmp, getKillRegState(true));
386*da58b97aSjoerg MIB.getInstr()->addRegisterKilled(TmpReg, TRI, true);
387*da58b97aSjoerg } else if (VE::VMRegClass.contains(DestReg, SrcReg)) {
388*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::ANDMmm), DestReg)
389*da58b97aSjoerg .addReg(VE::VM0)
390*da58b97aSjoerg .addReg(SrcReg, getKillRegState(KillSrc));
391*da58b97aSjoerg } else if (VE::VM512RegClass.contains(DestReg, SrcReg)) {
392*da58b97aSjoerg // Use two instructions.
393*da58b97aSjoerg const unsigned SubRegIdx[] = {VE::sub_vm_even, VE::sub_vm_odd};
394*da58b97aSjoerg unsigned int NumSubRegs = 2;
395*da58b97aSjoerg copyPhysSubRegs(MBB, I, DL, DestReg, SrcReg, KillSrc, get(VE::ANDMmm),
396*da58b97aSjoerg NumSubRegs, SubRegIdx, &getRegisterInfo());
397*da58b97aSjoerg } else if (VE::F128RegClass.contains(DestReg, SrcReg)) {
398*da58b97aSjoerg // Use two instructions.
399*da58b97aSjoerg const unsigned SubRegIdx[] = {VE::sub_even, VE::sub_odd};
400*da58b97aSjoerg unsigned int NumSubRegs = 2;
401*da58b97aSjoerg copyPhysSubRegs(MBB, I, DL, DestReg, SrcReg, KillSrc, get(VE::ORri),
402*da58b97aSjoerg NumSubRegs, SubRegIdx, &getRegisterInfo());
403*da58b97aSjoerg } else {
404*da58b97aSjoerg const TargetRegisterInfo *TRI = &getRegisterInfo();
405*da58b97aSjoerg dbgs() << "Impossible reg-to-reg copy from " << printReg(SrcReg, TRI)
406*da58b97aSjoerg << " to " << printReg(DestReg, TRI) << "\n";
407*da58b97aSjoerg llvm_unreachable("Impossible reg-to-reg copy");
408*da58b97aSjoerg }
409*da58b97aSjoerg }
410*da58b97aSjoerg
411*da58b97aSjoerg /// isLoadFromStackSlot - If the specified machine instruction is a direct
412*da58b97aSjoerg /// load from a stack slot, return the virtual or physical register number of
413*da58b97aSjoerg /// the destination along with the FrameIndex of the loaded stack slot. If
414*da58b97aSjoerg /// not, return 0. This predicate must return 0 if the instruction has
415*da58b97aSjoerg /// any side effects other than loading from the stack slot.
isLoadFromStackSlot(const MachineInstr & MI,int & FrameIndex) const416*da58b97aSjoerg unsigned VEInstrInfo::isLoadFromStackSlot(const MachineInstr &MI,
417*da58b97aSjoerg int &FrameIndex) const {
418*da58b97aSjoerg if (MI.getOpcode() == VE::LDrii || // I64
419*da58b97aSjoerg MI.getOpcode() == VE::LDLSXrii || // I32
420*da58b97aSjoerg MI.getOpcode() == VE::LDUrii || // F32
421*da58b97aSjoerg MI.getOpcode() == VE::LDQrii // F128 (pseudo)
422*da58b97aSjoerg ) {
423*da58b97aSjoerg if (MI.getOperand(1).isFI() && MI.getOperand(2).isImm() &&
424*da58b97aSjoerg MI.getOperand(2).getImm() == 0 && MI.getOperand(3).isImm() &&
425*da58b97aSjoerg MI.getOperand(3).getImm() == 0) {
426*da58b97aSjoerg FrameIndex = MI.getOperand(1).getIndex();
427*da58b97aSjoerg return MI.getOperand(0).getReg();
428*da58b97aSjoerg }
429*da58b97aSjoerg }
430*da58b97aSjoerg return 0;
431*da58b97aSjoerg }
432*da58b97aSjoerg
433*da58b97aSjoerg /// isStoreToStackSlot - If the specified machine instruction is a direct
434*da58b97aSjoerg /// store to a stack slot, return the virtual or physical register number of
435*da58b97aSjoerg /// the source reg along with the FrameIndex of the loaded stack slot. If
436*da58b97aSjoerg /// not, return 0. This predicate must return 0 if the instruction has
437*da58b97aSjoerg /// any side effects other than storing to the stack slot.
isStoreToStackSlot(const MachineInstr & MI,int & FrameIndex) const438*da58b97aSjoerg unsigned VEInstrInfo::isStoreToStackSlot(const MachineInstr &MI,
439*da58b97aSjoerg int &FrameIndex) const {
440*da58b97aSjoerg if (MI.getOpcode() == VE::STrii || // I64
441*da58b97aSjoerg MI.getOpcode() == VE::STLrii || // I32
442*da58b97aSjoerg MI.getOpcode() == VE::STUrii || // F32
443*da58b97aSjoerg MI.getOpcode() == VE::STQrii // F128 (pseudo)
444*da58b97aSjoerg ) {
445*da58b97aSjoerg if (MI.getOperand(0).isFI() && MI.getOperand(1).isImm() &&
446*da58b97aSjoerg MI.getOperand(1).getImm() == 0 && MI.getOperand(2).isImm() &&
447*da58b97aSjoerg MI.getOperand(2).getImm() == 0) {
448*da58b97aSjoerg FrameIndex = MI.getOperand(0).getIndex();
449*da58b97aSjoerg return MI.getOperand(3).getReg();
450*da58b97aSjoerg }
451*da58b97aSjoerg }
452*da58b97aSjoerg return 0;
453*da58b97aSjoerg }
454*da58b97aSjoerg
storeRegToStackSlot(MachineBasicBlock & MBB,MachineBasicBlock::iterator I,Register SrcReg,bool isKill,int FI,const TargetRegisterClass * RC,const TargetRegisterInfo * TRI) const455*da58b97aSjoerg void VEInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
456*da58b97aSjoerg MachineBasicBlock::iterator I,
457*da58b97aSjoerg Register SrcReg, bool isKill, int FI,
458*da58b97aSjoerg const TargetRegisterClass *RC,
459*da58b97aSjoerg const TargetRegisterInfo *TRI) const {
460*da58b97aSjoerg DebugLoc DL;
461*da58b97aSjoerg if (I != MBB.end())
462*da58b97aSjoerg DL = I->getDebugLoc();
463*da58b97aSjoerg
464*da58b97aSjoerg MachineFunction *MF = MBB.getParent();
465*da58b97aSjoerg const MachineFrameInfo &MFI = MF->getFrameInfo();
466*da58b97aSjoerg MachineMemOperand *MMO = MF->getMachineMemOperand(
467*da58b97aSjoerg MachinePointerInfo::getFixedStack(*MF, FI), MachineMemOperand::MOStore,
468*da58b97aSjoerg MFI.getObjectSize(FI), MFI.getObjectAlign(FI));
469*da58b97aSjoerg
470*da58b97aSjoerg // On the order of operands here: think "[FrameIdx + 0] = SrcReg".
471*da58b97aSjoerg if (RC == &VE::I64RegClass) {
472*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::STrii))
473*da58b97aSjoerg .addFrameIndex(FI)
474*da58b97aSjoerg .addImm(0)
475*da58b97aSjoerg .addImm(0)
476*da58b97aSjoerg .addReg(SrcReg, getKillRegState(isKill))
477*da58b97aSjoerg .addMemOperand(MMO);
478*da58b97aSjoerg } else if (RC == &VE::I32RegClass) {
479*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::STLrii))
480*da58b97aSjoerg .addFrameIndex(FI)
481*da58b97aSjoerg .addImm(0)
482*da58b97aSjoerg .addImm(0)
483*da58b97aSjoerg .addReg(SrcReg, getKillRegState(isKill))
484*da58b97aSjoerg .addMemOperand(MMO);
485*da58b97aSjoerg } else if (RC == &VE::F32RegClass) {
486*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::STUrii))
487*da58b97aSjoerg .addFrameIndex(FI)
488*da58b97aSjoerg .addImm(0)
489*da58b97aSjoerg .addImm(0)
490*da58b97aSjoerg .addReg(SrcReg, getKillRegState(isKill))
491*da58b97aSjoerg .addMemOperand(MMO);
492*da58b97aSjoerg } else if (VE::F128RegClass.hasSubClassEq(RC)) {
493*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::STQrii))
494*da58b97aSjoerg .addFrameIndex(FI)
495*da58b97aSjoerg .addImm(0)
496*da58b97aSjoerg .addImm(0)
497*da58b97aSjoerg .addReg(SrcReg, getKillRegState(isKill))
498*da58b97aSjoerg .addMemOperand(MMO);
499*da58b97aSjoerg } else
500*da58b97aSjoerg report_fatal_error("Can't store this register to stack slot");
501*da58b97aSjoerg }
502*da58b97aSjoerg
loadRegFromStackSlot(MachineBasicBlock & MBB,MachineBasicBlock::iterator I,Register DestReg,int FI,const TargetRegisterClass * RC,const TargetRegisterInfo * TRI) const503*da58b97aSjoerg void VEInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
504*da58b97aSjoerg MachineBasicBlock::iterator I,
505*da58b97aSjoerg Register DestReg, int FI,
506*da58b97aSjoerg const TargetRegisterClass *RC,
507*da58b97aSjoerg const TargetRegisterInfo *TRI) const {
508*da58b97aSjoerg DebugLoc DL;
509*da58b97aSjoerg if (I != MBB.end())
510*da58b97aSjoerg DL = I->getDebugLoc();
511*da58b97aSjoerg
512*da58b97aSjoerg MachineFunction *MF = MBB.getParent();
513*da58b97aSjoerg const MachineFrameInfo &MFI = MF->getFrameInfo();
514*da58b97aSjoerg MachineMemOperand *MMO = MF->getMachineMemOperand(
515*da58b97aSjoerg MachinePointerInfo::getFixedStack(*MF, FI), MachineMemOperand::MOLoad,
516*da58b97aSjoerg MFI.getObjectSize(FI), MFI.getObjectAlign(FI));
517*da58b97aSjoerg
518*da58b97aSjoerg if (RC == &VE::I64RegClass) {
519*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::LDrii), DestReg)
520*da58b97aSjoerg .addFrameIndex(FI)
521*da58b97aSjoerg .addImm(0)
522*da58b97aSjoerg .addImm(0)
523*da58b97aSjoerg .addMemOperand(MMO);
524*da58b97aSjoerg } else if (RC == &VE::I32RegClass) {
525*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::LDLSXrii), DestReg)
526*da58b97aSjoerg .addFrameIndex(FI)
527*da58b97aSjoerg .addImm(0)
528*da58b97aSjoerg .addImm(0)
529*da58b97aSjoerg .addMemOperand(MMO);
530*da58b97aSjoerg } else if (RC == &VE::F32RegClass) {
531*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::LDUrii), DestReg)
532*da58b97aSjoerg .addFrameIndex(FI)
533*da58b97aSjoerg .addImm(0)
534*da58b97aSjoerg .addImm(0)
535*da58b97aSjoerg .addMemOperand(MMO);
536*da58b97aSjoerg } else if (VE::F128RegClass.hasSubClassEq(RC)) {
537*da58b97aSjoerg BuildMI(MBB, I, DL, get(VE::LDQrii), DestReg)
538*da58b97aSjoerg .addFrameIndex(FI)
539*da58b97aSjoerg .addImm(0)
540*da58b97aSjoerg .addImm(0)
541*da58b97aSjoerg .addMemOperand(MMO);
542*da58b97aSjoerg } else
543*da58b97aSjoerg report_fatal_error("Can't load this register from stack slot");
544*da58b97aSjoerg }
545*da58b97aSjoerg
FoldImmediate(MachineInstr & UseMI,MachineInstr & DefMI,Register Reg,MachineRegisterInfo * MRI) const546*da58b97aSjoerg bool VEInstrInfo::FoldImmediate(MachineInstr &UseMI, MachineInstr &DefMI,
547*da58b97aSjoerg Register Reg, MachineRegisterInfo *MRI) const {
548*da58b97aSjoerg LLVM_DEBUG(dbgs() << "FoldImmediate\n");
549*da58b97aSjoerg
550*da58b97aSjoerg LLVM_DEBUG(dbgs() << "checking DefMI\n");
551*da58b97aSjoerg int64_t ImmVal;
552*da58b97aSjoerg switch (DefMI.getOpcode()) {
553*da58b97aSjoerg default:
554*da58b97aSjoerg return false;
555*da58b97aSjoerg case VE::ORim:
556*da58b97aSjoerg // General move small immediate instruction on VE.
557*da58b97aSjoerg LLVM_DEBUG(dbgs() << "checking ORim\n");
558*da58b97aSjoerg LLVM_DEBUG(DefMI.dump());
559*da58b97aSjoerg // FIXME: We may need to support FPImm too.
560*da58b97aSjoerg assert(DefMI.getOperand(1).isImm());
561*da58b97aSjoerg assert(DefMI.getOperand(2).isImm());
562*da58b97aSjoerg ImmVal =
563*da58b97aSjoerg DefMI.getOperand(1).getImm() + mimm2Val(DefMI.getOperand(2).getImm());
564*da58b97aSjoerg LLVM_DEBUG(dbgs() << "ImmVal is " << ImmVal << "\n");
565*da58b97aSjoerg break;
566*da58b97aSjoerg case VE::LEAzii:
567*da58b97aSjoerg // General move immediate instruction on VE.
568*da58b97aSjoerg LLVM_DEBUG(dbgs() << "checking LEAzii\n");
569*da58b97aSjoerg LLVM_DEBUG(DefMI.dump());
570*da58b97aSjoerg // FIXME: We may need to support FPImm too.
571*da58b97aSjoerg assert(DefMI.getOperand(2).isImm());
572*da58b97aSjoerg if (!DefMI.getOperand(3).isImm())
573*da58b97aSjoerg // LEAzii may refer label
574*da58b97aSjoerg return false;
575*da58b97aSjoerg ImmVal = DefMI.getOperand(2).getImm() + DefMI.getOperand(3).getImm();
576*da58b97aSjoerg LLVM_DEBUG(dbgs() << "ImmVal is " << ImmVal << "\n");
577*da58b97aSjoerg break;
578*da58b97aSjoerg }
579*da58b97aSjoerg
580*da58b97aSjoerg // Try to fold like below:
581*da58b97aSjoerg // %1:i64 = ORim 0, 0(1)
582*da58b97aSjoerg // %2:i64 = CMPSLrr %0, %1
583*da58b97aSjoerg // To
584*da58b97aSjoerg // %2:i64 = CMPSLrm %0, 0(1)
585*da58b97aSjoerg //
586*da58b97aSjoerg // Another example:
587*da58b97aSjoerg // %1:i64 = ORim 6, 0(1)
588*da58b97aSjoerg // %2:i64 = CMPSLrr %1, %0
589*da58b97aSjoerg // To
590*da58b97aSjoerg // %2:i64 = CMPSLir 6, %0
591*da58b97aSjoerg //
592*da58b97aSjoerg // Support commutable instructions like below:
593*da58b97aSjoerg // %1:i64 = ORim 6, 0(1)
594*da58b97aSjoerg // %2:i64 = ADDSLrr %1, %0
595*da58b97aSjoerg // To
596*da58b97aSjoerg // %2:i64 = ADDSLri %0, 6
597*da58b97aSjoerg //
598*da58b97aSjoerg // FIXME: Need to support i32. Current implementtation requires
599*da58b97aSjoerg // EXTRACT_SUBREG, so input has following COPY and it avoids folding:
600*da58b97aSjoerg // %1:i64 = ORim 6, 0(1)
601*da58b97aSjoerg // %2:i32 = COPY %1.sub_i32
602*da58b97aSjoerg // %3:i32 = ADDSWSXrr %0, %2
603*da58b97aSjoerg // FIXME: Need to support shift, cmov, and more instructions.
604*da58b97aSjoerg // FIXME: Need to support lvl too, but LVLGen runs after peephole-opt.
605*da58b97aSjoerg
606*da58b97aSjoerg LLVM_DEBUG(dbgs() << "checking UseMI\n");
607*da58b97aSjoerg LLVM_DEBUG(UseMI.dump());
608*da58b97aSjoerg unsigned NewUseOpcSImm7;
609*da58b97aSjoerg unsigned NewUseOpcMImm;
610*da58b97aSjoerg enum InstType {
611*da58b97aSjoerg rr2ri_rm, // rr -> ri or rm, commutable
612*da58b97aSjoerg rr2ir_rm, // rr -> ir or rm
613*da58b97aSjoerg } InstType;
614*da58b97aSjoerg
615*da58b97aSjoerg using namespace llvm::VE;
616*da58b97aSjoerg #define INSTRKIND(NAME) \
617*da58b97aSjoerg case NAME##rr: \
618*da58b97aSjoerg NewUseOpcSImm7 = NAME##ri; \
619*da58b97aSjoerg NewUseOpcMImm = NAME##rm; \
620*da58b97aSjoerg InstType = rr2ri_rm; \
621*da58b97aSjoerg break
622*da58b97aSjoerg #define NCINSTRKIND(NAME) \
623*da58b97aSjoerg case NAME##rr: \
624*da58b97aSjoerg NewUseOpcSImm7 = NAME##ir; \
625*da58b97aSjoerg NewUseOpcMImm = NAME##rm; \
626*da58b97aSjoerg InstType = rr2ir_rm; \
627*da58b97aSjoerg break
628*da58b97aSjoerg
629*da58b97aSjoerg switch (UseMI.getOpcode()) {
630*da58b97aSjoerg default:
631*da58b97aSjoerg return false;
632*da58b97aSjoerg
633*da58b97aSjoerg INSTRKIND(ADDUL);
634*da58b97aSjoerg INSTRKIND(ADDSWSX);
635*da58b97aSjoerg INSTRKIND(ADDSWZX);
636*da58b97aSjoerg INSTRKIND(ADDSL);
637*da58b97aSjoerg NCINSTRKIND(SUBUL);
638*da58b97aSjoerg NCINSTRKIND(SUBSWSX);
639*da58b97aSjoerg NCINSTRKIND(SUBSWZX);
640*da58b97aSjoerg NCINSTRKIND(SUBSL);
641*da58b97aSjoerg INSTRKIND(MULUL);
642*da58b97aSjoerg INSTRKIND(MULSWSX);
643*da58b97aSjoerg INSTRKIND(MULSWZX);
644*da58b97aSjoerg INSTRKIND(MULSL);
645*da58b97aSjoerg NCINSTRKIND(DIVUL);
646*da58b97aSjoerg NCINSTRKIND(DIVSWSX);
647*da58b97aSjoerg NCINSTRKIND(DIVSWZX);
648*da58b97aSjoerg NCINSTRKIND(DIVSL);
649*da58b97aSjoerg NCINSTRKIND(CMPUL);
650*da58b97aSjoerg NCINSTRKIND(CMPSWSX);
651*da58b97aSjoerg NCINSTRKIND(CMPSWZX);
652*da58b97aSjoerg NCINSTRKIND(CMPSL);
653*da58b97aSjoerg INSTRKIND(MAXSWSX);
654*da58b97aSjoerg INSTRKIND(MAXSWZX);
655*da58b97aSjoerg INSTRKIND(MAXSL);
656*da58b97aSjoerg INSTRKIND(MINSWSX);
657*da58b97aSjoerg INSTRKIND(MINSWZX);
658*da58b97aSjoerg INSTRKIND(MINSL);
659*da58b97aSjoerg INSTRKIND(AND);
660*da58b97aSjoerg INSTRKIND(OR);
661*da58b97aSjoerg INSTRKIND(XOR);
662*da58b97aSjoerg INSTRKIND(EQV);
663*da58b97aSjoerg NCINSTRKIND(NND);
664*da58b97aSjoerg NCINSTRKIND(MRG);
665*da58b97aSjoerg }
666*da58b97aSjoerg
667*da58b97aSjoerg #undef INSTRKIND
668*da58b97aSjoerg
669*da58b97aSjoerg unsigned NewUseOpc;
670*da58b97aSjoerg unsigned UseIdx;
671*da58b97aSjoerg bool Commute = false;
672*da58b97aSjoerg LLVM_DEBUG(dbgs() << "checking UseMI operands\n");
673*da58b97aSjoerg switch (InstType) {
674*da58b97aSjoerg case rr2ri_rm:
675*da58b97aSjoerg UseIdx = 2;
676*da58b97aSjoerg if (UseMI.getOperand(1).getReg() == Reg) {
677*da58b97aSjoerg Commute = true;
678*da58b97aSjoerg } else {
679*da58b97aSjoerg assert(UseMI.getOperand(2).getReg() == Reg);
680*da58b97aSjoerg }
681*da58b97aSjoerg if (isInt<7>(ImmVal)) {
682*da58b97aSjoerg // This ImmVal matches to SImm7 slot, so change UseOpc to an instruction
683*da58b97aSjoerg // holds a simm7 slot.
684*da58b97aSjoerg NewUseOpc = NewUseOpcSImm7;
685*da58b97aSjoerg } else if (isMImmVal(ImmVal)) {
686*da58b97aSjoerg // Similarly, change UseOpc to an instruction holds a mimm slot.
687*da58b97aSjoerg NewUseOpc = NewUseOpcMImm;
688*da58b97aSjoerg ImmVal = val2MImm(ImmVal);
689*da58b97aSjoerg } else
690*da58b97aSjoerg return false;
691*da58b97aSjoerg break;
692*da58b97aSjoerg case rr2ir_rm:
693*da58b97aSjoerg if (UseMI.getOperand(1).getReg() == Reg) {
694*da58b97aSjoerg // Check immediate value whether it matchs to the UseMI instruction.
695*da58b97aSjoerg if (!isInt<7>(ImmVal))
696*da58b97aSjoerg return false;
697*da58b97aSjoerg NewUseOpc = NewUseOpcSImm7;
698*da58b97aSjoerg UseIdx = 1;
699*da58b97aSjoerg } else {
700*da58b97aSjoerg assert(UseMI.getOperand(2).getReg() == Reg);
701*da58b97aSjoerg // Check immediate value whether it matchs to the UseMI instruction.
702*da58b97aSjoerg if (!isMImmVal(ImmVal))
703*da58b97aSjoerg return false;
704*da58b97aSjoerg NewUseOpc = NewUseOpcMImm;
705*da58b97aSjoerg ImmVal = val2MImm(ImmVal);
706*da58b97aSjoerg UseIdx = 2;
707*da58b97aSjoerg }
708*da58b97aSjoerg break;
709*da58b97aSjoerg }
710*da58b97aSjoerg
711*da58b97aSjoerg LLVM_DEBUG(dbgs() << "modifying UseMI\n");
712*da58b97aSjoerg bool DeleteDef = MRI->hasOneNonDBGUse(Reg);
713*da58b97aSjoerg UseMI.setDesc(get(NewUseOpc));
714*da58b97aSjoerg if (Commute) {
715*da58b97aSjoerg UseMI.getOperand(1).setReg(UseMI.getOperand(UseIdx).getReg());
716*da58b97aSjoerg }
717*da58b97aSjoerg UseMI.getOperand(UseIdx).ChangeToImmediate(ImmVal);
718*da58b97aSjoerg if (DeleteDef)
719*da58b97aSjoerg DefMI.eraseFromParent();
720*da58b97aSjoerg
721*da58b97aSjoerg return true;
722*da58b97aSjoerg }
723*da58b97aSjoerg
getGlobalBaseReg(MachineFunction * MF) const724*da58b97aSjoerg Register VEInstrInfo::getGlobalBaseReg(MachineFunction *MF) const {
725*da58b97aSjoerg VEMachineFunctionInfo *VEFI = MF->getInfo<VEMachineFunctionInfo>();
726*da58b97aSjoerg Register GlobalBaseReg = VEFI->getGlobalBaseReg();
727*da58b97aSjoerg if (GlobalBaseReg != 0)
728*da58b97aSjoerg return GlobalBaseReg;
729*da58b97aSjoerg
730*da58b97aSjoerg // We use %s15 (%got) as a global base register
731*da58b97aSjoerg GlobalBaseReg = VE::SX15;
732*da58b97aSjoerg
733*da58b97aSjoerg // Insert a pseudo instruction to set the GlobalBaseReg into the first
734*da58b97aSjoerg // MBB of the function
735*da58b97aSjoerg MachineBasicBlock &FirstMBB = MF->front();
736*da58b97aSjoerg MachineBasicBlock::iterator MBBI = FirstMBB.begin();
737*da58b97aSjoerg DebugLoc dl;
738*da58b97aSjoerg BuildMI(FirstMBB, MBBI, dl, get(VE::GETGOT), GlobalBaseReg);
739*da58b97aSjoerg VEFI->setGlobalBaseReg(GlobalBaseReg);
740*da58b97aSjoerg return GlobalBaseReg;
741*da58b97aSjoerg }
742*da58b97aSjoerg
getVM512Upper(Register reg)743*da58b97aSjoerg static Register getVM512Upper(Register reg) {
744*da58b97aSjoerg return (reg - VE::VMP0) * 2 + VE::VM0;
745*da58b97aSjoerg }
746*da58b97aSjoerg
getVM512Lower(Register reg)747*da58b97aSjoerg static Register getVM512Lower(Register reg) { return getVM512Upper(reg) + 1; }
748*da58b97aSjoerg
749*da58b97aSjoerg // Expand pseudo logical vector instructions for VM512 registers.
expandPseudoLogM(MachineInstr & MI,const MCInstrDesc & MCID)750*da58b97aSjoerg static void expandPseudoLogM(MachineInstr &MI, const MCInstrDesc &MCID) {
751*da58b97aSjoerg MachineBasicBlock *MBB = MI.getParent();
752*da58b97aSjoerg DebugLoc DL = MI.getDebugLoc();
753*da58b97aSjoerg
754*da58b97aSjoerg Register VMXu = getVM512Upper(MI.getOperand(0).getReg());
755*da58b97aSjoerg Register VMXl = getVM512Lower(MI.getOperand(0).getReg());
756*da58b97aSjoerg Register VMYu = getVM512Upper(MI.getOperand(1).getReg());
757*da58b97aSjoerg Register VMYl = getVM512Lower(MI.getOperand(1).getReg());
758*da58b97aSjoerg
759*da58b97aSjoerg switch (MI.getOpcode()) {
760*da58b97aSjoerg default: {
761*da58b97aSjoerg Register VMZu = getVM512Upper(MI.getOperand(2).getReg());
762*da58b97aSjoerg Register VMZl = getVM512Lower(MI.getOperand(2).getReg());
763*da58b97aSjoerg BuildMI(*MBB, MI, DL, MCID).addDef(VMXu).addUse(VMYu).addUse(VMZu);
764*da58b97aSjoerg BuildMI(*MBB, MI, DL, MCID).addDef(VMXl).addUse(VMYl).addUse(VMZl);
765*da58b97aSjoerg break;
766*da58b97aSjoerg }
767*da58b97aSjoerg case VE::NEGMy:
768*da58b97aSjoerg BuildMI(*MBB, MI, DL, MCID).addDef(VMXu).addUse(VMYu);
769*da58b97aSjoerg BuildMI(*MBB, MI, DL, MCID).addDef(VMXl).addUse(VMYl);
770*da58b97aSjoerg break;
771*da58b97aSjoerg }
772*da58b97aSjoerg MI.eraseFromParent();
773*da58b97aSjoerg }
774*da58b97aSjoerg
addOperandsForVFMK(MachineInstrBuilder & MIB,MachineInstr & MI,bool Upper)775*da58b97aSjoerg static void addOperandsForVFMK(MachineInstrBuilder &MIB, MachineInstr &MI,
776*da58b97aSjoerg bool Upper) {
777*da58b97aSjoerg // VM512
778*da58b97aSjoerg MIB.addReg(Upper ? getVM512Upper(MI.getOperand(0).getReg())
779*da58b97aSjoerg : getVM512Lower(MI.getOperand(0).getReg()));
780*da58b97aSjoerg
781*da58b97aSjoerg switch (MI.getNumExplicitOperands()) {
782*da58b97aSjoerg default:
783*da58b97aSjoerg report_fatal_error("unexpected number of operands for pvfmk");
784*da58b97aSjoerg case 2: // _Ml: VM512, VL
785*da58b97aSjoerg // VL
786*da58b97aSjoerg MIB.addReg(MI.getOperand(1).getReg());
787*da58b97aSjoerg break;
788*da58b97aSjoerg case 4: // _Mvl: VM512, CC, VR, VL
789*da58b97aSjoerg // CC
790*da58b97aSjoerg MIB.addImm(MI.getOperand(1).getImm());
791*da58b97aSjoerg // VR
792*da58b97aSjoerg MIB.addReg(MI.getOperand(2).getReg());
793*da58b97aSjoerg // VL
794*da58b97aSjoerg MIB.addReg(MI.getOperand(3).getReg());
795*da58b97aSjoerg break;
796*da58b97aSjoerg case 5: // _MvMl: VM512, CC, VR, VM512, VL
797*da58b97aSjoerg // CC
798*da58b97aSjoerg MIB.addImm(MI.getOperand(1).getImm());
799*da58b97aSjoerg // VR
800*da58b97aSjoerg MIB.addReg(MI.getOperand(2).getReg());
801*da58b97aSjoerg // VM512
802*da58b97aSjoerg MIB.addReg(Upper ? getVM512Upper(MI.getOperand(3).getReg())
803*da58b97aSjoerg : getVM512Lower(MI.getOperand(3).getReg()));
804*da58b97aSjoerg // VL
805*da58b97aSjoerg MIB.addReg(MI.getOperand(4).getReg());
806*da58b97aSjoerg break;
807*da58b97aSjoerg }
808*da58b97aSjoerg }
809*da58b97aSjoerg
expandPseudoVFMK(const TargetInstrInfo & TI,MachineInstr & MI)810*da58b97aSjoerg static void expandPseudoVFMK(const TargetInstrInfo &TI, MachineInstr &MI) {
811*da58b97aSjoerg // replace to pvfmk.w.up and pvfmk.w.lo
812*da58b97aSjoerg // replace to pvfmk.s.up and pvfmk.s.lo
813*da58b97aSjoerg
814*da58b97aSjoerg static std::map<unsigned, std::pair<unsigned, unsigned>> VFMKMap = {
815*da58b97aSjoerg {VE::VFMKyal, {VE::VFMKLal, VE::VFMKLal}},
816*da58b97aSjoerg {VE::VFMKynal, {VE::VFMKLnal, VE::VFMKLnal}},
817*da58b97aSjoerg {VE::VFMKWyvl, {VE::PVFMKWUPvl, VE::PVFMKWLOvl}},
818*da58b97aSjoerg {VE::VFMKWyvyl, {VE::PVFMKWUPvml, VE::PVFMKWLOvml}},
819*da58b97aSjoerg {VE::VFMKSyvl, {VE::PVFMKSUPvl, VE::PVFMKSLOvl}},
820*da58b97aSjoerg {VE::VFMKSyvyl, {VE::PVFMKSUPvml, VE::PVFMKSLOvml}},
821*da58b97aSjoerg };
822*da58b97aSjoerg
823*da58b97aSjoerg unsigned Opcode = MI.getOpcode();
824*da58b97aSjoerg
825*da58b97aSjoerg auto Found = VFMKMap.find(Opcode);
826*da58b97aSjoerg if (Found == VFMKMap.end())
827*da58b97aSjoerg report_fatal_error("unexpected opcode for pseudo vfmk");
828*da58b97aSjoerg
829*da58b97aSjoerg unsigned OpcodeUpper = (*Found).second.first;
830*da58b97aSjoerg unsigned OpcodeLower = (*Found).second.second;
831*da58b97aSjoerg
832*da58b97aSjoerg MachineBasicBlock *MBB = MI.getParent();
833*da58b97aSjoerg DebugLoc DL = MI.getDebugLoc();
834*da58b97aSjoerg
835*da58b97aSjoerg MachineInstrBuilder Bu = BuildMI(*MBB, MI, DL, TI.get(OpcodeUpper));
836*da58b97aSjoerg addOperandsForVFMK(Bu, MI, /* Upper */ true);
837*da58b97aSjoerg MachineInstrBuilder Bl = BuildMI(*MBB, MI, DL, TI.get(OpcodeLower));
838*da58b97aSjoerg addOperandsForVFMK(Bl, MI, /* Upper */ false);
839*da58b97aSjoerg
840*da58b97aSjoerg MI.eraseFromParent();
841*da58b97aSjoerg }
842*da58b97aSjoerg
expandPostRAPseudo(MachineInstr & MI) const843*da58b97aSjoerg bool VEInstrInfo::expandPostRAPseudo(MachineInstr &MI) const {
844*da58b97aSjoerg switch (MI.getOpcode()) {
845*da58b97aSjoerg case VE::EXTEND_STACK: {
846*da58b97aSjoerg return expandExtendStackPseudo(MI);
847*da58b97aSjoerg }
848*da58b97aSjoerg case VE::EXTEND_STACK_GUARD: {
849*da58b97aSjoerg MI.eraseFromParent(); // The pseudo instruction is gone now.
850*da58b97aSjoerg return true;
851*da58b97aSjoerg }
852*da58b97aSjoerg case VE::GETSTACKTOP: {
853*da58b97aSjoerg return expandGetStackTopPseudo(MI);
854*da58b97aSjoerg }
855*da58b97aSjoerg
856*da58b97aSjoerg case VE::ANDMyy:
857*da58b97aSjoerg expandPseudoLogM(MI, get(VE::ANDMmm));
858*da58b97aSjoerg return true;
859*da58b97aSjoerg case VE::ORMyy:
860*da58b97aSjoerg expandPseudoLogM(MI, get(VE::ORMmm));
861*da58b97aSjoerg return true;
862*da58b97aSjoerg case VE::XORMyy:
863*da58b97aSjoerg expandPseudoLogM(MI, get(VE::XORMmm));
864*da58b97aSjoerg return true;
865*da58b97aSjoerg case VE::EQVMyy:
866*da58b97aSjoerg expandPseudoLogM(MI, get(VE::EQVMmm));
867*da58b97aSjoerg return true;
868*da58b97aSjoerg case VE::NNDMyy:
869*da58b97aSjoerg expandPseudoLogM(MI, get(VE::NNDMmm));
870*da58b97aSjoerg return true;
871*da58b97aSjoerg case VE::NEGMy:
872*da58b97aSjoerg expandPseudoLogM(MI, get(VE::NEGMm));
873*da58b97aSjoerg return true;
874*da58b97aSjoerg
875*da58b97aSjoerg case VE::LVMyir:
876*da58b97aSjoerg case VE::LVMyim:
877*da58b97aSjoerg case VE::LVMyir_y:
878*da58b97aSjoerg case VE::LVMyim_y: {
879*da58b97aSjoerg Register VMXu = getVM512Upper(MI.getOperand(0).getReg());
880*da58b97aSjoerg Register VMXl = getVM512Lower(MI.getOperand(0).getReg());
881*da58b97aSjoerg int64_t Imm = MI.getOperand(1).getImm();
882*da58b97aSjoerg bool IsSrcReg =
883*da58b97aSjoerg MI.getOpcode() == VE::LVMyir || MI.getOpcode() == VE::LVMyir_y;
884*da58b97aSjoerg Register Src = IsSrcReg ? MI.getOperand(2).getReg() : VE::NoRegister;
885*da58b97aSjoerg int64_t MImm = IsSrcReg ? 0 : MI.getOperand(2).getImm();
886*da58b97aSjoerg bool KillSrc = IsSrcReg ? MI.getOperand(2).isKill() : false;
887*da58b97aSjoerg Register VMX = VMXl;
888*da58b97aSjoerg if (Imm >= 4) {
889*da58b97aSjoerg VMX = VMXu;
890*da58b97aSjoerg Imm -= 4;
891*da58b97aSjoerg }
892*da58b97aSjoerg MachineBasicBlock *MBB = MI.getParent();
893*da58b97aSjoerg DebugLoc DL = MI.getDebugLoc();
894*da58b97aSjoerg switch (MI.getOpcode()) {
895*da58b97aSjoerg case VE::LVMyir:
896*da58b97aSjoerg BuildMI(*MBB, MI, DL, get(VE::LVMir))
897*da58b97aSjoerg .addDef(VMX)
898*da58b97aSjoerg .addImm(Imm)
899*da58b97aSjoerg .addReg(Src, getKillRegState(KillSrc));
900*da58b97aSjoerg break;
901*da58b97aSjoerg case VE::LVMyim:
902*da58b97aSjoerg BuildMI(*MBB, MI, DL, get(VE::LVMim))
903*da58b97aSjoerg .addDef(VMX)
904*da58b97aSjoerg .addImm(Imm)
905*da58b97aSjoerg .addImm(MImm);
906*da58b97aSjoerg break;
907*da58b97aSjoerg case VE::LVMyir_y:
908*da58b97aSjoerg assert(MI.getOperand(0).getReg() == MI.getOperand(3).getReg() &&
909*da58b97aSjoerg "LVMyir_y has different register in 3rd operand");
910*da58b97aSjoerg BuildMI(*MBB, MI, DL, get(VE::LVMir_m))
911*da58b97aSjoerg .addDef(VMX)
912*da58b97aSjoerg .addImm(Imm)
913*da58b97aSjoerg .addReg(Src, getKillRegState(KillSrc))
914*da58b97aSjoerg .addReg(VMX);
915*da58b97aSjoerg break;
916*da58b97aSjoerg case VE::LVMyim_y:
917*da58b97aSjoerg assert(MI.getOperand(0).getReg() == MI.getOperand(3).getReg() &&
918*da58b97aSjoerg "LVMyim_y has different register in 3rd operand");
919*da58b97aSjoerg BuildMI(*MBB, MI, DL, get(VE::LVMim_m))
920*da58b97aSjoerg .addDef(VMX)
921*da58b97aSjoerg .addImm(Imm)
922*da58b97aSjoerg .addImm(MImm)
923*da58b97aSjoerg .addReg(VMX);
924*da58b97aSjoerg break;
925*da58b97aSjoerg }
926*da58b97aSjoerg MI.eraseFromParent();
927*da58b97aSjoerg return true;
928*da58b97aSjoerg }
929*da58b97aSjoerg case VE::SVMyi: {
930*da58b97aSjoerg Register Dest = MI.getOperand(0).getReg();
931*da58b97aSjoerg Register VMZu = getVM512Upper(MI.getOperand(1).getReg());
932*da58b97aSjoerg Register VMZl = getVM512Lower(MI.getOperand(1).getReg());
933*da58b97aSjoerg bool KillSrc = MI.getOperand(1).isKill();
934*da58b97aSjoerg int64_t Imm = MI.getOperand(2).getImm();
935*da58b97aSjoerg Register VMZ = VMZl;
936*da58b97aSjoerg if (Imm >= 4) {
937*da58b97aSjoerg VMZ = VMZu;
938*da58b97aSjoerg Imm -= 4;
939*da58b97aSjoerg }
940*da58b97aSjoerg MachineBasicBlock *MBB = MI.getParent();
941*da58b97aSjoerg DebugLoc DL = MI.getDebugLoc();
942*da58b97aSjoerg MachineInstrBuilder MIB =
943*da58b97aSjoerg BuildMI(*MBB, MI, DL, get(VE::SVMmi), Dest).addReg(VMZ).addImm(Imm);
944*da58b97aSjoerg MachineInstr *Inst = MIB.getInstr();
945*da58b97aSjoerg MI.eraseFromParent();
946*da58b97aSjoerg if (KillSrc) {
947*da58b97aSjoerg const TargetRegisterInfo *TRI = &getRegisterInfo();
948*da58b97aSjoerg Inst->addRegisterKilled(MI.getOperand(1).getReg(), TRI, true);
949*da58b97aSjoerg }
950*da58b97aSjoerg return true;
951*da58b97aSjoerg }
952*da58b97aSjoerg case VE::VFMKyal:
953*da58b97aSjoerg case VE::VFMKynal:
954*da58b97aSjoerg case VE::VFMKWyvl:
955*da58b97aSjoerg case VE::VFMKWyvyl:
956*da58b97aSjoerg case VE::VFMKSyvl:
957*da58b97aSjoerg case VE::VFMKSyvyl:
958*da58b97aSjoerg expandPseudoVFMK(*this, MI);
959*da58b97aSjoerg }
960*da58b97aSjoerg return false;
961*da58b97aSjoerg }
962*da58b97aSjoerg
expandExtendStackPseudo(MachineInstr & MI) const963*da58b97aSjoerg bool VEInstrInfo::expandExtendStackPseudo(MachineInstr &MI) const {
964*da58b97aSjoerg MachineBasicBlock &MBB = *MI.getParent();
965*da58b97aSjoerg MachineFunction &MF = *MBB.getParent();
966*da58b97aSjoerg const VESubtarget &STI = MF.getSubtarget<VESubtarget>();
967*da58b97aSjoerg const VEInstrInfo &TII = *STI.getInstrInfo();
968*da58b97aSjoerg DebugLoc dl = MBB.findDebugLoc(MI);
969*da58b97aSjoerg
970*da58b97aSjoerg // Create following instructions and multiple basic blocks.
971*da58b97aSjoerg //
972*da58b97aSjoerg // thisBB:
973*da58b97aSjoerg // brge.l.t %sp, %sl, sinkBB
974*da58b97aSjoerg // syscallBB:
975*da58b97aSjoerg // ld %s61, 0x18(, %tp) // load param area
976*da58b97aSjoerg // or %s62, 0, %s0 // spill the value of %s0
977*da58b97aSjoerg // lea %s63, 0x13b // syscall # of grow
978*da58b97aSjoerg // shm.l %s63, 0x0(%s61) // store syscall # at addr:0
979*da58b97aSjoerg // shm.l %sl, 0x8(%s61) // store old limit at addr:8
980*da58b97aSjoerg // shm.l %sp, 0x10(%s61) // store new limit at addr:16
981*da58b97aSjoerg // monc // call monitor
982*da58b97aSjoerg // or %s0, 0, %s62 // restore the value of %s0
983*da58b97aSjoerg // sinkBB:
984*da58b97aSjoerg
985*da58b97aSjoerg // Create new MBB
986*da58b97aSjoerg MachineBasicBlock *BB = &MBB;
987*da58b97aSjoerg const BasicBlock *LLVM_BB = BB->getBasicBlock();
988*da58b97aSjoerg MachineBasicBlock *syscallMBB = MF.CreateMachineBasicBlock(LLVM_BB);
989*da58b97aSjoerg MachineBasicBlock *sinkMBB = MF.CreateMachineBasicBlock(LLVM_BB);
990*da58b97aSjoerg MachineFunction::iterator It = ++(BB->getIterator());
991*da58b97aSjoerg MF.insert(It, syscallMBB);
992*da58b97aSjoerg MF.insert(It, sinkMBB);
993*da58b97aSjoerg
994*da58b97aSjoerg // Transfer the remainder of BB and its successor edges to sinkMBB.
995*da58b97aSjoerg sinkMBB->splice(sinkMBB->begin(), BB,
996*da58b97aSjoerg std::next(std::next(MachineBasicBlock::iterator(MI))),
997*da58b97aSjoerg BB->end());
998*da58b97aSjoerg sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
999*da58b97aSjoerg
1000*da58b97aSjoerg // Next, add the true and fallthrough blocks as its successors.
1001*da58b97aSjoerg BB->addSuccessor(syscallMBB);
1002*da58b97aSjoerg BB->addSuccessor(sinkMBB);
1003*da58b97aSjoerg BuildMI(BB, dl, TII.get(VE::BRCFLrr_t))
1004*da58b97aSjoerg .addImm(VECC::CC_IGE)
1005*da58b97aSjoerg .addReg(VE::SX11) // %sp
1006*da58b97aSjoerg .addReg(VE::SX8) // %sl
1007*da58b97aSjoerg .addMBB(sinkMBB);
1008*da58b97aSjoerg
1009*da58b97aSjoerg BB = syscallMBB;
1010*da58b97aSjoerg
1011*da58b97aSjoerg // Update machine-CFG edges
1012*da58b97aSjoerg BB->addSuccessor(sinkMBB);
1013*da58b97aSjoerg
1014*da58b97aSjoerg BuildMI(BB, dl, TII.get(VE::LDrii), VE::SX61)
1015*da58b97aSjoerg .addReg(VE::SX14)
1016*da58b97aSjoerg .addImm(0)
1017*da58b97aSjoerg .addImm(0x18);
1018*da58b97aSjoerg BuildMI(BB, dl, TII.get(VE::ORri), VE::SX62)
1019*da58b97aSjoerg .addReg(VE::SX0)
1020*da58b97aSjoerg .addImm(0);
1021*da58b97aSjoerg BuildMI(BB, dl, TII.get(VE::LEAzii), VE::SX63)
1022*da58b97aSjoerg .addImm(0)
1023*da58b97aSjoerg .addImm(0)
1024*da58b97aSjoerg .addImm(0x13b);
1025*da58b97aSjoerg BuildMI(BB, dl, TII.get(VE::SHMLri))
1026*da58b97aSjoerg .addReg(VE::SX61)
1027*da58b97aSjoerg .addImm(0)
1028*da58b97aSjoerg .addReg(VE::SX63);
1029*da58b97aSjoerg BuildMI(BB, dl, TII.get(VE::SHMLri))
1030*da58b97aSjoerg .addReg(VE::SX61)
1031*da58b97aSjoerg .addImm(8)
1032*da58b97aSjoerg .addReg(VE::SX8);
1033*da58b97aSjoerg BuildMI(BB, dl, TII.get(VE::SHMLri))
1034*da58b97aSjoerg .addReg(VE::SX61)
1035*da58b97aSjoerg .addImm(16)
1036*da58b97aSjoerg .addReg(VE::SX11);
1037*da58b97aSjoerg BuildMI(BB, dl, TII.get(VE::MONC));
1038*da58b97aSjoerg
1039*da58b97aSjoerg BuildMI(BB, dl, TII.get(VE::ORri), VE::SX0)
1040*da58b97aSjoerg .addReg(VE::SX62)
1041*da58b97aSjoerg .addImm(0);
1042*da58b97aSjoerg
1043*da58b97aSjoerg MI.eraseFromParent(); // The pseudo instruction is gone now.
1044*da58b97aSjoerg return true;
1045*da58b97aSjoerg }
1046*da58b97aSjoerg
expandGetStackTopPseudo(MachineInstr & MI) const1047*da58b97aSjoerg bool VEInstrInfo::expandGetStackTopPseudo(MachineInstr &MI) const {
1048*da58b97aSjoerg MachineBasicBlock *MBB = MI.getParent();
1049*da58b97aSjoerg MachineFunction &MF = *MBB->getParent();
1050*da58b97aSjoerg const VESubtarget &STI = MF.getSubtarget<VESubtarget>();
1051*da58b97aSjoerg const VEInstrInfo &TII = *STI.getInstrInfo();
1052*da58b97aSjoerg DebugLoc DL = MBB->findDebugLoc(MI);
1053*da58b97aSjoerg
1054*da58b97aSjoerg // Create following instruction
1055*da58b97aSjoerg //
1056*da58b97aSjoerg // dst = %sp + target specific frame + the size of parameter area
1057*da58b97aSjoerg
1058*da58b97aSjoerg const MachineFrameInfo &MFI = MF.getFrameInfo();
1059*da58b97aSjoerg const VEFrameLowering &TFL = *STI.getFrameLowering();
1060*da58b97aSjoerg
1061*da58b97aSjoerg // The VE ABI requires a reserved area at the top of stack as described
1062*da58b97aSjoerg // in VEFrameLowering.cpp. So, we adjust it here.
1063*da58b97aSjoerg unsigned NumBytes = STI.getAdjustedFrameSize(0);
1064*da58b97aSjoerg
1065*da58b97aSjoerg // Also adds the size of parameter area.
1066*da58b97aSjoerg if (MFI.adjustsStack() && TFL.hasReservedCallFrame(MF))
1067*da58b97aSjoerg NumBytes += MFI.getMaxCallFrameSize();
1068*da58b97aSjoerg
1069*da58b97aSjoerg BuildMI(*MBB, MI, DL, TII.get(VE::LEArii))
1070*da58b97aSjoerg .addDef(MI.getOperand(0).getReg())
1071*da58b97aSjoerg .addReg(VE::SX11)
1072*da58b97aSjoerg .addImm(0)
1073*da58b97aSjoerg .addImm(NumBytes);
1074*da58b97aSjoerg
1075*da58b97aSjoerg MI.eraseFromParent(); // The pseudo instruction is gone now.
1076*da58b97aSjoerg return true;
1077*da58b97aSjoerg }
1078