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

Generated by: LCOV version 1.13