1 //===-- R600ExpandSpecialInstrs.cpp - Expand special instructions ---------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
9 // Vector, Reduction, and Cube instructions need to fill the entire instruction
10 // group to work correctly. This pass expands these individual instructions
11 // into several instructions that will completely fill the instruction group.
12 //===----------------------------------------------------------------------===//
15 #include "R600Defines.h"
16 #include "R600InstrInfo.h"
17 #include "R600RegisterInfo.h"
18 #include "R600MachineFunctionInfo.h"
19 #include "llvm/CodeGen/MachineFunctionPass.h"
20 #include "llvm/CodeGen/MachineInstrBuilder.h"
21 #include "llvm/CodeGen/MachineRegisterInfo.h"
27 class R600ExpandSpecialInstrsPass
: public MachineFunctionPass
{
31 const R600InstrInfo
*TII
;
33 bool ExpandInputPerspective(MachineInstr
& MI
);
34 bool ExpandInputConstant(MachineInstr
& MI
);
37 R600ExpandSpecialInstrsPass(TargetMachine
&tm
) : MachineFunctionPass(ID
),
38 TII (static_cast<const R600InstrInfo
*>(tm
.getInstrInfo())) { }
40 virtual bool runOnMachineFunction(MachineFunction
&MF
);
42 const char *getPassName() const {
43 return "R600 Expand special instructions pass";
47 } // End anonymous namespace
49 char R600ExpandSpecialInstrsPass::ID
= 0;
51 FunctionPass
*llvm::createR600ExpandSpecialInstrsPass(TargetMachine
&TM
) {
52 return new R600ExpandSpecialInstrsPass(TM
);
55 bool R600ExpandSpecialInstrsPass::ExpandInputPerspective(MachineInstr
&MI
)
57 const R600RegisterInfo
&TRI
= TII
->getRegisterInfo();
58 if (MI
.getOpcode() != AMDGPU::input_perspective
)
61 MachineBasicBlock::iterator I
= &MI
;
62 unsigned DstReg
= MI
.getOperand(0).getReg();
63 R600MachineFunctionInfo
*MFI
= MI
.getParent()->getParent()
64 ->getInfo
<R600MachineFunctionInfo
>();
67 // In Evergreen ISA doc section 8.3.2 :
68 // We need to interpolate XY and ZW in two different instruction groups.
69 // An INTERP_* must occupy all 4 slots of an instruction group.
70 // Output of INTERP_XY is written in X,Y slots
71 // Output of INTERP_ZW is written in Z,W slots
73 // Thus interpolation requires the following sequences :
75 // AnyGPR.x = INTERP_ZW; (Write Masked Out)
76 // AnyGPR.y = INTERP_ZW; (Write Masked Out)
77 // DstGPR.z = INTERP_ZW;
78 // DstGPR.w = INTERP_ZW; (End of first IG)
79 // DstGPR.x = INTERP_XY;
80 // DstGPR.y = INTERP_XY;
81 // AnyGPR.z = INTERP_XY; (Write Masked Out)
82 // AnyGPR.w = INTERP_XY; (Write Masked Out) (End of second IG)
84 switch (MI
.getOperand(1).getImm()) {
86 IJIndexBase
= MFI
->GetIJPerspectiveIndex();
89 IJIndexBase
= MFI
->GetIJLinearIndex();
92 assert(0 && "Unknow ij index");
95 for (unsigned i
= 0; i
< 8; i
++) {
96 unsigned IJIndex
= AMDGPU::R600_TReg32RegClass
.getRegister(
97 2 * IJIndexBase
+ ((i
+ 1) % 2));
98 unsigned ReadReg
= AMDGPU::R600_TReg32RegClass
.getRegister(
99 4 * MI
.getOperand(2).getImm());
103 case 0:Sel
= AMDGPU::sel_x
;break;
104 case 1:Sel
= AMDGPU::sel_y
;break;
105 case 2:Sel
= AMDGPU::sel_z
;break;
106 case 3:Sel
= AMDGPU::sel_w
;break;
110 unsigned Res
= TRI
.getSubReg(DstReg
, Sel
);
112 const MCInstrDesc
&Opcode
= (i
< 4)?
113 TII
->get(AMDGPU::INTERP_ZW
):
114 TII
->get(AMDGPU::INTERP_XY
);
116 MachineInstr
*NewMI
= BuildMI(*(MI
.getParent()),
117 I
, MI
.getParent()->findDebugLoc(I
),
123 if (!(i
> 1 && i
< 6)) {
124 TII
->addFlag(NewMI
, 0, MO_FLAG_MASK
);
128 TII
->addFlag(NewMI
, 0, MO_FLAG_NOT_LAST
);
131 MI
.eraseFromParent();
136 bool R600ExpandSpecialInstrsPass::ExpandInputConstant(MachineInstr
&MI
)
138 const R600RegisterInfo
&TRI
= TII
->getRegisterInfo();
139 if (MI
.getOpcode() != AMDGPU::input_constant
)
142 MachineBasicBlock::iterator I
= &MI
;
143 unsigned DstReg
= MI
.getOperand(0).getReg();
145 for (unsigned i
= 0; i
< 4; i
++) {
146 unsigned ReadReg
= AMDGPU::R600_TReg32RegClass
.getRegister(
147 4 * MI
.getOperand(1).getImm() + i
);
151 case 0:Sel
= AMDGPU::sel_x
;break;
152 case 1:Sel
= AMDGPU::sel_y
;break;
153 case 2:Sel
= AMDGPU::sel_z
;break;
154 case 3:Sel
= AMDGPU::sel_w
;break;
158 unsigned Res
= TRI
.getSubReg(DstReg
, Sel
);
160 MachineInstr
*NewMI
= BuildMI(*(MI
.getParent()),
161 I
, MI
.getParent()->findDebugLoc(I
),
162 TII
->get(AMDGPU::INTERP_LOAD_P0
), Res
)
167 TII
->addFlag(NewMI
, 0, MO_FLAG_NOT_LAST
);
170 MI
.eraseFromParent();
175 bool R600ExpandSpecialInstrsPass::runOnMachineFunction(MachineFunction
&MF
) {
177 const R600RegisterInfo
&TRI
= TII
->getRegisterInfo();
179 for (MachineFunction::iterator BB
= MF
.begin(), BB_E
= MF
.end();
181 MachineBasicBlock
&MBB
= *BB
;
182 MachineBasicBlock::iterator I
= MBB
.begin();
183 while (I
!= MBB
.end()) {
184 MachineInstr
&MI
= *I
;
187 if (ExpandInputPerspective(MI
))
189 if (ExpandInputConstant(MI
))
192 bool IsReduction
= TII
->isReductionOp(MI
.getOpcode());
193 bool IsVector
= TII
->isVector(MI
);
194 bool IsCube
= TII
->isCubeOp(MI
.getOpcode());
195 if (!IsReduction
&& !IsVector
&& !IsCube
) {
199 // Expand the instruction
201 // Reduction instructions:
202 // T0_X = DP4 T1_XYZW, T2_XYZW
204 // TO_X = DP4 T1_X, T2_X
205 // TO_Y (write masked) = DP4 T1_Y, T2_Y
206 // TO_Z (write masked) = DP4 T1_Z, T2_Z
207 // TO_W (write masked) = DP4 T1_W, T2_W
209 // Vector instructions:
210 // T0_X = MULLO_INT T1_X, T2_X
212 // T0_X = MULLO_INT T1_X, T2_X
213 // T0_Y (write masked) = MULLO_INT T1_X, T2_X
214 // T0_Z (write masked) = MULLO_INT T1_X, T2_X
215 // T0_W (write masked) = MULLO_INT T1_X, T2_X
217 // Cube instructions:
218 // T0_XYZW = CUBE T1_XYZW
220 // TO_X = CUBE T1_Z, T1_Y
221 // T0_Y = CUBE T1_Z, T1_X
222 // T0_Z = CUBE T1_X, T1_Z
223 // T0_W = CUBE T1_Y, T1_Z
224 for (unsigned Chan
= 0; Chan
< 4; Chan
++) {
225 unsigned DstReg
= MI
.getOperand(0).getReg();
226 unsigned Src0
= MI
.getOperand(1).getReg();
229 // Determine the correct source registers
231 Src1
= MI
.getOperand(2).getReg();
234 unsigned SubRegIndex
= TRI
.getSubRegFromChannel(Chan
);
235 Src0
= TRI
.getSubReg(Src0
, SubRegIndex
);
236 Src1
= TRI
.getSubReg(Src1
, SubRegIndex
);
238 static const int CubeSrcSwz
[] = {2, 2, 0, 1};
239 unsigned SubRegIndex0
= TRI
.getSubRegFromChannel(CubeSrcSwz
[Chan
]);
240 unsigned SubRegIndex1
= TRI
.getSubRegFromChannel(CubeSrcSwz
[3 - Chan
]);
241 Src1
= TRI
.getSubReg(Src0
, SubRegIndex1
);
242 Src0
= TRI
.getSubReg(Src0
, SubRegIndex0
);
245 // Determine the correct destination registers;
248 unsigned SubRegIndex
= TRI
.getSubRegFromChannel(Chan
);
249 DstReg
= TRI
.getSubReg(DstReg
, SubRegIndex
);
251 // Mask the write if the original instruction does not write to
252 // the current Channel.
253 Flags
|= (Chan
!= TRI
.getHWRegChan(DstReg
) ? MO_FLAG_MASK
: 0);
254 unsigned DstBase
= TRI
.getHWRegIndex(DstReg
);
255 DstReg
= AMDGPU::R600_TReg32RegClass
.getRegister((DstBase
* 4) + Chan
);
258 // Set the IsLast bit
259 Flags
|= (Chan
!= 3 ? MO_FLAG_NOT_LAST
: 0);
261 // Add the new instruction
264 switch (MI
.getOpcode()) {
265 case AMDGPU::CUBE_r600_pseudo
:
266 Opcode
= AMDGPU::CUBE_r600_real
;
268 case AMDGPU::CUBE_eg_pseudo
:
269 Opcode
= AMDGPU::CUBE_eg_real
;
272 assert(!"Unknown CUBE instruction");
277 Opcode
= MI
.getOpcode();
279 MachineInstr
*NewMI
=
280 BuildMI(MBB
, I
, MBB
.findDebugLoc(I
), TII
->get(Opcode
), DstReg
)
285 NewMI
->setIsInsideBundle(Chan
!= 0);
286 TII
->addFlag(NewMI
, 0, Flags
);
288 MI
.eraseFromParent();