LCOV - code coverage report
Current view: top level - lib/Target/AMDGPU/InstPrinter - AMDGPUInstPrinter.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 749 821 91.2 %
Date: 2018-02-23 15:42:53 Functions: 106 111 95.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- AMDGPUInstPrinter.cpp - AMDGPU MC Inst -> ASM ---------------------===//
       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             : // \file
       9             : //===----------------------------------------------------------------------===//
      10             : 
      11             : #include "AMDGPUInstPrinter.h"
      12             : #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
      13             : #include "SIDefines.h"
      14             : #include "Utils/AMDGPUAsmUtils.h"
      15             : #include "Utils/AMDGPUBaseInfo.h"
      16             : #include "llvm/MC/MCExpr.h"
      17             : #include "llvm/MC/MCInst.h"
      18             : #include "llvm/MC/MCInstrDesc.h"
      19             : #include "llvm/MC/MCInstrInfo.h"
      20             : #include "llvm/MC/MCRegisterInfo.h"
      21             : #include "llvm/MC/MCSubtargetInfo.h"
      22             : #include "llvm/Support/ErrorHandling.h"
      23             : #include "llvm/Support/MathExtras.h"
      24             : #include "llvm/Support/raw_ostream.h"
      25             : #include <cassert>
      26             : 
      27             : using namespace llvm;
      28             : using namespace llvm::AMDGPU;
      29             : 
      30      582100 : void AMDGPUInstPrinter::printInst(const MCInst *MI, raw_ostream &OS,
      31             :                                   StringRef Annot, const MCSubtargetInfo &STI) {
      32             :   OS.flush();
      33      582100 :   printInstruction(MI, STI, OS);
      34      582100 :   printAnnotation(OS, Annot);
      35      582100 : }
      36             : 
      37       24342 : void AMDGPUInstPrinter::printU4ImmOperand(const MCInst *MI, unsigned OpNo,
      38             :                                           const MCSubtargetInfo &STI,
      39             :                                           raw_ostream &O) {
      40       48684 :   O << formatHex(MI->getOperand(OpNo).getImm() & 0xf);
      41       24342 : }
      42             : 
      43           0 : void AMDGPUInstPrinter::printU8ImmOperand(const MCInst *MI, unsigned OpNo,
      44             :                                           raw_ostream &O) {
      45           0 :   O << formatHex(MI->getOperand(OpNo).getImm() & 0xff);
      46           0 : }
      47             : 
      48        6050 : void AMDGPUInstPrinter::printU16ImmOperand(const MCInst *MI, unsigned OpNo,
      49             :                                            const MCSubtargetInfo &STI,
      50             :                                            raw_ostream &O) {
      51             :   // It's possible to end up with a 32-bit literal used with a 16-bit operand
      52             :   // with ignored high bits. Print as 32-bit anyway in that case.
      53        6050 :   int64_t Imm = MI->getOperand(OpNo).getImm();
      54        6050 :   if (isInt<16>(Imm) || isUInt<16>(Imm))
      55        6046 :     O << formatHex(static_cast<uint64_t>(Imm & 0xffff));
      56             :   else
      57           4 :     printU32ImmOperand(MI, OpNo, STI, O);
      58        6050 : }
      59             : 
      60        2958 : void AMDGPUInstPrinter::printU4ImmDecOperand(const MCInst *MI, unsigned OpNo,
      61             :                                              raw_ostream &O) {
      62        5916 :   O << formatDec(MI->getOperand(OpNo).getImm() & 0xf);
      63        2958 : }
      64             : 
      65        7064 : void AMDGPUInstPrinter::printU8ImmDecOperand(const MCInst *MI, unsigned OpNo,
      66             :                                              raw_ostream &O) {
      67       14128 :   O << formatDec(MI->getOperand(OpNo).getImm() & 0xff);
      68        7064 : }
      69             : 
      70       27842 : void AMDGPUInstPrinter::printU16ImmDecOperand(const MCInst *MI, unsigned OpNo,
      71             :                                               raw_ostream &O) {
      72       55684 :   O << formatDec(MI->getOperand(OpNo).getImm() & 0xffff);
      73       27842 : }
      74             : 
      75         344 : void AMDGPUInstPrinter::printS13ImmDecOperand(const MCInst *MI, unsigned OpNo,
      76             :                                               raw_ostream &O) {
      77        1032 :   O << formatDec(SignExtend32<13>(MI->getOperand(OpNo).getImm()));
      78         344 : }
      79             : 
      80       31618 : void AMDGPUInstPrinter::printU32ImmOperand(const MCInst *MI, unsigned OpNo,
      81             :                                            const MCSubtargetInfo &STI,
      82             :                                            raw_ostream &O) {
      83       63236 :   O << formatHex(MI->getOperand(OpNo).getImm() & 0xffffffff);
      84       31618 : }
      85             : 
      86      208616 : void AMDGPUInstPrinter::printNamedBit(const MCInst *MI, unsigned OpNo,
      87             :                                       raw_ostream &O, StringRef BitName) {
      88      208616 :   if (MI->getOperand(OpNo).getImm()) {
      89        3757 :     O << ' ' << BitName;
      90             :   }
      91      208616 : }
      92             : 
      93           0 : void AMDGPUInstPrinter::printOffen(const MCInst *MI, unsigned OpNo,
      94             :                                    raw_ostream &O) {
      95           0 :   printNamedBit(MI, OpNo, O, "offen");
      96           0 : }
      97             : 
      98           0 : void AMDGPUInstPrinter::printIdxen(const MCInst *MI, unsigned OpNo,
      99             :                                    raw_ostream &O) {
     100           0 :   printNamedBit(MI, OpNo, O, "idxen");
     101           0 : }
     102             : 
     103           0 : void AMDGPUInstPrinter::printAddr64(const MCInst *MI, unsigned OpNo,
     104             :                                     raw_ostream &O) {
     105           0 :   printNamedBit(MI, OpNo, O, "addr64");
     106           0 : }
     107             : 
     108           0 : void AMDGPUInstPrinter::printMBUFOffset(const MCInst *MI, unsigned OpNo,
     109             :                                         raw_ostream &O) {
     110           0 :   if (MI->getOperand(OpNo).getImm()) {
     111           0 :     O << " offset:";
     112           0 :     printU16ImmDecOperand(MI, OpNo, O);
     113             :   }
     114           0 : }
     115             : 
     116       58443 : void AMDGPUInstPrinter::printOffset(const MCInst *MI, unsigned OpNo,
     117             :                                     const MCSubtargetInfo &STI,
     118             :                                     raw_ostream &O) {
     119       58443 :   uint16_t Imm = MI->getOperand(OpNo).getImm();
     120       58443 :   if (Imm != 0) {
     121       27823 :     O << ((OpNo == 0)? "offset:" : " offset:");
     122       27823 :     printU16ImmDecOperand(MI, OpNo, O);
     123             :   }
     124       58443 : }
     125             : 
     126        2302 : void AMDGPUInstPrinter::printOffsetS13(const MCInst *MI, unsigned OpNo,
     127             :                                        const MCSubtargetInfo &STI,
     128             :                                        raw_ostream &O) {
     129        2302 :   uint16_t Imm = MI->getOperand(OpNo).getImm();
     130        2302 :   if (Imm != 0) {
     131         344 :     O << ((OpNo == 0)? "offset:" : " offset:");
     132         344 :     printS13ImmDecOperand(MI, OpNo, O);
     133             :   }
     134        2302 : }
     135             : 
     136        3963 : void AMDGPUInstPrinter::printOffset0(const MCInst *MI, unsigned OpNo,
     137             :                                      const MCSubtargetInfo &STI,
     138             :                                      raw_ostream &O) {
     139        3963 :   if (MI->getOperand(OpNo).getImm()) {
     140        2961 :     O << " offset0:";
     141        2961 :     printU8ImmDecOperand(MI, OpNo, O);
     142             :   }
     143        3963 : }
     144             : 
     145        3963 : void AMDGPUInstPrinter::printOffset1(const MCInst *MI, unsigned OpNo,
     146             :                                      const MCSubtargetInfo &STI,
     147             :                                      raw_ostream &O) {
     148        3963 :   if (MI->getOperand(OpNo).getImm()) {
     149        3755 :     O << " offset1:";
     150        3755 :     printU8ImmDecOperand(MI, OpNo, O);
     151             :   }
     152        3963 : }
     153             : 
     154       14987 : void AMDGPUInstPrinter::printSMRDOffset8(const MCInst *MI, unsigned OpNo,
     155             :                                         const MCSubtargetInfo &STI,
     156             :                                         raw_ostream &O) {
     157       14987 :   printU32ImmOperand(MI, OpNo, STI, O);
     158       14987 : }
     159             : 
     160       16452 : void AMDGPUInstPrinter::printSMRDOffset20(const MCInst *MI, unsigned OpNo,
     161             :                                         const MCSubtargetInfo &STI,
     162             :                                         raw_ostream &O) {
     163       16452 :   printU32ImmOperand(MI, OpNo, STI, O);
     164       16452 : }
     165             : 
     166          39 : void AMDGPUInstPrinter::printSMRDLiteralOffset(const MCInst *MI, unsigned OpNo,
     167             :                                                const MCSubtargetInfo &STI,
     168             :                                                raw_ostream &O) {
     169          39 :   printU32ImmOperand(MI, OpNo, STI, O);
     170          39 : }
     171             : 
     172       12384 : void AMDGPUInstPrinter::printGDS(const MCInst *MI, unsigned OpNo,
     173             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     174       12384 :   printNamedBit(MI, OpNo, O, "gds");
     175       12384 : }
     176             : 
     177       84499 : void AMDGPUInstPrinter::printGLC(const MCInst *MI, unsigned OpNo,
     178             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     179       84499 :   printNamedBit(MI, OpNo, O, "glc");
     180       84499 : }
     181             : 
     182       55926 : void AMDGPUInstPrinter::printSLC(const MCInst *MI, unsigned OpNo,
     183             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     184       55926 :   printNamedBit(MI, OpNo, O, "slc");
     185       55926 : }
     186             : 
     187       41391 : void AMDGPUInstPrinter::printTFE(const MCInst *MI, unsigned OpNo,
     188             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     189       41391 :   printNamedBit(MI, OpNo, O, "tfe");
     190       41391 : }
     191             : 
     192        3604 : void AMDGPUInstPrinter::printDMask(const MCInst *MI, unsigned OpNo,
     193             :                                    const MCSubtargetInfo &STI, raw_ostream &O) {
     194        3604 :   if (MI->getOperand(OpNo).getImm()) {
     195        3387 :     O << " dmask:";
     196        3387 :     printU16ImmOperand(MI, OpNo, STI, O);
     197             :   }
     198        3604 : }
     199             : 
     200        3604 : void AMDGPUInstPrinter::printUNorm(const MCInst *MI, unsigned OpNo,
     201             :                                    const MCSubtargetInfo &STI, raw_ostream &O) {
     202        3604 :   printNamedBit(MI, OpNo, O, "unorm");
     203        3604 : }
     204             : 
     205        3604 : void AMDGPUInstPrinter::printDA(const MCInst *MI, unsigned OpNo,
     206             :                                 const MCSubtargetInfo &STI, raw_ostream &O) {
     207        3604 :   printNamedBit(MI, OpNo, O, "da");
     208        3604 : }
     209             : 
     210        3604 : void AMDGPUInstPrinter::printR128(const MCInst *MI, unsigned OpNo,
     211             :                                   const MCSubtargetInfo &STI, raw_ostream &O) {
     212        3604 :   printNamedBit(MI, OpNo, O, "r128");
     213        3604 : }
     214             : 
     215        3604 : void AMDGPUInstPrinter::printLWE(const MCInst *MI, unsigned OpNo,
     216             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     217        3604 :   printNamedBit(MI, OpNo, O, "lwe");
     218        3604 : }
     219             : 
     220         652 : void AMDGPUInstPrinter::printExpCompr(const MCInst *MI, unsigned OpNo,
     221             :                                       const MCSubtargetInfo &STI,
     222             :                                       raw_ostream &O) {
     223         652 :   if (MI->getOperand(OpNo).getImm())
     224         109 :     O << " compr";
     225         652 : }
     226             : 
     227         652 : void AMDGPUInstPrinter::printExpVM(const MCInst *MI, unsigned OpNo,
     228             :                                    const MCSubtargetInfo &STI,
     229             :                                    raw_ostream &O) {
     230         652 :   if (MI->getOperand(OpNo).getImm())
     231         150 :     O << " vm";
     232         652 : }
     233             : 
     234         174 : void AMDGPUInstPrinter::printDFMT(const MCInst *MI, unsigned OpNo,
     235             :                                   const MCSubtargetInfo &STI,
     236             :                                   raw_ostream &O) {
     237         174 :   if (MI->getOperand(OpNo).getImm()) {
     238         174 :     O << " dfmt:";
     239         174 :     printU8ImmDecOperand(MI, OpNo, O);
     240             :   }
     241         174 : }
     242             : 
     243         174 : void AMDGPUInstPrinter::printNFMT(const MCInst *MI, unsigned OpNo,
     244             :                                   const MCSubtargetInfo &STI,
     245             :                                   raw_ostream &O) {
     246         174 :   if (MI->getOperand(OpNo).getImm()) {
     247         174 :     O << " nfmt:";
     248         174 :     printU8ImmDecOperand(MI, OpNo, O);
     249             :   }
     250         174 : }
     251             : 
     252     1014765 : void AMDGPUInstPrinter::printRegOperand(unsigned RegNo, raw_ostream &O,
     253             :                                         const MCRegisterInfo &MRI) {
     254     1014765 :   switch (RegNo) {
     255        6723 :   case AMDGPU::VCC:
     256        6723 :     O << "vcc";
     257        6723 :     return;
     258           0 :   case AMDGPU::SCC:
     259           0 :     O << "scc";
     260           0 :     return;
     261        4190 :   case AMDGPU::EXEC:
     262        4190 :     O << "exec";
     263        4190 :     return;
     264        7612 :   case AMDGPU::M0:
     265        7612 :     O << "m0";
     266        7612 :     return;
     267           0 :   case AMDGPU::FLAT_SCR:
     268           0 :     O << "flat_scratch";
     269           0 :     return;
     270           4 :   case AMDGPU::XNACK_MASK:
     271           4 :     O << "xnack_mask";
     272           4 :     return;
     273        5472 :   case AMDGPU::VCC_LO:
     274        5472 :     O << "vcc_lo";
     275        5472 :     return;
     276        5470 :   case AMDGPU::VCC_HI:
     277        5470 :     O << "vcc_hi";
     278        5470 :     return;
     279        2866 :   case AMDGPU::TBA_LO:
     280        2866 :     O << "tba_lo";
     281        2866 :     return;
     282        2866 :   case AMDGPU::TBA_HI:
     283        2866 :     O << "tba_hi";
     284        2866 :     return;
     285        2880 :   case AMDGPU::TMA_LO:
     286        2880 :     O << "tma_lo";
     287        2880 :     return;
     288        2873 :   case AMDGPU::TMA_HI:
     289        2873 :     O << "tma_hi";
     290        2873 :     return;
     291        5332 :   case AMDGPU::EXEC_LO:
     292        5332 :     O << "exec_lo";
     293        5332 :     return;
     294        5325 :   case AMDGPU::EXEC_HI:
     295        5325 :     O << "exec_hi";
     296        5325 :     return;
     297           0 :   case AMDGPU::FLAT_SCR_LO:
     298           0 :     O << "flat_scratch_lo";
     299           0 :     return;
     300           0 :   case AMDGPU::FLAT_SCR_HI:
     301           0 :     O << "flat_scratch_hi";
     302           0 :     return;
     303           3 :   case AMDGPU::XNACK_MASK_LO:
     304           3 :     O << "xnack_mask_lo";
     305           3 :     return;
     306           4 :   case AMDGPU::XNACK_MASK_HI:
     307           4 :     O << "xnack_mask_hi";
     308           4 :     return;
     309           0 :   case AMDGPU::FP_REG:
     310             :   case AMDGPU::SP_REG:
     311             :   case AMDGPU::SCRATCH_WAVE_OFFSET_REG:
     312             :   case AMDGPU::PRIVATE_RSRC_REG:
     313           0 :     llvm_unreachable("pseudo-register should not ever be emitted");
     314             :   default:
     315             :     break;
     316             :   }
     317             : 
     318             :   // The low 8 bits of the encoding value is the register index, for both VGPRs
     319             :   // and SGPRs.
     320     1926290 :   unsigned RegIdx = MRI.getEncodingValue(RegNo) & ((1 << 8) - 1);
     321             : 
     322             :   unsigned NumRegs;
     323     1654917 :   if (MRI.getRegClass(AMDGPU::VGPR_32RegClassID).contains(RegNo)) {
     324             :     O << 'v';
     325             :     NumRegs = 1;
     326      673115 :   } else  if (MRI.getRegClass(AMDGPU::SGPR_32RegClassID).contains(RegNo)) {
     327             :     O << 's';
     328             :     NumRegs = 1;
     329      579357 :   } else if (MRI.getRegClass(AMDGPU::VReg_64RegClassID).contains(RegNo)) {
     330             :     O <<'v';
     331             :     NumRegs = 2;
     332      414819 :   } else  if (MRI.getRegClass(AMDGPU::SGPR_64RegClassID).contains(RegNo)) {
     333             :     O << 's';
     334             :     NumRegs = 2;
     335      176169 :   } else if (MRI.getRegClass(AMDGPU::VReg_128RegClassID).contains(RegNo)) {
     336             :     O << 'v';
     337             :     NumRegs = 4;
     338      146124 :   } else  if (MRI.getRegClass(AMDGPU::SGPR_128RegClassID).contains(RegNo)) {
     339             :     O << 's';
     340             :     NumRegs = 4;
     341       59412 :   } else if (MRI.getRegClass(AMDGPU::VReg_96RegClassID).contains(RegNo)) {
     342             :     O << 'v';
     343             :     NumRegs = 3;
     344       57416 :   } else if (MRI.getRegClass(AMDGPU::VReg_256RegClassID).contains(RegNo)) {
     345             :     O << 'v';
     346             :     NumRegs = 8;
     347       56943 :   } else if (MRI.getRegClass(AMDGPU::SGPR_256RegClassID).contains(RegNo)) {
     348             :     O << 's';
     349             :     NumRegs = 8;
     350       49048 :   } else if (MRI.getRegClass(AMDGPU::VReg_512RegClassID).contains(RegNo)) {
     351             :     O << 'v';
     352             :     NumRegs = 16;
     353       49036 :   } else if (MRI.getRegClass(AMDGPU::SGPR_512RegClassID).contains(RegNo)) {
     354             :     O << 's';
     355             :     NumRegs = 16;
     356             :   } else {
     357       24153 :     O << getRegisterName(RegNo);
     358       24153 :     return;
     359             :   }
     360             : 
     361             :   if (NumRegs == 1) {
     362             :     O << RegIdx;
     363             :     return;
     364             :   }
     365             : 
     366      265563 :   O << '[' << RegIdx << ':' << (RegIdx + NumRegs - 1) << ']';
     367             : }
     368             : 
     369      198517 : void AMDGPUInstPrinter::printVOPDst(const MCInst *MI, unsigned OpNo,
     370             :                                     const MCSubtargetInfo &STI, raw_ostream &O) {
     371      397034 :   if (MII.get(MI->getOpcode()).TSFlags & SIInstrFlags::VOP3)
     372       63267 :     O << "_e64 ";
     373      135250 :   else if (MII.get(MI->getOpcode()).TSFlags & SIInstrFlags::DPP)
     374       12167 :     O << "_dpp ";
     375      123083 :   else if (MII.get(MI->getOpcode()).TSFlags & SIInstrFlags::SDWA)
     376       18842 :     O << "_sdwa ";
     377             :   else
     378      104241 :     O << "_e32 ";
     379             : 
     380      198517 :   printOperand(MI, OpNo, STI, O);
     381      198517 : }
     382             : 
     383        9160 : void AMDGPUInstPrinter::printImmediate16(uint32_t Imm,
     384             :                                          const MCSubtargetInfo &STI,
     385             :                                          raw_ostream &O) {
     386        9160 :   int16_t SImm = static_cast<int16_t>(Imm);
     387        9160 :   if (SImm >= -16 && SImm <= 64) {
     388             :     O << SImm;
     389             :     return;
     390             :   }
     391             : 
     392        3799 :   if (Imm == 0x3C00)
     393          67 :     O<< "1.0";
     394        3732 :   else if (Imm == 0xBC00)
     395          14 :     O<< "-1.0";
     396        3718 :   else if (Imm == 0x3800)
     397        1370 :     O<< "0.5";
     398        2348 :   else if (Imm == 0xB800)
     399           9 :     O<< "-0.5";
     400        2339 :   else if (Imm == 0x4000)
     401          65 :     O<< "2.0";
     402        2274 :   else if (Imm == 0xC000)
     403          23 :     O<< "-2.0";
     404        2251 :   else if (Imm == 0x4400)
     405          27 :     O<< "4.0";
     406        2224 :   else if (Imm == 0xC400)
     407        1328 :     O<< "-4.0";
     408         896 :   else if (Imm == 0x3118) {
     409             :     assert(STI.getFeatureBits()[AMDGPU::FeatureInv2PiInlineImm]);
     410          13 :     O << "0.15915494";
     411             :   } else
     412         883 :     O << formatHex(static_cast<uint64_t>(Imm));
     413             : }
     414             : 
     415         228 : void AMDGPUInstPrinter::printImmediateV216(uint32_t Imm,
     416             :                                            const MCSubtargetInfo &STI,
     417             :                                            raw_ostream &O) {
     418             :   uint16_t Lo16 = static_cast<uint16_t>(Imm);
     419         228 :   printImmediate16(Lo16, STI, O);
     420         228 : }
     421             : 
     422      124256 : void AMDGPUInstPrinter::printImmediate32(uint32_t Imm,
     423             :                                          const MCSubtargetInfo &STI,
     424             :                                          raw_ostream &O) {
     425      124256 :   int32_t SImm = static_cast<int32_t>(Imm);
     426      124256 :   if (SImm >= -16 && SImm <= 64) {
     427             :     O << SImm;
     428             :     return;
     429             :   }
     430             : 
     431       29985 :   if (Imm == FloatToBits(0.0f))
     432           0 :     O << "0.0";
     433       29985 :   else if (Imm == FloatToBits(1.0f))
     434         764 :     O << "1.0";
     435       29221 :   else if (Imm == FloatToBits(-1.0f))
     436         116 :     O << "-1.0";
     437       29105 :   else if (Imm == FloatToBits(0.5f))
     438        3758 :     O << "0.5";
     439       25347 :   else if (Imm == FloatToBits(-0.5f))
     440          21 :     O << "-0.5";
     441       25326 :   else if (Imm == FloatToBits(2.0f))
     442         295 :     O << "2.0";
     443       25031 :   else if (Imm == FloatToBits(-2.0f))
     444          76 :     O << "-2.0";
     445       24955 :   else if (Imm == FloatToBits(4.0f))
     446         272 :     O << "4.0";
     447       24683 :   else if (Imm == FloatToBits(-4.0f))
     448        3648 :     O << "-4.0";
     449       21124 :   else if (Imm == 0x3e22f983 &&
     450             :            STI.getFeatureBits()[AMDGPU::FeatureInv2PiInlineImm])
     451          57 :     O << "0.15915494";
     452             :   else
     453       20978 :     O << formatHex(static_cast<uint64_t>(Imm));
     454             : }
     455             : 
     456        8972 : void AMDGPUInstPrinter::printImmediate64(uint64_t Imm,
     457             :                                          const MCSubtargetInfo &STI,
     458             :                                          raw_ostream &O) {
     459        8972 :   int64_t SImm = static_cast<int64_t>(Imm);
     460        8972 :   if (SImm >= -16 && SImm <= 64) {
     461        3880 :     O << SImm;
     462        3880 :     return;
     463             :   }
     464             : 
     465        5092 :   if (Imm == DoubleToBits(0.0))
     466           0 :     O << "0.0";
     467        5092 :   else if (Imm == DoubleToBits(1.0))
     468         152 :     O << "1.0";
     469        4940 :   else if (Imm == DoubleToBits(-1.0))
     470          33 :     O << "-1.0";
     471        4907 :   else if (Imm == DoubleToBits(0.5))
     472        1662 :     O << "0.5";
     473        3245 :   else if (Imm == DoubleToBits(-0.5))
     474           4 :     O << "-0.5";
     475        3241 :   else if (Imm == DoubleToBits(2.0))
     476          44 :     O << "2.0";
     477        3197 :   else if (Imm == DoubleToBits(-2.0))
     478           4 :     O << "-2.0";
     479        3193 :   else if (Imm == DoubleToBits(4.0))
     480          35 :     O << "4.0";
     481        3158 :   else if (Imm == DoubleToBits(-4.0))
     482        1639 :     O << "-4.0";
     483        1534 :   else if (Imm == 0x3fc45f306dc9c882 &&
     484             :            STI.getFeatureBits()[AMDGPU::FeatureInv2PiInlineImm])
     485          15 :   O << "0.15915494";
     486             :   else {
     487             :     assert(isUInt<32>(Imm) || Imm == 0x3fc45f306dc9c882);
     488             : 
     489             :     // In rare situations, we will have a 32-bit literal in a 64-bit
     490             :     // operand. This is technically allowed for the encoding of s_mov_b64.
     491        1504 :     O << formatHex(static_cast<uint64_t>(Imm));
     492             :   }
     493             : }
     494             : 
     495     1374130 : void AMDGPUInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
     496             :                                      const MCSubtargetInfo &STI,
     497             :                                      raw_ostream &O) {
     498     1374130 :   if (!STI.getFeatureBits()[AMDGPU::FeatureGCN]) {
     499      216777 :     static_cast<R600InstPrinter*>(this)->printOperand(MI, OpNo, O);
     500      216777 :     return;
     501             :   }
     502             : 
     503     1157353 :   if (OpNo >= MI->getNumOperands()) {
     504           0 :     O << "/*Missing OP" << OpNo << "*/";
     505           0 :     return;
     506             :   }
     507             : 
     508             :   const MCOperand &Op = MI->getOperand(OpNo);
     509     1157353 :   if (Op.isReg()) {
     510     1012049 :     printRegOperand(Op.getReg(), O, MRI);
     511      145304 :   } else if (Op.isImm()) {
     512      142540 :     const MCInstrDesc &Desc = MII.get(MI->getOpcode());
     513      142540 :     switch (Desc.OpInfo[OpNo].OperandType) {
     514      124256 :     case AMDGPU::OPERAND_REG_IMM_INT32:
     515             :     case AMDGPU::OPERAND_REG_IMM_FP32:
     516             :     case AMDGPU::OPERAND_REG_INLINE_C_INT32:
     517             :     case AMDGPU::OPERAND_REG_INLINE_C_FP32:
     518             :     case MCOI::OPERAND_IMMEDIATE:
     519      124256 :       printImmediate32(Op.getImm(), STI, O);
     520      124256 :       break;
     521        8972 :     case AMDGPU::OPERAND_REG_IMM_INT64:
     522             :     case AMDGPU::OPERAND_REG_IMM_FP64:
     523             :     case AMDGPU::OPERAND_REG_INLINE_C_INT64:
     524             :     case AMDGPU::OPERAND_REG_INLINE_C_FP64:
     525        8972 :       printImmediate64(Op.getImm(), STI, O);
     526        8972 :       break;
     527        8932 :     case AMDGPU::OPERAND_REG_INLINE_C_INT16:
     528             :     case AMDGPU::OPERAND_REG_INLINE_C_FP16:
     529             :     case AMDGPU::OPERAND_REG_IMM_INT16:
     530             :     case AMDGPU::OPERAND_REG_IMM_FP16:
     531        8932 :       printImmediate16(Op.getImm(), STI, O);
     532        8932 :       break;
     533         228 :     case AMDGPU::OPERAND_REG_INLINE_C_V2FP16:
     534             :     case AMDGPU::OPERAND_REG_INLINE_C_V2INT16:
     535         228 :       printImmediateV216(Op.getImm(), STI, O);
     536         228 :       break;
     537         152 :     case MCOI::OPERAND_UNKNOWN:
     538             :     case MCOI::OPERAND_PCREL:
     539         152 :       O << formatDec(Op.getImm());
     540         152 :       break;
     541           0 :     case MCOI::OPERAND_REGISTER:
     542             :       // FIXME: This should be removed and handled somewhere else. Seems to come
     543             :       // from a disassembler bug.
     544           0 :       O << "/*invalid immediate*/";
     545           0 :       break;
     546           0 :     default:
     547             :       // We hit this for the immediate instruction bits that don't yet have a
     548             :       // custom printer.
     549           0 :       llvm_unreachable("unexpected immediate operand type");
     550             :     }
     551        2764 :   } else if (Op.isFPImm()) {
     552             :     // We special case 0.0 because otherwise it will be printed as an integer.
     553           0 :     if (Op.getFPImm() == 0.0)
     554           0 :       O << "0.0";
     555             :     else {
     556           0 :       const MCInstrDesc &Desc = MII.get(MI->getOpcode());
     557           0 :       int RCID = Desc.OpInfo[OpNo].RegClass;
     558           0 :       unsigned RCBits = AMDGPU::getRegBitWidth(MRI.getRegClass(RCID));
     559           0 :       if (RCBits == 32)
     560           0 :         printImmediate32(FloatToBits(Op.getFPImm()), STI, O);
     561           0 :       else if (RCBits == 64)
     562           0 :         printImmediate64(DoubleToBits(Op.getFPImm()), STI, O);
     563             :       else
     564           0 :         llvm_unreachable("Invalid register class size");
     565             :     }
     566        2764 :   } else if (Op.isExpr()) {
     567        2764 :     const MCExpr *Exp = Op.getExpr();
     568        2764 :     Exp->print(O, &MAI);
     569             :   } else {
     570           0 :     O << "/*INV_OP*/";
     571             :   }
     572             : }
     573             : 
     574      116716 : void AMDGPUInstPrinter::printOperandAndFPInputMods(const MCInst *MI,
     575             :                                                    unsigned OpNo,
     576             :                                                    const MCSubtargetInfo &STI,
     577             :                                                    raw_ostream &O) {
     578      116716 :   unsigned InputModifiers = MI->getOperand(OpNo).getImm();
     579             : 
     580             :   // Use 'neg(...)' instead of '-' to avoid ambiguity.
     581             :   // This is important for integer literals because
     582             :   // -1 is not the same value as neg(1).
     583             :   bool NegMnemo = false;
     584             : 
     585      116716 :   if (InputModifiers & SISrcMods::NEG) {
     586       18528 :     if (OpNo + 1 < MI->getNumOperands() &&
     587        6176 :         (InputModifiers & SISrcMods::ABS) == 0) {
     588             :       const MCOperand &Op = MI->getOperand(OpNo + 1);
     589        5901 :       NegMnemo = Op.isImm() || Op.isFPImm();
     590             :     }
     591             :     if (NegMnemo) {
     592          32 :       O << "neg(";
     593             :     } else {
     594             :       O << '-';
     595             :     }
     596             :   }
     597             : 
     598      116716 :   if (InputModifiers & SISrcMods::ABS)
     599             :     O << '|';
     600      116716 :   printOperand(MI, OpNo + 1, STI, O);
     601      116716 :   if (InputModifiers & SISrcMods::ABS)
     602             :     O << '|';
     603             : 
     604      116716 :   if (NegMnemo) {
     605             :     O << ')';
     606             :   }
     607      116716 : }
     608             : 
     609       23963 : void AMDGPUInstPrinter::printOperandAndIntInputMods(const MCInst *MI,
     610             :                                                     unsigned OpNo,
     611             :                                                     const MCSubtargetInfo &STI,
     612             :                                                     raw_ostream &O) {
     613       23963 :   unsigned InputModifiers = MI->getOperand(OpNo).getImm();
     614       23963 :   if (InputModifiers & SISrcMods::SEXT)
     615        1174 :     O << "sext(";
     616       23963 :   printOperand(MI, OpNo + 1, STI, O);
     617       23963 :   if (InputModifiers & SISrcMods::SEXT)
     618             :     O << ')';
     619       23963 : }
     620             : 
     621       12171 : void AMDGPUInstPrinter::printDPPCtrl(const MCInst *MI, unsigned OpNo,
     622             :                                      const MCSubtargetInfo &STI,
     623             :                                      raw_ostream &O) {
     624       12171 :   unsigned Imm = MI->getOperand(OpNo).getImm();
     625       12171 :   if (Imm <= 0x0ff) {
     626        5827 :     O << " quad_perm:[";
     627       11654 :     O << formatDec(Imm & 0x3)         << ',';
     628       11654 :     O << formatDec((Imm & 0xc)  >> 2) << ',';
     629       11654 :     O << formatDec((Imm & 0x30) >> 4) << ',';
     630       11654 :     O << formatDec((Imm & 0xc0) >> 6) << ']';
     631        6344 :   } else if ((Imm >= 0x101) && (Imm <= 0x10f)) {
     632        1272 :     O << " row_shl:";
     633        1272 :     printU4ImmDecOperand(MI, OpNo, O);
     634        5072 :   } else if ((Imm >= 0x111) && (Imm <= 0x11f)) {
     635         845 :     O << " row_shr:";
     636         845 :     printU4ImmDecOperand(MI, OpNo, O);
     637        4227 :   } else if ((Imm >= 0x121) && (Imm <= 0x12f)) {
     638         841 :     O << " row_ror:";
     639         841 :     printU4ImmDecOperand(MI, OpNo, O);
     640        3386 :   } else if (Imm == 0x130) {
     641         424 :     O << " wave_shl:1";
     642        2962 :   } else if (Imm == 0x134) {
     643         424 :     O << " wave_rol:1";
     644        2538 :   } else if (Imm == 0x138) {
     645         424 :     O << " wave_shr:1";
     646        2114 :   } else if (Imm == 0x13c) {
     647         424 :     O << " wave_ror:1";
     648        1690 :   } else if (Imm == 0x140) {
     649         422 :     O << " row_mirror";
     650        1268 :   } else if (Imm == 0x141) {
     651         422 :     O << " row_half_mirror";
     652         846 :   } else if (Imm == 0x142) {
     653         424 :     O << " row_bcast:15";
     654         422 :   } else if (Imm == 0x143) {
     655         422 :     O << " row_bcast:31";
     656             :   } else {
     657           0 :     llvm_unreachable("Invalid dpp_ctrl value");
     658             :   }
     659       12171 : }
     660             : 
     661       12171 : void AMDGPUInstPrinter::printRowMask(const MCInst *MI, unsigned OpNo,
     662             :                                      const MCSubtargetInfo &STI,
     663             :                                      raw_ostream &O) {
     664       12171 :   O << " row_mask:";
     665       12171 :   printU4ImmOperand(MI, OpNo, STI, O);
     666       12171 : }
     667             : 
     668       12171 : void AMDGPUInstPrinter::printBankMask(const MCInst *MI, unsigned OpNo,
     669             :                                       const MCSubtargetInfo &STI,
     670             :                                       raw_ostream &O) {
     671       12171 :   O << " bank_mask:";
     672       12171 :   printU4ImmOperand(MI, OpNo, STI, O);
     673       12171 : }
     674             : 
     675       12171 : void AMDGPUInstPrinter::printBoundCtrl(const MCInst *MI, unsigned OpNo,
     676             :                                        const MCSubtargetInfo &STI,
     677             :                                        raw_ostream &O) {
     678       12171 :   unsigned Imm = MI->getOperand(OpNo).getImm();
     679       12171 :   if (Imm) {
     680         884 :     O << " bound_ctrl:0"; // XXX - this syntax is used in sp3
     681             :   }
     682       12171 : }
     683             : 
     684       56063 : void AMDGPUInstPrinter::printSDWASel(const MCInst *MI, unsigned OpNo,
     685             :                                      raw_ostream &O) {
     686             :   using namespace llvm::AMDGPU::SDWA;
     687             : 
     688       56063 :   unsigned Imm = MI->getOperand(OpNo).getImm();
     689       56063 :   switch (Imm) {
     690        2065 :   case SdwaSel::BYTE_0: O << "BYTE_0"; break;
     691        1888 :   case SdwaSel::BYTE_1: O << "BYTE_1"; break;
     692        2282 :   case SdwaSel::BYTE_2: O << "BYTE_2"; break;
     693        1848 :   case SdwaSel::BYTE_3: O << "BYTE_3"; break;
     694        2401 :   case SdwaSel::WORD_0: O << "WORD_0"; break;
     695        3082 :   case SdwaSel::WORD_1: O << "WORD_1"; break;
     696       42497 :   case SdwaSel::DWORD: O << "DWORD"; break;
     697           0 :   default: llvm_unreachable("Invalid SDWA data select operand");
     698             :   }
     699       56063 : }
     700             : 
     701       14395 : void AMDGPUInstPrinter::printSDWADstSel(const MCInst *MI, unsigned OpNo,
     702             :                                         const MCSubtargetInfo &STI,
     703             :                                         raw_ostream &O) {
     704       14395 :   O << "dst_sel:";
     705       14395 :   printSDWASel(MI, OpNo, O);
     706       14395 : }
     707             : 
     708       24016 : void AMDGPUInstPrinter::printSDWASrc0Sel(const MCInst *MI, unsigned OpNo,
     709             :                                          const MCSubtargetInfo &STI,
     710             :                                          raw_ostream &O) {
     711       24016 :   O << "src0_sel:";
     712       24016 :   printSDWASel(MI, OpNo, O);
     713       24016 : }
     714             : 
     715       17652 : void AMDGPUInstPrinter::printSDWASrc1Sel(const MCInst *MI, unsigned OpNo,
     716             :                                          const MCSubtargetInfo &STI,
     717             :                                          raw_ostream &O) {
     718       17652 :   O << "src1_sel:";
     719       17652 :   printSDWASel(MI, OpNo, O);
     720       17652 : }
     721             : 
     722       14395 : void AMDGPUInstPrinter::printSDWADstUnused(const MCInst *MI, unsigned OpNo,
     723             :                                            const MCSubtargetInfo &STI,
     724             :                                            raw_ostream &O) {
     725             :   using namespace llvm::AMDGPU::SDWA;
     726             : 
     727       14395 :   O << "dst_unused:";
     728       14395 :   unsigned Imm = MI->getOperand(OpNo).getImm();
     729       14395 :   switch (Imm) {
     730       13182 :   case DstUnused::UNUSED_PAD: O << "UNUSED_PAD"; break;
     731         431 :   case DstUnused::UNUSED_SEXT: O << "UNUSED_SEXT"; break;
     732         782 :   case DstUnused::UNUSED_PRESERVE: O << "UNUSED_PRESERVE"; break;
     733           0 :   default: llvm_unreachable("Invalid SDWA dest_unused operand");
     734             :   }
     735       14395 : }
     736             : 
     737             : template <unsigned N>
     738        2608 : void AMDGPUInstPrinter::printExpSrcN(const MCInst *MI, unsigned OpNo,
     739             :                                      const MCSubtargetInfo &STI,
     740             :                                      raw_ostream &O) {
     741        2608 :   unsigned Opc = MI->getOpcode();
     742        2608 :   int EnIdx = AMDGPU::getNamedOperandIdx(Opc, AMDGPU::OpName::en);
     743        5216 :   unsigned En = MI->getOperand(EnIdx).getImm();
     744             : 
     745        1956 :   int ComprIdx = AMDGPU::getNamedOperandIdx(Opc, AMDGPU::OpName::compr);
     746             : 
     747             :   // If compr is set, print as src0, src0, src1, src1
     748        3912 :   if (MI->getOperand(ComprIdx).getImm()) {
     749             :     if (N == 1 || N == 2)
     750         218 :       --OpNo;
     751             :     else if (N == 3)
     752         109 :       OpNo -= 2;
     753             :   }
     754             : 
     755        2608 :   if (En & (1 << N))
     756        4286 :     printRegOperand(MI->getOperand(OpNo).getReg(), O, MRI);
     757             :   else
     758         465 :     O << "off";
     759        2608 : }
     760             : 
     761         652 : void AMDGPUInstPrinter::printExpSrc0(const MCInst *MI, unsigned OpNo,
     762             :                                      const MCSubtargetInfo &STI,
     763             :                                      raw_ostream &O) {
     764         652 :   printExpSrcN<0>(MI, OpNo, STI, O);
     765         652 : }
     766             : 
     767         652 : void AMDGPUInstPrinter::printExpSrc1(const MCInst *MI, unsigned OpNo,
     768             :                                      const MCSubtargetInfo &STI,
     769             :                                      raw_ostream &O) {
     770         652 :   printExpSrcN<1>(MI, OpNo, STI, O);
     771         652 : }
     772             : 
     773         652 : void AMDGPUInstPrinter::printExpSrc2(const MCInst *MI, unsigned OpNo,
     774             :                                      const MCSubtargetInfo &STI,
     775             :                                      raw_ostream &O) {
     776         652 :   printExpSrcN<2>(MI, OpNo, STI, O);
     777         652 : }
     778             : 
     779         652 : void AMDGPUInstPrinter::printExpSrc3(const MCInst *MI, unsigned OpNo,
     780             :                                      const MCSubtargetInfo &STI,
     781             :                                      raw_ostream &O) {
     782         652 :   printExpSrcN<3>(MI, OpNo, STI, O);
     783         652 : }
     784             : 
     785         652 : void AMDGPUInstPrinter::printExpTgt(const MCInst *MI, unsigned OpNo,
     786             :                                     const MCSubtargetInfo &STI,
     787             :                                     raw_ostream &O) {
     788             :   // This is really a 6 bit field.
     789         652 :   uint32_t Tgt = MI->getOperand(OpNo).getImm() & ((1 << 6) - 1);
     790             : 
     791         652 :   if (Tgt <= 7)
     792         398 :     O << " mrt" << Tgt;
     793         254 :   else if (Tgt == 8)
     794          36 :     O << " mrtz";
     795         218 :   else if (Tgt == 9)
     796          21 :     O << " null";
     797         197 :   else if (Tgt >= 12 && Tgt <= 15)
     798          47 :     O << " pos" << Tgt - 12;
     799         150 :   else if (Tgt >= 32 && Tgt <= 63)
     800         134 :     O << " param" << Tgt - 32;
     801             :   else {
     802             :     // Reserved values 10, 11
     803          16 :     O << " invalid_target_" << Tgt;
     804             :   }
     805         652 : }
     806             : 
     807             : static bool allOpsDefaultValue(const int* Ops, int NumOps, int Mod,
     808             :                                bool IsPacked, bool HasDstSel) {
     809        8273 :   int DefaultValue = IsPacked && (Mod == SISrcMods::OP_SEL_1);
     810             : 
     811       44411 :   for (int I = 0; I < NumOps; ++I) {
     812       18672 :     if (!!(Ops[I] & Mod) != DefaultValue)
     813             :       return false;
     814             :   }
     815             : 
     816        7670 :   if (HasDstSel && (Ops[0] & SISrcMods::DST_OP_SEL) != 0)
     817             :     return false;
     818             : 
     819             :   return true;
     820             : }
     821             : 
     822        8273 : void AMDGPUInstPrinter::printPackedModifier(const MCInst *MI,
     823             :                                             StringRef Name,
     824             :                                             unsigned Mod,
     825             :                                             raw_ostream &O) {
     826        8273 :   unsigned Opc = MI->getOpcode();
     827             :   int NumOps = 0;
     828             :   int Ops[3];
     829             : 
     830       44140 :   for (int OpName : { AMDGPU::OpName::src0_modifiers,
     831             :                       AMDGPU::OpName::src1_modifiers,
     832       27594 :                       AMDGPU::OpName::src2_modifiers }) {
     833       24819 :     int Idx = AMDGPU::getNamedOperandIdx(Opc, OpName);
     834       24819 :     if (Idx == -1)
     835             :       break;
     836             : 
     837       38642 :     Ops[NumOps++] = MI->getOperand(Idx).getImm();
     838             :   }
     839             : 
     840             :   const bool HasDstSel =
     841       16546 :     NumOps > 0 &&
     842       19978 :     Mod == SISrcMods::OP_SEL_0 &&
     843        6864 :     MII.get(MI->getOpcode()).TSFlags & SIInstrFlags::VOP3_OPSEL;
     844             : 
     845             :   const bool IsPacked =
     846       16546 :     MII.get(MI->getOpcode()).TSFlags & SIInstrFlags::IsPacked;
     847             : 
     848        8273 :   if (allOpsDefaultValue(Ops, NumOps, Mod, IsPacked, HasDstSel))
     849        7632 :     return;
     850             : 
     851         641 :   O << Name;
     852        3903 :   for (int I = 0; I < NumOps; ++I) {
     853        1631 :     if (I != 0)
     854             :       O << ',';
     855             : 
     856        1631 :     O << !!(Ops[I] & Mod);
     857             :   }
     858             : 
     859         641 :   if (HasDstSel) {
     860         170 :     O << ',' << !!(Ops[0] & SISrcMods::DST_OP_SEL);
     861             :   }
     862             : 
     863             :   O << ']';
     864             : }
     865             : 
     866        3432 : void AMDGPUInstPrinter::printOpSel(const MCInst *MI, unsigned,
     867             :                                    const MCSubtargetInfo &STI,
     868             :                                    raw_ostream &O) {
     869        3432 :   printPackedModifier(MI, " op_sel:[", SISrcMods::OP_SEL_0, O);
     870        3432 : }
     871             : 
     872        1791 : void AMDGPUInstPrinter::printOpSelHi(const MCInst *MI, unsigned OpNo,
     873             :                                      const MCSubtargetInfo &STI,
     874             :                                      raw_ostream &O) {
     875        1791 :   printPackedModifier(MI, " op_sel_hi:[", SISrcMods::OP_SEL_1, O);
     876        1791 : }
     877             : 
     878        1525 : void AMDGPUInstPrinter::printNegLo(const MCInst *MI, unsigned OpNo,
     879             :                                    const MCSubtargetInfo &STI,
     880             :                                    raw_ostream &O) {
     881        1525 :   printPackedModifier(MI, " neg_lo:[", SISrcMods::NEG, O);
     882        1525 : }
     883             : 
     884        1525 : void AMDGPUInstPrinter::printNegHi(const MCInst *MI, unsigned OpNo,
     885             :                                    const MCSubtargetInfo &STI,
     886             :                                    raw_ostream &O) {
     887        1525 :   printPackedModifier(MI, " neg_hi:[", SISrcMods::NEG_HI, O);
     888        1525 : }
     889             : 
     890         159 : void AMDGPUInstPrinter::printInterpSlot(const MCInst *MI, unsigned OpNum,
     891             :                                         const MCSubtargetInfo &STI,
     892             :                                         raw_ostream &O) {
     893         159 :   unsigned Imm = MI->getOperand(OpNum).getImm();
     894         159 :   switch (Imm) {
     895          90 :   case 0:
     896          90 :     O << "p10";
     897          90 :     break;
     898          14 :   case 1:
     899          14 :     O << "p20";
     900          14 :     break;
     901          37 :   case 2:
     902          37 :     O << "p0";
     903          37 :     break;
     904          18 :   default:
     905          18 :     O << "invalid_param_" << Imm;
     906             :   }
     907         159 : }
     908             : 
     909         820 : void AMDGPUInstPrinter::printInterpAttr(const MCInst *MI, unsigned OpNum,
     910             :                                         const MCSubtargetInfo &STI,
     911             :                                         raw_ostream &O) {
     912         820 :   unsigned Attr = MI->getOperand(OpNum).getImm();
     913         820 :   O << "attr" << Attr;
     914         820 : }
     915             : 
     916         820 : void AMDGPUInstPrinter::printInterpAttrChan(const MCInst *MI, unsigned OpNum,
     917             :                                         const MCSubtargetInfo &STI,
     918             :                                         raw_ostream &O) {
     919         820 :   unsigned Chan = MI->getOperand(OpNum).getImm();
     920         820 :   O << '.' << "xyzw"[Chan & 0x3];
     921         820 : }
     922             : 
     923          94 : void AMDGPUInstPrinter::printVGPRIndexMode(const MCInst *MI, unsigned OpNo,
     924             :                                            const MCSubtargetInfo &STI,
     925             :                                            raw_ostream &O) {
     926          94 :   unsigned Val = MI->getOperand(OpNo).getImm();
     927          94 :   if (Val == 0) {
     928          35 :     O << " 0";
     929          35 :     return;
     930             :   }
     931             : 
     932          59 :   if (Val & VGPRIndexMode::DST_ENABLE)
     933          30 :     O << " dst";
     934             : 
     935          59 :   if (Val & VGPRIndexMode::SRC0_ENABLE)
     936          35 :     O << " src0";
     937             : 
     938          59 :   if (Val & VGPRIndexMode::SRC1_ENABLE)
     939           7 :     O << " src1";
     940             : 
     941          59 :   if (Val & VGPRIndexMode::SRC2_ENABLE)
     942           6 :     O << " src2";
     943             : }
     944             : 
     945        1517 : void AMDGPUInstPrinter::printMemOperand(const MCInst *MI, unsigned OpNo,
     946             :                                         const MCSubtargetInfo &STI,
     947             :                                         raw_ostream &O) {
     948        1517 :   if (!STI.getFeatureBits()[AMDGPU::FeatureGCN]) {
     949        1517 :     static_cast<R600InstPrinter*>(this)->printMemOperand(MI, OpNo, O);
     950        1517 :     return;
     951             :   }
     952             : 
     953           0 :   printOperand(MI, OpNo, STI, O);
     954           0 :   O  << ", ";
     955           0 :   printOperand(MI, OpNo + 1, STI, O);
     956             : }
     957             : 
     958      152807 : void AMDGPUInstPrinter::printIfSet(const MCInst *MI, unsigned OpNo,
     959             :                                    raw_ostream &O, StringRef Asm,
     960             :                                    StringRef Default) {
     961             :   const MCOperand &Op = MI->getOperand(OpNo);
     962             :   assert(Op.isImm());
     963      152807 :   if (Op.getImm() == 1) {
     964       25605 :     O << Asm;
     965             :   } else {
     966      127202 :     O << Default;
     967             :   }
     968      152807 : }
     969             : 
     970      364744 : void AMDGPUInstPrinter::printIfSet(const MCInst *MI, unsigned OpNo,
     971             :                                    raw_ostream &O, char Asm) {
     972             :   const MCOperand &Op = MI->getOperand(OpNo);
     973             :   assert(Op.isImm());
     974      364744 :   if (Op.getImm() == 1)
     975             :     O << Asm;
     976      364744 : }
     977             : 
     978      135110 : void AMDGPUInstPrinter::printAbs(const MCInst *MI, unsigned OpNo,
     979             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     980      135110 :   static_cast<R600InstPrinter*>(this)->printAbs(MI, OpNo, O);
     981      135110 : }
     982             : 
     983       45594 : void AMDGPUInstPrinter::printClamp(const MCInst *MI, unsigned OpNo,
     984             :                                    const MCSubtargetInfo &STI, raw_ostream &O) {
     985       45594 :   static_cast<R600InstPrinter*>(this)->printClamp(MI, OpNo, O);
     986       45594 : }
     987             : 
     988         107 : void AMDGPUInstPrinter::printHigh(const MCInst *MI, unsigned OpNo,
     989             :                                   const MCSubtargetInfo &STI,
     990             :                                   raw_ostream &O) {
     991         107 :   if (MI->getOperand(OpNo).getImm())
     992          14 :     O << " high";
     993         107 : }
     994             : 
     995       70283 : void AMDGPUInstPrinter::printClampSI(const MCInst *MI, unsigned OpNo,
     996             :                                      const MCSubtargetInfo &STI,
     997             :                                      raw_ostream &O) {
     998       70283 :   if (MI->getOperand(OpNo).getImm())
     999        1915 :     O << " clamp";
    1000       70283 : }
    1001             : 
    1002       23520 : void AMDGPUInstPrinter::printOModSI(const MCInst *MI, unsigned OpNo,
    1003             :                                     const MCSubtargetInfo &STI,
    1004             :                                     raw_ostream &O) {
    1005       23520 :   int Imm = MI->getOperand(OpNo).getImm();
    1006       23520 :   if (Imm == SIOutMods::MUL2)
    1007         454 :     O << " mul:2";
    1008       23066 :   else if (Imm == SIOutMods::MUL4)
    1009         456 :     O << " mul:4";
    1010       22610 :   else if (Imm == SIOutMods::DIV2)
    1011         449 :     O << " div:2";
    1012       23520 : }
    1013             : 
    1014       26714 : void AMDGPUInstPrinter::printLiteral(const MCInst *MI, unsigned OpNo,
    1015             :                                      const MCSubtargetInfo &STI,
    1016             :                                      raw_ostream &O) {
    1017       26714 :   static_cast<R600InstPrinter*>(this)->printLiteral(MI, OpNo, O);
    1018       26714 : }
    1019             : 
    1020       48957 : void AMDGPUInstPrinter::printLast(const MCInst *MI, unsigned OpNo,
    1021             :                                   const MCSubtargetInfo &STI, raw_ostream &O) {
    1022       48957 :   static_cast<R600InstPrinter*>(this)->printLast(MI, OpNo, O);
    1023       48957 : }
    1024             : 
    1025       89056 : void AMDGPUInstPrinter::printNeg(const MCInst *MI, unsigned OpNo,
    1026             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
    1027       89056 :   static_cast<R600InstPrinter*>(this)->printNeg(MI, OpNo, O);
    1028       89056 : }
    1029             : 
    1030       38427 : void AMDGPUInstPrinter::printOMOD(const MCInst *MI, unsigned OpNo,
    1031             :                                   const MCSubtargetInfo &STI, raw_ostream &O) {
    1032       38427 :   static_cast<R600InstPrinter*>(this)->printOMOD(MI, OpNo, O);
    1033       38427 : }
    1034             : 
    1035      140578 : void AMDGPUInstPrinter::printRel(const MCInst *MI, unsigned OpNo,
    1036             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
    1037      140578 :   static_cast<R600InstPrinter*>(this)->printRel(MI, OpNo, O);
    1038      140578 : }
    1039             : 
    1040       29128 : void AMDGPUInstPrinter::printUpdateExecMask(const MCInst *MI, unsigned OpNo,
    1041             :                                             const MCSubtargetInfo &STI,
    1042             :                                             raw_ostream &O) {
    1043       29128 :   static_cast<R600InstPrinter*>(this)->printUpdateExecMask(MI, OpNo, O);
    1044       29128 : }
    1045             : 
    1046       29128 : void AMDGPUInstPrinter::printUpdatePred(const MCInst *MI, unsigned OpNo,
    1047             :                                         const MCSubtargetInfo &STI,
    1048             :                                         raw_ostream &O) {
    1049       29128 :   static_cast<R600InstPrinter*>(this)->printUpdatePred(MI, OpNo, O);
    1050       29128 : }
    1051             : 
    1052       38427 : void AMDGPUInstPrinter::printWrite(const MCInst *MI, unsigned OpNo,
    1053             :                                    const MCSubtargetInfo &STI, raw_ostream &O) {
    1054       38427 :   static_cast<R600InstPrinter*>(this)->printWrite(MI, OpNo, O);
    1055       38427 : }
    1056             : 
    1057       45594 : void AMDGPUInstPrinter::printBankSwizzle(const MCInst *MI, unsigned OpNo,
    1058             :                                          const MCSubtargetInfo &STI,
    1059             :                                          raw_ostream &O) {
    1060       45594 :   static_cast<R600InstPrinter*>(this)->printBankSwizzle(MI, OpNo, O);
    1061       45594 : }
    1062             : 
    1063        2448 : void AMDGPUInstPrinter::printRSel(const MCInst *MI, unsigned OpNo,
    1064             :                                   const MCSubtargetInfo &STI, raw_ostream &O) {
    1065        2448 :   static_cast<R600InstPrinter*>(this)->printRSel(MI, OpNo, O);
    1066        2448 : }
    1067             : 
    1068        1104 : void AMDGPUInstPrinter::printCT(const MCInst *MI, unsigned OpNo,
    1069             :                                 const MCSubtargetInfo &STI, raw_ostream &O) {
    1070        1104 :   static_cast<R600InstPrinter*>(this)->printCT(MI, OpNo, O);
    1071        1104 : }
    1072             : 
    1073        7196 : void AMDGPUInstPrinter::printKCache(const MCInst *MI, unsigned OpNo,
    1074             :                                     const MCSubtargetInfo &STI, raw_ostream &O) {
    1075        7196 :   static_cast<R600InstPrinter*>(this)->printKCache(MI, OpNo, O);
    1076        7196 : }
    1077             : 
    1078         120 : void AMDGPUInstPrinter::printSendMsg(const MCInst *MI, unsigned OpNo,
    1079             :                                      const MCSubtargetInfo &STI,
    1080             :                                      raw_ostream &O) {
    1081             :   using namespace llvm::AMDGPU::SendMsg;
    1082             : 
    1083         120 :   const unsigned SImm16 = MI->getOperand(OpNo).getImm();
    1084         120 :   const unsigned Id = SImm16 & ID_MASK_;
    1085             :   do {
    1086         120 :     if (Id == ID_INTERRUPT) {
    1087          28 :       if ((SImm16 & ~ID_MASK_) != 0) // Unused/unknown bits must be 0.
    1088             :         break;
    1089          16 :       O << "sendmsg(" << IdSymbolic[Id] << ')';
    1090             :       return;
    1091             :     }
    1092          92 :     if (Id == ID_GS || Id == ID_GS_DONE) {
    1093          70 :       if ((SImm16 & ~(ID_MASK_|OP_GS_MASK_|STREAM_ID_MASK_)) != 0) // Unused/unknown bits must be 0.
    1094             :         break;
    1095          70 :       const unsigned OpGs = (SImm16 & OP_GS_MASK_) >> OP_SHIFT_;
    1096          70 :       const unsigned StreamId = (SImm16 & STREAM_ID_MASK_) >> STREAM_ID_SHIFT_;
    1097          70 :       if (OpGs == OP_GS_NOP && Id != ID_GS_DONE) // NOP to be used for GS_DONE only.
    1098             :         break;
    1099          66 :       if (OpGs == OP_GS_NOP && StreamId != 0) // NOP does not use/define stream id bits.
    1100             :         break;
    1101          66 :       O << "sendmsg(" << IdSymbolic[Id] << ", " << OpGsSymbolic[OpGs];
    1102          66 :       if (OpGs != OP_GS_NOP) {  O << ", " << StreamId; }
    1103             :       O << ')';
    1104             :       return;
    1105             :     }
    1106          22 :     if (Id == ID_SYSMSG) {
    1107          15 :       if ((SImm16 & ~(ID_MASK_|OP_SYS_MASK_)) != 0) // Unused/unknown bits must be 0.
    1108             :         break;
    1109          15 :       const unsigned OpSys = (SImm16 & OP_SYS_MASK_) >> OP_SHIFT_;
    1110          15 :       if (! (OP_SYS_FIRST_ <= OpSys && OpSys < OP_SYS_LAST_)) // Unused/unknown.
    1111             :         break;
    1112          10 :       O << "sendmsg(" << IdSymbolic[Id] << ", " << OpSysSymbolic[OpSys] << ')';
    1113             :       return;
    1114             :     }
    1115             :   } while (false);
    1116             :   O << SImm16; // Unknown simm16 code.
    1117             : }
    1118             : 
    1119          54 : static void printSwizzleBitmask(const uint16_t AndMask,
    1120             :                                 const uint16_t OrMask,
    1121             :                                 const uint16_t XorMask,
    1122             :                                 raw_ostream &O) {
    1123             :   using namespace llvm::AMDGPU::Swizzle;
    1124             : 
    1125          54 :   uint16_t Probe0 = ((0            & AndMask) | OrMask) ^ XorMask;
    1126          54 :   uint16_t Probe1 = ((BITMASK_MASK & AndMask) | OrMask) ^ XorMask;
    1127             : 
    1128          54 :   O << "\"";
    1129             : 
    1130         594 :   for (unsigned Mask = 1 << (BITMASK_WIDTH - 1); Mask > 0; Mask >>= 1) {
    1131         270 :     uint16_t p0 = Probe0 & Mask;
    1132         270 :     uint16_t p1 = Probe1 & Mask;
    1133             : 
    1134         270 :     if (p0 == p1) {
    1135         230 :       if (p0 == 0) {
    1136         205 :         O << "0";
    1137             :       } else {
    1138          25 :         O << "1";
    1139             :       }
    1140             :     } else {
    1141          40 :       if (p0 == 0) {
    1142          26 :         O << "p";
    1143             :       } else {
    1144          14 :         O << "i";
    1145             :       }
    1146             :     }
    1147             :   }
    1148             : 
    1149          54 :   O << "\"";
    1150          54 : }
    1151             : 
    1152         272 : void AMDGPUInstPrinter::printSwizzle(const MCInst *MI, unsigned OpNo,
    1153             :                                      const MCSubtargetInfo &STI,
    1154             :                                      raw_ostream &O) {
    1155             :   using namespace llvm::AMDGPU::Swizzle;
    1156             : 
    1157         272 :   uint16_t Imm = MI->getOperand(OpNo).getImm();
    1158         272 :   if (Imm == 0) {
    1159             :     return;
    1160             :   }
    1161             : 
    1162         241 :   O << " offset:";
    1163             : 
    1164         241 :   if ((Imm & QUAD_PERM_ENC_MASK) == QUAD_PERM_ENC) {
    1165             : 
    1166          14 :     O << "swizzle(" << IdSymbolic[ID_QUAD_PERM];
    1167         126 :     for (auto i = 0; i < LANE_NUM; ++i) {
    1168          56 :       O << ",";
    1169          56 :       O << formatDec(Imm & LANE_MASK);
    1170          56 :       Imm >>= LANE_SHIFT;
    1171             :     }
    1172          14 :     O << ")";
    1173             : 
    1174         227 :   } else if ((Imm & BITMASK_PERM_ENC_MASK) == BITMASK_PERM_ENC) {
    1175             : 
    1176         208 :     uint16_t AndMask = (Imm >> BITMASK_AND_SHIFT) & BITMASK_MASK;
    1177         208 :     uint16_t OrMask  = (Imm >> BITMASK_OR_SHIFT)  & BITMASK_MASK;
    1178         208 :     uint16_t XorMask = (Imm >> BITMASK_XOR_SHIFT) & BITMASK_MASK;
    1179             : 
    1180         416 :     if (AndMask == BITMASK_MAX &&
    1181         493 :         OrMask == 0 &&
    1182             :         countPopulation(XorMask) == 1) {
    1183             : 
    1184          42 :       O << "swizzle(" << IdSymbolic[ID_SWAP];
    1185          42 :       O << ",";
    1186          42 :       O << formatDec(XorMask);
    1187          42 :       O << ")";
    1188             : 
    1189             :     } else if (AndMask == BITMASK_MAX &&
    1190         166 :                OrMask == 0 && XorMask > 0 &&
    1191          35 :                isPowerOf2_64(XorMask + 1)) {
    1192             : 
    1193          35 :       O << "swizzle(" << IdSymbolic[ID_REVERSE];
    1194          35 :       O << ",";
    1195          35 :       O << formatDec(XorMask + 1);
    1196          35 :       O << ")";
    1197             : 
    1198             :     } else {
    1199             : 
    1200         131 :       uint16_t GroupSize = BITMASK_MAX - AndMask + 1;
    1201             :       if (GroupSize > 1 &&
    1202         131 :           isPowerOf2_64(GroupSize) &&
    1203         313 :           OrMask < GroupSize &&
    1204          91 :           XorMask == 0) {
    1205             : 
    1206          77 :         O << "swizzle(" << IdSymbolic[ID_BROADCAST];
    1207          77 :         O << ",";
    1208          77 :         O << formatDec(GroupSize);
    1209          77 :         O << ",";
    1210          77 :         O << formatDec(OrMask);
    1211          77 :         O << ")";
    1212             : 
    1213             :       } else {
    1214          54 :         O << "swizzle(" << IdSymbolic[ID_BITMASK_PERM];
    1215          54 :         O << ",";
    1216          54 :         printSwizzleBitmask(AndMask, OrMask, XorMask, O);
    1217          54 :         O << ")";
    1218             :       }
    1219             :     }
    1220             :   } else {
    1221          19 :     printU16ImmDecOperand(MI, OpNo, O);
    1222             :   }
    1223             : }
    1224             : 
    1225       39065 : void AMDGPUInstPrinter::printWaitFlag(const MCInst *MI, unsigned OpNo,
    1226             :                                       const MCSubtargetInfo &STI,
    1227             :                                       raw_ostream &O) {
    1228             :   AMDGPU::IsaInfo::IsaVersion ISA =
    1229       39065 :       AMDGPU::IsaInfo::getIsaVersion(STI.getFeatureBits());
    1230             : 
    1231       39065 :   unsigned SImm16 = MI->getOperand(OpNo).getImm();
    1232             :   unsigned Vmcnt, Expcnt, Lgkmcnt;
    1233       39065 :   decodeWaitcnt(ISA, SImm16, Vmcnt, Expcnt, Lgkmcnt);
    1234             : 
    1235             :   bool NeedSpace = false;
    1236             : 
    1237       39065 :   if (Vmcnt != getVmcntBitMask(ISA)) {
    1238       17031 :     O << "vmcnt(" << Vmcnt << ')';
    1239             :     NeedSpace = true;
    1240             :   }
    1241             : 
    1242       39065 :   if (Expcnt != getExpcntBitMask(ISA)) {
    1243        5960 :     if (NeedSpace)
    1244             :       O << ' ';
    1245        5960 :     O << "expcnt(" << Expcnt << ')';
    1246             :     NeedSpace = true;
    1247             :   }
    1248             : 
    1249       39065 :   if (Lgkmcnt != getLgkmcntBitMask(ISA)) {
    1250       21274 :     if (NeedSpace)
    1251             :       O << ' ';
    1252       21274 :     O << "lgkmcnt(" << Lgkmcnt << ')';
    1253             :   }
    1254       39065 : }
    1255             : 
    1256         265 : void AMDGPUInstPrinter::printHwreg(const MCInst *MI, unsigned OpNo,
    1257             :                                    const MCSubtargetInfo &STI, raw_ostream &O) {
    1258             :   using namespace llvm::AMDGPU::Hwreg;
    1259             : 
    1260         265 :   unsigned SImm16 = MI->getOperand(OpNo).getImm();
    1261         265 :   const unsigned Id = (SImm16 & ID_MASK_) >> ID_SHIFT_;
    1262         265 :   const unsigned Offset = (SImm16 & OFFSET_MASK_) >> OFFSET_SHIFT_;
    1263         265 :   const unsigned Width = ((SImm16 & WIDTH_M1_MASK_) >> WIDTH_M1_SHIFT_) + 1;
    1264             : 
    1265         265 :   O << "hwreg(";
    1266             :   unsigned Last = ID_SYMBOLIC_LAST_;
    1267         265 :   if (AMDGPU::isSI(STI) || AMDGPU::isCI(STI) || AMDGPU::isVI(STI))
    1268             :     Last = ID_SYMBOLIC_FIRST_GFX9_;
    1269         265 :   if (ID_SYMBOLIC_FIRST_ <= Id && Id < Last && IdSymbolic[Id]) {
    1270         228 :     O << IdSymbolic[Id];
    1271             :   } else {
    1272             :     O << Id;
    1273             :   }
    1274         265 :   if (Width != WIDTH_M1_DEFAULT_ + 1 || Offset != OFFSET_DEFAULT_) {
    1275         468 :     O << ", " << Offset << ", " << Width;
    1276             :   }
    1277             :   O << ')';
    1278         265 : }
    1279             : 
    1280             : #include "AMDGPUGenAsmWriter.inc"
    1281             : 
    1282      135110 : void R600InstPrinter::printAbs(const MCInst *MI, unsigned OpNo,
    1283             :                                raw_ostream &O) {
    1284      135110 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, '|');
    1285      135110 : }
    1286             : 
    1287       45594 : void R600InstPrinter::printBankSwizzle(const MCInst *MI, unsigned OpNo,
    1288             :                                        raw_ostream &O) {
    1289       45594 :   int BankSwizzle = MI->getOperand(OpNo).getImm();
    1290       45594 :   switch (BankSwizzle) {
    1291         961 :   case 1:
    1292         961 :     O << "BS:VEC_021/SCL_122";
    1293         961 :     break;
    1294         704 :   case 2:
    1295         704 :     O << "BS:VEC_120/SCL_212";
    1296         704 :     break;
    1297         115 :   case 3:
    1298         115 :     O << "BS:VEC_102/SCL_221";
    1299         115 :     break;
    1300         176 :   case 4:
    1301         176 :     O << "BS:VEC_201";
    1302         176 :     break;
    1303          30 :   case 5:
    1304          30 :     O << "BS:VEC_210";
    1305          30 :     break;
    1306             :   default:
    1307             :     break;
    1308             :   }
    1309       45594 : }
    1310             : 
    1311       45594 : void R600InstPrinter::printClamp(const MCInst *MI, unsigned OpNo,
    1312             :                                  raw_ostream &O) {
    1313       45594 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, "_SAT");
    1314       45594 : }
    1315             : 
    1316        1104 : void R600InstPrinter::printCT(const MCInst *MI, unsigned OpNo,
    1317             :                                 raw_ostream &O) {
    1318        1104 :   unsigned CT = MI->getOperand(OpNo).getImm();
    1319        1104 :   switch (CT) {
    1320             :   case 0:
    1321             :     O << 'U';
    1322             :     break;
    1323             :   case 1:
    1324             :     O << 'N';
    1325             :     break;
    1326             :   default:
    1327             :     break;
    1328             :   }
    1329        1104 : }
    1330             : 
    1331        7196 : void R600InstPrinter::printKCache(const MCInst *MI, unsigned OpNo,
    1332             :                                   raw_ostream &O) {
    1333        7196 :   int KCacheMode = MI->getOperand(OpNo).getImm();
    1334        7196 :   if (KCacheMode > 0) {
    1335        6328 :     int KCacheBank = MI->getOperand(OpNo - 2).getImm();
    1336        3164 :     O << "CB" << KCacheBank << ':';
    1337        6328 :     int KCacheAddr = MI->getOperand(OpNo + 2).getImm();
    1338        3164 :     int LineSize = (KCacheMode == 1) ? 16 : 32;
    1339        6328 :     O << KCacheAddr * 16 << '-' << KCacheAddr * 16 + LineSize;
    1340             :   }
    1341        7196 : }
    1342             : 
    1343       48957 : void R600InstPrinter::printLast(const MCInst *MI, unsigned OpNo,
    1344             :                                 raw_ostream &O) {
    1345       48957 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, "*", " ");
    1346       48957 : }
    1347             : 
    1348       26714 : void R600InstPrinter::printLiteral(const MCInst *MI, unsigned OpNo,
    1349             :                                    raw_ostream &O) {
    1350             :   const MCOperand &Op = MI->getOperand(OpNo);
    1351             :   assert(Op.isImm() || Op.isExpr());
    1352       26714 :   if (Op.isImm()) {
    1353       26701 :     int64_t Imm = Op.getImm();
    1354       53402 :     O << Imm << '(' << BitsToFloat(Imm) << ')';
    1355             :   }
    1356       26714 :   if (Op.isExpr()) {
    1357          26 :     Op.getExpr()->print(O << '@', &MAI);
    1358             :   }
    1359       26714 : }
    1360             : 
    1361       89056 : void R600InstPrinter::printNeg(const MCInst *MI, unsigned OpNo,
    1362             :                                raw_ostream &O) {
    1363       89056 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, '-');
    1364       89056 : }
    1365             : 
    1366       38427 : void R600InstPrinter::printOMOD(const MCInst *MI, unsigned OpNo,
    1367             :                                 raw_ostream &O) {
    1368       38427 :   switch (MI->getOperand(OpNo).getImm()) {
    1369             :   default: break;
    1370           0 :   case 1:
    1371           0 :     O << " * 2.0";
    1372           0 :     break;
    1373           0 :   case 2:
    1374           0 :     O << " * 4.0";
    1375           0 :     break;
    1376           0 :   case 3:
    1377           0 :     O << " / 2.0";
    1378           0 :     break;
    1379             :   }
    1380       38427 : }
    1381             : 
    1382        1517 : void R600InstPrinter::printMemOperand(const MCInst *MI, unsigned OpNo,
    1383             :                                       raw_ostream &O) {
    1384        1517 :   printOperand(MI, OpNo, O);
    1385        1517 :   O  << ", ";
    1386        1517 :   printOperand(MI, OpNo + 1, O);
    1387        1517 : }
    1388             : 
    1389      219811 : void R600InstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
    1390             :                                    raw_ostream &O) {
    1391      219811 :   if (OpNo >= MI->getNumOperands()) {
    1392           0 :     O << "/*Missing OP" << OpNo << "*/";
    1393           0 :     return;
    1394             :   }
    1395             : 
    1396             :   const MCOperand &Op = MI->getOperand(OpNo);
    1397      219811 :   if (Op.isReg()) {
    1398      199656 :     switch (Op.getReg()) {
    1399             :     // This is the default predicate state, so we don't need to print it.
    1400             :     case AMDGPU::PRED_SEL_OFF:
    1401             :       break;
    1402             : 
    1403      150953 :     default:
    1404      150953 :       O << getRegisterName(Op.getReg());
    1405      150953 :       break;
    1406             :     }
    1407       20155 :   } else if (Op.isImm()) {
    1408       20153 :       O << Op.getImm();
    1409           2 :   } else if (Op.isFPImm()) {
    1410             :     // We special case 0.0 because otherwise it will be printed as an integer.
    1411           0 :     if (Op.getFPImm() == 0.0)
    1412           0 :       O << "0.0";
    1413             :     else {
    1414           0 :       O << Op.getFPImm();
    1415             :     }
    1416           2 :   } else if (Op.isExpr()) {
    1417           2 :     const MCExpr *Exp = Op.getExpr();
    1418           2 :     Exp->print(O, &MAI);
    1419             :   } else {
    1420           0 :     O << "/*INV_OP*/";
    1421             :   }
    1422             : }
    1423             : 
    1424      140578 : void R600InstPrinter::printRel(const MCInst *MI, unsigned OpNo,
    1425             :                                raw_ostream &O) {
    1426      140578 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, '+');
    1427      140578 : }
    1428             : 
    1429        2448 : void R600InstPrinter::printRSel(const MCInst *MI, unsigned OpNo,
    1430             :                                   raw_ostream &O) {
    1431        2448 :   unsigned Sel = MI->getOperand(OpNo).getImm();
    1432        2448 :   switch (Sel) {
    1433             :   case 0:
    1434             :     O << 'X';
    1435             :     break;
    1436             :   case 1:
    1437             :     O << 'Y';
    1438             :     break;
    1439             :   case 2:
    1440             :     O << 'Z';
    1441             :     break;
    1442             :   case 3:
    1443             :     O << 'W';
    1444             :     break;
    1445             :   case 4:
    1446             :     O << '0';
    1447             :     break;
    1448             :   case 5:
    1449             :     O << '1';
    1450             :     break;
    1451             :   case 7:
    1452             :     O << '_';
    1453             :     break;
    1454             :   default:
    1455             :     break;
    1456             :   }
    1457        2448 : }
    1458             : 
    1459       29128 : void R600InstPrinter::printUpdateExecMask(const MCInst *MI, unsigned OpNo,
    1460             :                                           raw_ostream &O) {
    1461       29128 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, "ExecMask,");
    1462       29128 : }
    1463             : 
    1464       29128 : void R600InstPrinter::printUpdatePred(const MCInst *MI, unsigned OpNo,
    1465             :                                       raw_ostream &O) {
    1466       29128 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, "Pred,");
    1467       29128 : }
    1468             : 
    1469       38427 : void R600InstPrinter::printWrite(const MCInst *MI, unsigned OpNo,
    1470             :                                  raw_ostream &O) {
    1471             :   const MCOperand &Op = MI->getOperand(OpNo);
    1472       38427 :   if (Op.getImm() == 0) {
    1473         619 :     O << " (MASKED)";
    1474             :   }
    1475       38427 : }

Generated by: LCOV version 1.13