lib/Target/R600/MCTargetDesc/R600MCCodeEmitter.cpp

   1 //===- R600MCCodeEmitter.cpp - Code Emitter for R600->Cayman GPU families -===//
   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 /// \file
  11 ///
  12 /// \brief The R600 code emitter produces machine code that can be executed
  13 /// directly on the GPU device.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "R600Defines.h"
  18 #include "MCTargetDesc/AMDGPUMCCodeEmitter.h"
  19 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
  20 #include "llvm/MC/MCCodeEmitter.h"
  21 #include "llvm/MC/MCContext.h"
  22 #include "llvm/MC/MCInst.h"
  23 #include "llvm/MC/MCInstrInfo.h"
  24 #include "llvm/MC/MCRegisterInfo.h"
  25 #include "llvm/MC/MCSubtargetInfo.h"
  26 #include "llvm/Support/raw_ostream.h"
  27 #include <stdio.h>
  28
  29 using namespace llvm;
  30
  31 namespace {
  32
  33 class R600MCCodeEmitter : public AMDGPUMCCodeEmitter {
  34   R600MCCodeEmitter(const R600MCCodeEmitter &) LLVM_DELETED_FUNCTION;
  35   void operator=(const R600MCCodeEmitter &) LLVM_DELETED_FUNCTION;
  36   const MCInstrInfo &MCII;
  37   const MCRegisterInfo &MRI;
  38   const MCSubtargetInfo &STI;
  39   MCContext &Ctx;
  40
  41 public:
  42
  43   R600MCCodeEmitter(const MCInstrInfo &mcii, const MCRegisterInfo &mri,
  44                     const MCSubtargetInfo &sti, MCContext &ctx)
  45     : MCII(mcii), MRI(mri), STI(sti), Ctx(ctx) { }
  46
  47   /// \brief Encode the instruction and write it to the OS.
  48   virtual void EncodeInstruction(const MCInst &MI, raw_ostream &OS,
  49                          SmallVectorImpl<MCFixup> &Fixups) const;
  50
  51   /// \returns the encoding for an MCOperand.
  52   virtual uint64_t getMachineOpValue(const MCInst &MI, const MCOperand &MO,
  53                                      SmallVectorImpl<MCFixup> &Fixups) const;
  54 private:
  55
  56   void EmitByte(unsigned int byte, raw_ostream &OS) const;
  57
  58   void Emit(uint32_t value, raw_ostream &OS) const;
  59   void Emit(uint64_t value, raw_ostream &OS) const;
  60
  61   unsigned getHWRegChan(unsigned reg) const;
  62   unsigned getHWReg(unsigned regNo) const;
  63
  64 };
  65
  66 } // End anonymous namespace
  67
  68 enum RegElement {
  69   ELEMENT_X = 0,
  70   ELEMENT_Y,
  71   ELEMENT_Z,
  72   ELEMENT_W
  73 };
  74
  75 enum FCInstr {
  76   FC_IF_PREDICATE = 0,
  77   FC_ELSE,
  78   FC_ENDIF,
  79   FC_BGNLOOP,
  80   FC_ENDLOOP,
  81   FC_BREAK_PREDICATE,
  82   FC_CONTINUE
  83 };
  84
  85 enum TextureTypes {
  86   TEXTURE_1D = 1,
  87   TEXTURE_2D,
  88   TEXTURE_3D,
  89   TEXTURE_CUBE,
  90   TEXTURE_RECT,
  91   TEXTURE_SHADOW1D,
  92   TEXTURE_SHADOW2D,
  93   TEXTURE_SHADOWRECT,
  94   TEXTURE_1D_ARRAY,
  95   TEXTURE_2D_ARRAY,
  96   TEXTURE_SHADOW1D_ARRAY,
  97   TEXTURE_SHADOW2D_ARRAY
  98 };
  99
 100 MCCodeEmitter *llvm::createR600MCCodeEmitter(const MCInstrInfo &MCII,
 101                                            const MCRegisterInfo &MRI,
 102                                            const MCSubtargetInfo &STI,
 103                                            MCContext &Ctx) {
 104   return new R600MCCodeEmitter(MCII, MRI, STI, Ctx);
 105 }
 106
 107 void R600MCCodeEmitter::EncodeInstruction(const MCInst &MI, raw_ostream &OS,
 108                                        SmallVectorImpl<MCFixup> &Fixups) const {
 109   const MCInstrDesc &Desc = MCII.get(MI.getOpcode());
 110   if (MI.getOpcode() == AMDGPU::RETURN ||
 111     MI.getOpcode() == AMDGPU::FETCH_CLAUSE ||
 112     MI.getOpcode() == AMDGPU::ALU_CLAUSE ||
 113     MI.getOpcode() == AMDGPU::BUNDLE ||
 114     MI.getOpcode() == AMDGPU::KILL) {
 115     return;
 116   } else if (IS_VTX(Desc)) {
 117     uint64_t InstWord01 = getBinaryCodeForInstr(MI, Fixups);
 118     uint32_t InstWord2 = MI.getOperand(2).getImm(); // Offset
 119     InstWord2 |= 1 << 19;
 120
 121     Emit(InstWord01, OS);
 122     Emit(InstWord2, OS);
 123     Emit((u_int32_t) 0, OS);
 124   } else if (IS_TEX(Desc)) {
 125     unsigned Opcode = MI.getOpcode();
 126     bool HasOffsets = (Opcode == AMDGPU::TEX_LD);
 127     unsigned OpOffset = HasOffsets ? 3 : 0;
 128     int64_t Sampler = MI.getOperand(OpOffset + 3).getImm();
 129     int64_t TextureType = MI.getOperand(OpOffset + 4).getImm();
 130
 131     uint32_t SrcSelect[4] = {0, 1, 2, 3};
 132     uint32_t Offsets[3] = {0, 0, 0};
 133     uint64_t CoordType[4] = {1, 1, 1, 1};
 134
 135     if (HasOffsets)
 136       for (unsigned i = 0; i < 3; i++) {
 137         int SignedOffset = MI.getOperand(i + 2).getImm();
 138         Offsets[i] = (SignedOffset & 0x1F);
 139       }
 140
 141     if (TextureType == TEXTURE_RECT ||
 142         TextureType == TEXTURE_SHADOWRECT) {
 143       CoordType[ELEMENT_X] = 0;
 144       CoordType[ELEMENT_Y] = 0;
 145     }
 146
 147     if (TextureType == TEXTURE_1D_ARRAY ||
 148         TextureType == TEXTURE_SHADOW1D_ARRAY) {
 149       if (Opcode == AMDGPU::TEX_SAMPLE_C_L ||
 150           Opcode == AMDGPU::TEX_SAMPLE_C_LB) {
 151         CoordType[ELEMENT_Y] = 0;
 152       } else {
 153         CoordType[ELEMENT_Z] = 0;
 154         SrcSelect[ELEMENT_Z] = ELEMENT_Y;
 155       }
 156     } else if (TextureType == TEXTURE_2D_ARRAY ||
 157         TextureType == TEXTURE_SHADOW2D_ARRAY) {
 158       CoordType[ELEMENT_Z] = 0;
 159     }
 160
 161
 162     if ((TextureType == TEXTURE_SHADOW1D ||
 163         TextureType == TEXTURE_SHADOW2D ||
 164         TextureType == TEXTURE_SHADOWRECT ||
 165         TextureType == TEXTURE_SHADOW1D_ARRAY) &&
 166         Opcode != AMDGPU::TEX_SAMPLE_C_L &&
 167         Opcode != AMDGPU::TEX_SAMPLE_C_LB) {
 168       SrcSelect[ELEMENT_W] = ELEMENT_Z;
 169     }
 170
 171     uint64_t Word01 = getBinaryCodeForInstr(MI, Fixups) |
 172         CoordType[ELEMENT_X] << 60 | CoordType[ELEMENT_Y] << 61 |
 173         CoordType[ELEMENT_Z] << 62 | CoordType[ELEMENT_W] << 63;
 174     uint32_t Word2 = Sampler << 15 | SrcSelect[ELEMENT_X] << 20 |
 175         SrcSelect[ELEMENT_Y] << 23 | SrcSelect[ELEMENT_Z] << 26 |
 176         SrcSelect[ELEMENT_W] << 29 | Offsets[0] << 0 | Offsets[1] << 5 |
 177         Offsets[2] << 10;
 178
 179     Emit(Word01, OS);
 180     Emit(Word2, OS);
 181     Emit((u_int32_t) 0, OS);
 182   } else {
 183     uint64_t Inst = getBinaryCodeForInstr(MI, Fixups);
 184     Emit(Inst, OS);
 185   }
 186 }
 187
 188 void R600MCCodeEmitter::EmitByte(unsigned int Byte, raw_ostream &OS) const {
 189   OS.write((uint8_t) Byte & 0xff);
 190 }
 191
 192 void R600MCCodeEmitter::Emit(uint32_t Value, raw_ostream &OS) const {
 193   for (unsigned i = 0; i < 4; i++) {
 194     OS.write((uint8_t) ((Value >> (8 * i)) & 0xff));
 195   }
 196 }
 197
 198 void R600MCCodeEmitter::Emit(uint64_t Value, raw_ostream &OS) const {
 199   for (unsigned i = 0; i < 8; i++) {
 200     EmitByte((Value >> (8 * i)) & 0xff, OS);
 201   }
 202 }
 203
 204 unsigned R600MCCodeEmitter::getHWRegChan(unsigned reg) const {
 205   return MRI.getEncodingValue(reg) >> HW_CHAN_SHIFT;
 206 }
 207
 208 unsigned R600MCCodeEmitter::getHWReg(unsigned RegNo) const {
 209   return MRI.getEncodingValue(RegNo) & HW_REG_MASK;
 210 }
 211
 212 uint64_t R600MCCodeEmitter::getMachineOpValue(const MCInst &MI,
 213                                               const MCOperand &MO,
 214                                         SmallVectorImpl<MCFixup> &Fixup) const {
 215   if (MO.isReg()) {
 216     if (HAS_NATIVE_OPERANDS(MCII.get(MI.getOpcode()).TSFlags)) {
 217       return MRI.getEncodingValue(MO.getReg());
 218     } else {
 219       return getHWReg(MO.getReg());
 220     }
 221   } else if (MO.isImm()) {
 222     return MO.getImm();
 223   } else {
 224     assert(0);
 225     return 0;
 226   }
 227 }
 228
 229 #include "AMDGPUGenMCCodeEmitter.inc"