1 //===-- SIInstrInfo.cpp - SI Instruction Information ---------------------===//
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 //===----------------------------------------------------------------------===//
10 // SI Implementation of TargetInstrInfo.
12 //===----------------------------------------------------------------------===//
15 #include "SIInstrInfo.h"
16 #include "AMDGPUTargetMachine.h"
17 #include "llvm/CodeGen/MachineRegisterInfo.h"
18 #include "llvm/MC/MCInstrDesc.h"
24 SIInstrInfo::SIInstrInfo(AMDGPUTargetMachine
&tm
)
25 : AMDGPUInstrInfo(tm
),
30 const SIRegisterInfo
&SIInstrInfo::getRegisterInfo() const
36 SIInstrInfo::copyPhysReg(MachineBasicBlock
&MBB
,
37 MachineBasicBlock::iterator MI
, DebugLoc DL
,
38 unsigned DestReg
, unsigned SrcReg
,
41 BuildMI(MBB
, MI
, DL
, get(AMDIL::V_MOV_B32_e32
), DestReg
)
42 .addReg(SrcReg
, getKillRegState(KillSrc
));
45 unsigned SIInstrInfo::getEncodingType(const MachineInstr
&MI
) const
47 return get(MI
.getOpcode()).TSFlags
& SI_INSTR_FLAGS_ENCODING_MASK
;
50 unsigned SIInstrInfo::getEncodingBytes(const MachineInstr
&MI
) const
53 /* Instructions with literal constants are expanded to 64-bits, and
54 * the constant is stored in bits [63:32] */
55 for (unsigned i
= 0; i
< MI
.getNumOperands(); i
++) {
56 if (MI
.getOperand(i
).getType() == MachineOperand::MO_FPImmediate
) {
61 /* This instruction always has a literal */
62 if (MI
.getOpcode() == AMDIL::S_MOV_IMM_I32
) {
66 unsigned encoding_type
= getEncodingType(MI
);
67 switch (encoding_type
) {
68 case SIInstrEncodingType::EXP
:
69 case SIInstrEncodingType::LDS
:
70 case SIInstrEncodingType::MUBUF
:
71 case SIInstrEncodingType::MTBUF
:
72 case SIInstrEncodingType::MIMG
:
73 case SIInstrEncodingType::VOP3
:
80 MachineInstr
* SIInstrInfo::convertToISA(MachineInstr
& MI
, MachineFunction
&MF
,
84 switch (MI
.getOpcode()) {
86 case AMDIL::CLAMP_f32
: return convertCLAMP_f32(MI
, MF
, DL
);
89 MachineInstr
* newMI
= AMDGPUInstrInfo::convertToISA(MI
, MF
, DL
);
90 const MCInstrDesc
&newDesc
= get(newMI
->getOpcode());
92 /* If this instruction was converted to a VOP3, we need to add the extra
93 * operands for abs, clamp, omod, and negate. */
94 if (getEncodingType(*newMI
) == SIInstrEncodingType::VOP3
95 && newMI
->getNumOperands() < newDesc
.getNumOperands()) {
96 MachineInstrBuilder
builder(newMI
);
97 for (unsigned op_idx
= newMI
->getNumOperands();
98 op_idx
< newDesc
.getNumOperands(); op_idx
++) {
105 unsigned SIInstrInfo::getISAOpcode(unsigned AMDILopcode
) const
107 switch (AMDILopcode
) {
108 //XXX We need a better way of detecting end of program
109 case AMDIL::RETURN
: return AMDIL::S_ENDPGM
;
110 case AMDIL::MOVE_f32
: return AMDIL::V_MOV_B32_e32
;
111 default: return AMDILopcode
;
115 MachineInstr
* SIInstrInfo::convertCLAMP_f32(MachineInstr
& clampInstr
,
116 MachineFunction
&MF
, DebugLoc DL
) const
118 MachineRegisterInfo
&MRI
= MF
.getRegInfo();
119 /* XXX: HACK assume that low == zero and high == one for now until
120 * we have a way to propogate the immediates. */
123 uint32_t zero = (uint32_t)APFloat(0.0f).bitcastToAPInt().getZExtValue();
124 uint32_t one = (uint32_t)APFloat(1.0f).bitcastToAPInt().getZExtValue();
125 uint32_t low = clampInstr.getOperand(2).getImm();
126 uint32_t high = clampInstr.getOperand(3).getImm();
128 // if (low == zero && high == one) {
130 /* Convert the desination register to the VReg_32 class */
131 if (TargetRegisterInfo::isVirtualRegister(clampInstr
.getOperand(0).getReg())) {
132 MRI
.setRegClass(clampInstr
.getOperand(0).getReg(),
133 AMDIL::VReg_32RegisterClass
);
135 return BuildMI(MF
, DL
, get(AMDIL::V_MOV_B32_e64
))
136 .addOperand(clampInstr
.getOperand(0))
137 .addOperand(clampInstr
.getOperand(1))
138 /* VSRC1-2 are unused, but we still need to fill all the
139 * operand slots, so we just reuse the VSRC0 operand */
140 .addOperand(clampInstr
.getOperand(1))
141 .addOperand(clampInstr
.getOperand(1))
147 /* XXX: Handle other cases */