LCOV - code coverage report
Current view: top level - lib/Target/AMDGPU/InstPrinter - AMDGPUInstPrinter.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 751 825 91.0 %
Date: 2018-09-23 13:06:45 Functions: 93 99 93.9 %
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      584517 : void AMDGPUInstPrinter::printInst(const MCInst *MI, raw_ostream &OS,
      31             :                                   StringRef Annot, const MCSubtargetInfo &STI) {
      32             :   OS.flush();
      33      584517 :   printInstruction(MI, STI, OS);
      34      584517 :   printAnnotation(OS, Annot);
      35      584517 : }
      36             : 
      37       30410 : void AMDGPUInstPrinter::printU4ImmOperand(const MCInst *MI, unsigned OpNo,
      38             :                                           const MCSubtargetInfo &STI,
      39             :                                           raw_ostream &O) {
      40       60820 :   O << formatHex(MI->getOperand(OpNo).getImm() & 0xf);
      41       30410 : }
      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        7885 : 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        7885 :   int64_t Imm = MI->getOperand(OpNo).getImm();
      54        7885 :   if (isInt<16>(Imm) || isUInt<16>(Imm))
      55        7881 :     O << formatHex(static_cast<uint64_t>(Imm & 0xffff));
      56             :   else
      57           4 :     printU32ImmOperand(MI, OpNo, STI, O);
      58        7885 : }
      59             : 
      60        3591 : void AMDGPUInstPrinter::printU4ImmDecOperand(const MCInst *MI, unsigned OpNo,
      61             :                                              raw_ostream &O) {
      62        7182 :   O << formatDec(MI->getOperand(OpNo).getImm() & 0xf);
      63        3591 : }
      64             : 
      65        7697 : void AMDGPUInstPrinter::printU8ImmDecOperand(const MCInst *MI, unsigned OpNo,
      66             :                                              raw_ostream &O) {
      67       15394 :   O << formatDec(MI->getOperand(OpNo).getImm() & 0xff);
      68        7697 : }
      69             : 
      70       30983 : void AMDGPUInstPrinter::printU16ImmDecOperand(const MCInst *MI, unsigned OpNo,
      71             :                                               raw_ostream &O) {
      72       61966 :   O << formatDec(MI->getOperand(OpNo).getImm() & 0xffff);
      73       30983 : }
      74             : 
      75        1652 : void AMDGPUInstPrinter::printS13ImmDecOperand(const MCInst *MI, unsigned OpNo,
      76             :                                               raw_ostream &O) {
      77        4956 :   O << formatDec(SignExtend32<13>(MI->getOperand(OpNo).getImm()));
      78        1652 : }
      79             : 
      80       26694 : void AMDGPUInstPrinter::printU32ImmOperand(const MCInst *MI, unsigned OpNo,
      81             :                                            const MCSubtargetInfo &STI,
      82             :                                            raw_ostream &O) {
      83       53388 :   O << formatHex(MI->getOperand(OpNo).getImm() & 0xffffffff);
      84       26694 : }
      85             : 
      86      232404 : void AMDGPUInstPrinter::printNamedBit(const MCInst *MI, unsigned OpNo,
      87             :                                       raw_ostream &O, StringRef BitName) {
      88      232404 :   if (MI->getOperand(OpNo).getImm()) {
      89        6725 :     O << ' ' << BitName;
      90             :   }
      91      232404 : }
      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       64724 : void AMDGPUInstPrinter::printOffset(const MCInst *MI, unsigned OpNo,
     117             :                                     const MCSubtargetInfo &STI,
     118             :                                     raw_ostream &O) {
     119       64724 :   uint16_t Imm = MI->getOperand(OpNo).getImm();
     120       64724 :   if (Imm != 0) {
     121       61876 :     O << ((OpNo == 0)? "offset:" : " offset:");
     122       30960 :     printU16ImmDecOperand(MI, OpNo, O);
     123             :   }
     124       64724 : }
     125             : 
     126        4484 : void AMDGPUInstPrinter::printOffsetS13(const MCInst *MI, unsigned OpNo,
     127             :                                        const MCSubtargetInfo &STI,
     128             :                                        raw_ostream &O) {
     129        4484 :   uint16_t Imm = MI->getOperand(OpNo).getImm();
     130        4484 :   if (Imm != 0) {
     131        3304 :     O << ((OpNo == 0)? "offset:" : " offset:");
     132        1652 :     printS13ImmDecOperand(MI, OpNo, O);
     133             :   }
     134        4484 : }
     135             : 
     136        4522 : void AMDGPUInstPrinter::printOffset0(const MCInst *MI, unsigned OpNo,
     137             :                                      const MCSubtargetInfo &STI,
     138             :                                      raw_ostream &O) {
     139        4522 :   if (MI->getOperand(OpNo).getImm()) {
     140        3407 :     O << " offset0:";
     141        3407 :     printU8ImmDecOperand(MI, OpNo, O);
     142             :   }
     143        4522 : }
     144             : 
     145        4522 : void AMDGPUInstPrinter::printOffset1(const MCInst *MI, unsigned OpNo,
     146             :                                      const MCSubtargetInfo &STI,
     147             :                                      raw_ostream &O) {
     148        4522 :   if (MI->getOperand(OpNo).getImm()) {
     149        4290 :     O << " offset1:";
     150        4290 :     printU8ImmDecOperand(MI, OpNo, O);
     151             :   }
     152        4522 : }
     153             : 
     154       11835 : void AMDGPUInstPrinter::printSMRDOffset8(const MCInst *MI, unsigned OpNo,
     155             :                                         const MCSubtargetInfo &STI,
     156             :                                         raw_ostream &O) {
     157       11835 :   printU32ImmOperand(MI, OpNo, STI, O);
     158       11835 : }
     159             : 
     160       14655 : void AMDGPUInstPrinter::printSMRDOffset20(const MCInst *MI, unsigned OpNo,
     161             :                                         const MCSubtargetInfo &STI,
     162             :                                         raw_ostream &O) {
     163       14655 :   printU32ImmOperand(MI, OpNo, STI, O);
     164       14655 : }
     165             : 
     166          42 : void AMDGPUInstPrinter::printSMRDLiteralOffset(const MCInst *MI, unsigned OpNo,
     167             :                                                const MCSubtargetInfo &STI,
     168             :                                                raw_ostream &O) {
     169          42 :   printU32ImmOperand(MI, OpNo, STI, O);
     170          42 : }
     171             : 
     172       15474 : void AMDGPUInstPrinter::printGDS(const MCInst *MI, unsigned OpNo,
     173             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     174       15474 :   printNamedBit(MI, OpNo, O, "gds");
     175       15474 : }
     176             : 
     177       86011 : void AMDGPUInstPrinter::printGLC(const MCInst *MI, unsigned OpNo,
     178             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     179       86011 :   printNamedBit(MI, OpNo, O, "glc");
     180       86011 : }
     181             : 
     182       63354 : void AMDGPUInstPrinter::printSLC(const MCInst *MI, unsigned OpNo,
     183             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     184       63354 :   printNamedBit(MI, OpNo, O, "slc");
     185       63354 : }
     186             : 
     187       43257 : void AMDGPUInstPrinter::printTFE(const MCInst *MI, unsigned OpNo,
     188             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     189       43257 :   printNamedBit(MI, OpNo, O, "tfe");
     190       43257 : }
     191             : 
     192        5138 : void AMDGPUInstPrinter::printDMask(const MCInst *MI, unsigned OpNo,
     193             :                                    const MCSubtargetInfo &STI, raw_ostream &O) {
     194        5138 :   if (MI->getOperand(OpNo).getImm()) {
     195        4856 :     O << " dmask:";
     196        4856 :     printU16ImmOperand(MI, OpNo, STI, O);
     197             :   }
     198        5138 : }
     199             : 
     200        5138 : void AMDGPUInstPrinter::printUNorm(const MCInst *MI, unsigned OpNo,
     201             :                                    const MCSubtargetInfo &STI, raw_ostream &O) {
     202        5138 :   printNamedBit(MI, OpNo, O, "unorm");
     203        5138 : }
     204             : 
     205        5138 : void AMDGPUInstPrinter::printDA(const MCInst *MI, unsigned OpNo,
     206             :                                 const MCSubtargetInfo &STI, raw_ostream &O) {
     207        5138 :   printNamedBit(MI, OpNo, O, "da");
     208        5138 : }
     209             : 
     210        5138 : void AMDGPUInstPrinter::printR128A16(const MCInst *MI, unsigned OpNo,
     211             :                                   const MCSubtargetInfo &STI, raw_ostream &O) {
     212        5138 :   if (STI.hasFeature(AMDGPU::FeatureR128A16))
     213        1583 :     printNamedBit(MI, OpNo, O, "a16");
     214             :   else
     215        3555 :     printNamedBit(MI, OpNo, O, "r128");
     216        5138 : }
     217             : 
     218        5138 : void AMDGPUInstPrinter::printLWE(const MCInst *MI, unsigned OpNo,
     219             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     220        5138 :   printNamedBit(MI, OpNo, O, "lwe");
     221        5138 : }
     222             : 
     223        3756 : void AMDGPUInstPrinter::printD16(const MCInst *MI, unsigned OpNo,
     224             :                                  const MCSubtargetInfo &STI, raw_ostream &O) {
     225        3756 :   printNamedBit(MI, OpNo, O, "d16");
     226        3756 : }
     227             : 
     228         737 : void AMDGPUInstPrinter::printExpCompr(const MCInst *MI, unsigned OpNo,
     229             :                                       const MCSubtargetInfo &STI,
     230             :                                       raw_ostream &O) {
     231         737 :   if (MI->getOperand(OpNo).getImm())
     232         113 :     O << " compr";
     233         737 : }
     234             : 
     235         737 : void AMDGPUInstPrinter::printExpVM(const MCInst *MI, unsigned OpNo,
     236             :                                    const MCSubtargetInfo &STI,
     237             :                                    raw_ostream &O) {
     238         737 :   if (MI->getOperand(OpNo).getImm())
     239         202 :     O << " vm";
     240         737 : }
     241             : 
     242         318 : void AMDGPUInstPrinter::printFORMAT(const MCInst *MI, unsigned OpNo,
     243             :                                     const MCSubtargetInfo &STI,
     244             :                                     raw_ostream &O) {
     245         318 :   if (unsigned Val = MI->getOperand(OpNo).getImm()) {
     246         318 :     O << " dfmt:" << (Val & 15);
     247         318 :     O << ", nfmt:" << (Val >> 4);
     248             :   }
     249         318 : }
     250             : 
     251     1213510 : void AMDGPUInstPrinter::printRegOperand(unsigned RegNo, raw_ostream &O,
     252             :                                         const MCRegisterInfo &MRI) {
     253     1213510 :   switch (RegNo) {
     254        7583 :   case AMDGPU::VCC:
     255        7583 :     O << "vcc";
     256        7583 :     return;
     257           0 :   case AMDGPU::SCC:
     258           0 :     O << "scc";
     259           0 :     return;
     260        5330 :   case AMDGPU::EXEC:
     261        5330 :     O << "exec";
     262        5330 :     return;
     263        9586 :   case AMDGPU::M0:
     264        9586 :     O << "m0";
     265        9586 :     return;
     266           0 :   case AMDGPU::FLAT_SCR:
     267           0 :     O << "flat_scratch";
     268           0 :     return;
     269           4 :   case AMDGPU::XNACK_MASK:
     270           4 :     O << "xnack_mask";
     271           4 :     return;
     272        7136 :   case AMDGPU::VCC_LO:
     273        7136 :     O << "vcc_lo";
     274        7136 :     return;
     275        7136 :   case AMDGPU::VCC_HI:
     276        7136 :     O << "vcc_hi";
     277        7136 :     return;
     278        2870 :   case AMDGPU::TBA_LO:
     279        2870 :     O << "tba_lo";
     280        2870 :     return;
     281        2870 :   case AMDGPU::TBA_HI:
     282        2870 :     O << "tba_hi";
     283        2870 :     return;
     284        2884 :   case AMDGPU::TMA_LO:
     285        2884 :     O << "tma_lo";
     286        2884 :     return;
     287        2877 :   case AMDGPU::TMA_HI:
     288        2877 :     O << "tma_hi";
     289        2877 :     return;
     290        6902 :   case AMDGPU::EXEC_LO:
     291        6902 :     O << "exec_lo";
     292        6902 :     return;
     293        6895 :   case AMDGPU::EXEC_HI:
     294        6895 :     O << "exec_hi";
     295        6895 :     return;
     296           0 :   case AMDGPU::FLAT_SCR_LO:
     297           0 :     O << "flat_scratch_lo";
     298           0 :     return;
     299           0 :   case AMDGPU::FLAT_SCR_HI:
     300           0 :     O << "flat_scratch_hi";
     301           0 :     return;
     302           3 :   case AMDGPU::XNACK_MASK_LO:
     303           3 :     O << "xnack_mask_lo";
     304           3 :     return;
     305           4 :   case AMDGPU::XNACK_MASK_HI:
     306           4 :     O << "xnack_mask_hi";
     307           4 :     return;
     308             :   case AMDGPU::FP_REG:
     309             :   case AMDGPU::SP_REG:
     310             :   case AMDGPU::SCRATCH_WAVE_OFFSET_REG:
     311             :   case AMDGPU::PRIVATE_RSRC_REG:
     312             :     llvm_unreachable("pseudo-register should not ever be emitted");
     313             :   default:
     314             :     break;
     315             :   }
     316             : 
     317             :   // The low 8 bits of the encoding value is the register index, for both VGPRs
     318             :   // and SGPRs.
     319     1151430 :   unsigned RegIdx = MRI.getEncodingValue(RegNo) & ((1 << 8) - 1);
     320             : 
     321             :   unsigned NumRegs;
     322     1151430 :   if (MRI.getRegClass(AMDGPU::VGPR_32RegClassID).contains(RegNo)) {
     323             :     O << 'v';
     324             :     NumRegs = 1;
     325      553566 :   } else  if (MRI.getRegClass(AMDGPU::SGPR_32RegClassID).contains(RegNo)) {
     326             :     O << 's';
     327             :     NumRegs = 1;
     328      329208 :   } else if (MRI.getRegClass(AMDGPU::VReg_64RegClassID).contains(RegNo)) {
     329             :     O <<'v';
     330             :     NumRegs = 2;
     331      240772 :   } else  if (MRI.getRegClass(AMDGPU::SGPR_64RegClassID).contains(RegNo)) {
     332             :     O << 's';
     333             :     NumRegs = 2;
     334      107565 :   } else if (MRI.getRegClass(AMDGPU::VReg_128RegClassID).contains(RegNo)) {
     335             :     O << 'v';
     336             :     NumRegs = 4;
     337       89307 :   } else  if (MRI.getRegClass(AMDGPU::SGPR_128RegClassID).contains(RegNo)) {
     338             :     O << 's';
     339             :     NumRegs = 4;
     340       36660 :   } else if (MRI.getRegClass(AMDGPU::VReg_96RegClassID).contains(RegNo)) {
     341             :     O << 'v';
     342             :     NumRegs = 3;
     343       35429 :   } else if (MRI.getRegClass(AMDGPU::VReg_256RegClassID).contains(RegNo)) {
     344             :     O << 'v';
     345             :     NumRegs = 8;
     346       35297 :   } else if (MRI.getRegClass(AMDGPU::SGPR_256RegClassID).contains(RegNo)) {
     347             :     O << 's';
     348             :     NumRegs = 8;
     349       29078 :   } else if (MRI.getRegClass(AMDGPU::VReg_512RegClassID).contains(RegNo)) {
     350             :     O << 'v';
     351             :     NumRegs = 16;
     352       29066 :   } else if (MRI.getRegClass(AMDGPU::SGPR_512RegClassID).contains(RegNo)) {
     353             :     O << 's';
     354             :     NumRegs = 16;
     355             :   } else {
     356       28536 :     O << getRegisterName(RegNo);
     357       28536 :     return;
     358             :   }
     359             : 
     360             :   if (NumRegs == 1) {
     361             :     O << RegIdx;
     362      822222 :     return;
     363             :   }
     364             : 
     365      300672 :   O << '[' << RegIdx << ':' << (RegIdx + NumRegs - 1) << ']';
     366             : }
     367             : 
     368      241587 : void AMDGPUInstPrinter::printVOPDst(const MCInst *MI, unsigned OpNo,
     369             :                                     const MCSubtargetInfo &STI, raw_ostream &O) {
     370      483174 :   if (MII.get(MI->getOpcode()).TSFlags & SIInstrFlags::VOP3)
     371       73743 :     O << "_e64 ";
     372      167844 :   else if (MII.get(MI->getOpcode()).TSFlags & SIInstrFlags::DPP)
     373       15201 :     O << "_dpp ";
     374      152643 :   else if (MII.get(MI->getOpcode()).TSFlags & SIInstrFlags::SDWA)
     375       34248 :     O << "_sdwa ";
     376             :   else
     377      118395 :     O << "_e32 ";
     378             : 
     379      241587 :   printOperand(MI, OpNo, STI, O);
     380      241587 : }
     381             : 
     382         676 : void AMDGPUInstPrinter::printVINTRPDst(const MCInst *MI, unsigned OpNo,
     383             :                                        const MCSubtargetInfo &STI, raw_ostream &O) {
     384         676 :   if (AMDGPU::isSI(STI) || AMDGPU::isCI(STI))
     385         178 :     O << " ";
     386             :   else
     387         498 :     O << "_e32 ";
     388             : 
     389         676 :   printOperand(MI, OpNo, STI, O);
     390         676 : }
     391             : 
     392       12601 : void AMDGPUInstPrinter::printImmediate16(uint32_t Imm,
     393             :                                          const MCSubtargetInfo &STI,
     394             :                                          raw_ostream &O) {
     395       12601 :   int16_t SImm = static_cast<int16_t>(Imm);
     396       12601 :   if (SImm >= -16 && SImm <= 64) {
     397             :     O << SImm;
     398        6989 :     return;
     399             :   }
     400             : 
     401        5612 :   if (Imm == 0x3C00)
     402          97 :     O<< "1.0";
     403        5515 :   else if (Imm == 0xBC00)
     404          21 :     O<< "-1.0";
     405        5494 :   else if (Imm == 0x3800)
     406        2121 :     O<< "0.5";
     407        3373 :   else if (Imm == 0xB800)
     408           9 :     O<< "-0.5";
     409        3364 :   else if (Imm == 0x4000)
     410          70 :     O<< "2.0";
     411        3294 :   else if (Imm == 0xC000)
     412          23 :     O<< "-2.0";
     413        3271 :   else if (Imm == 0x4400)
     414          65 :     O<< "4.0";
     415        3206 :   else if (Imm == 0xC400)
     416        2071 :     O<< "-4.0";
     417        1135 :   else if (Imm == 0x3118) {
     418             :     assert(STI.getFeatureBits()[AMDGPU::FeatureInv2PiInlineImm]);
     419          17 :     O << "0.15915494";
     420             :   } else
     421        1118 :     O << formatHex(static_cast<uint64_t>(Imm));
     422             : }
     423             : 
     424         325 : void AMDGPUInstPrinter::printImmediateV216(uint32_t Imm,
     425             :                                            const MCSubtargetInfo &STI,
     426             :                                            raw_ostream &O) {
     427             :   uint16_t Lo16 = static_cast<uint16_t>(Imm);
     428         325 :   printImmediate16(Lo16, STI, O);
     429         325 : }
     430             : 
     431      135162 : void AMDGPUInstPrinter::printImmediate32(uint32_t Imm,
     432             :                                          const MCSubtargetInfo &STI,
     433             :                                          raw_ostream &O) {
     434      135162 :   int32_t SImm = static_cast<int32_t>(Imm);
     435      135162 :   if (SImm >= -16 && SImm <= 64) {
     436             :     O << SImm;
     437      100517 :     return;
     438             :   }
     439             : 
     440             :   if (Imm == FloatToBits(0.0f))
     441             :     O << "0.0";
     442       34645 :   else if (Imm == FloatToBits(1.0f))
     443         931 :     O << "1.0";
     444       33714 :   else if (Imm == FloatToBits(-1.0f))
     445         135 :     O << "-1.0";
     446       33579 :   else if (Imm == FloatToBits(0.5f))
     447        4919 :     O << "0.5";
     448       28660 :   else if (Imm == FloatToBits(-0.5f))
     449          21 :     O << "-0.5";
     450       28639 :   else if (Imm == FloatToBits(2.0f))
     451         380 :     O << "2.0";
     452       28259 :   else if (Imm == FloatToBits(-2.0f))
     453         101 :     O << "-2.0";
     454       28158 :   else if (Imm == FloatToBits(4.0f))
     455         333 :     O << "4.0";
     456       27825 :   else if (Imm == FloatToBits(-4.0f))
     457        4804 :     O << "-4.0";
     458       23021 :   else if (Imm == 0x3e22f983 &&
     459             :            STI.getFeatureBits()[AMDGPU::FeatureInv2PiInlineImm])
     460          93 :     O << "0.15915494";
     461             :   else
     462       22928 :     O << formatHex(static_cast<uint64_t>(Imm));
     463             : }
     464             : 
     465       10545 : void AMDGPUInstPrinter::printImmediate64(uint64_t Imm,
     466             :                                          const MCSubtargetInfo &STI,
     467             :                                          raw_ostream &O) {
     468       10545 :   int64_t SImm = static_cast<int64_t>(Imm);
     469       10545 :   if (SImm >= -16 && SImm <= 64) {
     470        4549 :     O << SImm;
     471        4549 :     return;
     472             :   }
     473             : 
     474             :   if (Imm == DoubleToBits(0.0))
     475             :     O << "0.0";
     476        5996 :   else if (Imm == DoubleToBits(1.0))
     477         169 :     O << "1.0";
     478        5827 :   else if (Imm == DoubleToBits(-1.0))
     479          33 :     O << "-1.0";
     480        5794 :   else if (Imm == DoubleToBits(0.5))
     481        1970 :     O << "0.5";
     482        3824 :   else if (Imm == DoubleToBits(-0.5))
     483           4 :     O << "-0.5";
     484        3820 :   else if (Imm == DoubleToBits(2.0))
     485          43 :     O << "2.0";
     486        3777 :   else if (Imm == DoubleToBits(-2.0))
     487           4 :     O << "-2.0";
     488        3773 :   else if (Imm == DoubleToBits(4.0))
     489          35 :     O << "4.0";
     490        3738 :   else if (Imm == DoubleToBits(-4.0))
     491        1947 :     O << "-4.0";
     492        1791 :   else if (Imm == 0x3fc45f306dc9c882 &&
     493             :            STI.getFeatureBits()[AMDGPU::FeatureInv2PiInlineImm])
     494          19 :   O << "0.15915494";
     495             :   else {
     496             :     assert(isUInt<32>(Imm) || Imm == 0x3fc45f306dc9c882);
     497             : 
     498             :     // In rare situations, we will have a 32-bit literal in a 64-bit
     499             :     // operand. This is technically allowed for the encoding of s_mov_b64.
     500        1772 :     O << formatHex(static_cast<uint64_t>(Imm));
     501             :   }
     502             : }
     503             : 
     504     1371964 : void AMDGPUInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
     505             :                                      const MCSubtargetInfo &STI,
     506             :                                      raw_ostream &O) {
     507     1371964 :   if (OpNo >= MI->getNumOperands()) {
     508           0 :     O << "/*Missing OP" << OpNo << "*/";
     509           0 :     return;
     510             :   }
     511             : 
     512             :   const MCOperand &Op = MI->getOperand(OpNo);
     513     1371964 :   if (Op.isReg()) {
     514     1210393 :     printRegOperand(Op.getReg(), O, MRI);
     515      161571 :   } else if (Op.isImm()) {
     516      158482 :     const MCInstrDesc &Desc = MII.get(MI->getOpcode());
     517      158482 :     switch (Desc.OpInfo[OpNo].OperandType) {
     518      135162 :     case AMDGPU::OPERAND_REG_IMM_INT32:
     519             :     case AMDGPU::OPERAND_REG_IMM_FP32:
     520             :     case AMDGPU::OPERAND_REG_INLINE_C_INT32:
     521             :     case AMDGPU::OPERAND_REG_INLINE_C_FP32:
     522             :     case MCOI::OPERAND_IMMEDIATE:
     523      135162 :       printImmediate32(Op.getImm(), STI, O);
     524      135162 :       break;
     525       10545 :     case AMDGPU::OPERAND_REG_IMM_INT64:
     526             :     case AMDGPU::OPERAND_REG_IMM_FP64:
     527             :     case AMDGPU::OPERAND_REG_INLINE_C_INT64:
     528             :     case AMDGPU::OPERAND_REG_INLINE_C_FP64:
     529       10545 :       printImmediate64(Op.getImm(), STI, O);
     530       10545 :       break;
     531       12276 :     case AMDGPU::OPERAND_REG_INLINE_C_INT16:
     532             :     case AMDGPU::OPERAND_REG_INLINE_C_FP16:
     533             :     case AMDGPU::OPERAND_REG_IMM_INT16:
     534             :     case AMDGPU::OPERAND_REG_IMM_FP16:
     535       12276 :       printImmediate16(Op.getImm(), STI, O);
     536       12276 :       break;
     537         325 :     case AMDGPU::OPERAND_REG_INLINE_C_V2FP16:
     538             :     case AMDGPU::OPERAND_REG_INLINE_C_V2INT16:
     539         325 :       printImmediateV216(Op.getImm(), STI, O);
     540         325 :       break;
     541         174 :     case MCOI::OPERAND_UNKNOWN:
     542             :     case MCOI::OPERAND_PCREL:
     543         174 :       O << formatDec(Op.getImm());
     544         174 :       break;
     545           0 :     case MCOI::OPERAND_REGISTER:
     546             :       // FIXME: This should be removed and handled somewhere else. Seems to come
     547             :       // from a disassembler bug.
     548           0 :       O << "/*invalid immediate*/";
     549           0 :       break;
     550           0 :     default:
     551             :       // We hit this for the immediate instruction bits that don't yet have a
     552             :       // custom printer.
     553           0 :       llvm_unreachable("unexpected immediate operand type");
     554             :     }
     555        3089 :   } else if (Op.isFPImm()) {
     556             :     // We special case 0.0 because otherwise it will be printed as an integer.
     557           0 :     if (Op.getFPImm() == 0.0)
     558           0 :       O << "0.0";
     559             :     else {
     560           0 :       const MCInstrDesc &Desc = MII.get(MI->getOpcode());
     561           0 :       int RCID = Desc.OpInfo[OpNo].RegClass;
     562           0 :       unsigned RCBits = AMDGPU::getRegBitWidth(MRI.getRegClass(RCID));
     563           0 :       if (RCBits == 32)
     564           0 :         printImmediate32(FloatToBits(Op.getFPImm()), STI, O);
     565           0 :       else if (RCBits == 64)
     566           0 :         printImmediate64(DoubleToBits(Op.getFPImm()), STI, O);
     567             :       else
     568           0 :         llvm_unreachable("Invalid register class size");
     569             :     }
     570        3089 :   } else if (Op.isExpr()) {
     571        3089 :     const MCExpr *Exp = Op.getExpr();
     572        3089 :     Exp->print(O, &MAI);
     573             :   } else {
     574           0 :     O << "/*INV_OP*/";
     575             :   }
     576             : }
     577             : 
     578      152876 : void AMDGPUInstPrinter::printOperandAndFPInputMods(const MCInst *MI,
     579             :                                                    unsigned OpNo,
     580             :                                                    const MCSubtargetInfo &STI,
     581             :                                                    raw_ostream &O) {
     582      152876 :   unsigned InputModifiers = MI->getOperand(OpNo).getImm();
     583             : 
     584             :   // Use 'neg(...)' instead of '-' to avoid ambiguity.
     585             :   // This is important for integer literals because
     586             :   // -1 is not the same value as neg(1).
     587             :   bool NegMnemo = false;
     588             : 
     589      152876 :   if (InputModifiers & SISrcMods::NEG) {
     590       15502 :     if (OpNo + 1 < MI->getNumOperands() &&
     591        7751 :         (InputModifiers & SISrcMods::ABS) == 0) {
     592             :       const MCOperand &Op = MI->getOperand(OpNo + 1);
     593        7462 :       NegMnemo = Op.isImm() || Op.isFPImm();
     594             :     }
     595             :     if (NegMnemo) {
     596          32 :       O << "neg(";
     597             :     } else {
     598             :       O << '-';
     599             :     }
     600             :   }
     601             : 
     602      152876 :   if (InputModifiers & SISrcMods::ABS)
     603             :     O << '|';
     604      152876 :   printOperand(MI, OpNo + 1, STI, O);
     605      152876 :   if (InputModifiers & SISrcMods::ABS)
     606             :     O << '|';
     607             : 
     608      152876 :   if (NegMnemo) {
     609             :     O << ')';
     610             :   }
     611      152876 : }
     612             : 
     613       38625 : void AMDGPUInstPrinter::printOperandAndIntInputMods(const MCInst *MI,
     614             :                                                     unsigned OpNo,
     615             :                                                     const MCSubtargetInfo &STI,
     616             :                                                     raw_ostream &O) {
     617       38625 :   unsigned InputModifiers = MI->getOperand(OpNo).getImm();
     618       38625 :   if (InputModifiers & SISrcMods::SEXT)
     619        1752 :     O << "sext(";
     620       38625 :   printOperand(MI, OpNo + 1, STI, O);
     621       38625 :   if (InputModifiers & SISrcMods::SEXT)
     622             :     O << ')';
     623       38625 : }
     624             : 
     625       15205 : void AMDGPUInstPrinter::printDPPCtrl(const MCInst *MI, unsigned OpNo,
     626             :                                      const MCSubtargetInfo &STI,
     627             :                                      raw_ostream &O) {
     628             :   using namespace AMDGPU::DPP;
     629             : 
     630       15205 :   unsigned Imm = MI->getOperand(OpNo).getImm();
     631       15205 :   if (Imm <= DppCtrl::QUAD_PERM_LAST) {
     632        7396 :     O << " quad_perm:[";
     633        7396 :     O << formatDec(Imm & 0x3)         << ',';
     634        7396 :     O << formatDec((Imm & 0xc)  >> 2) << ',';
     635        7396 :     O << formatDec((Imm & 0x30) >> 4) << ',';
     636       14792 :     O << formatDec((Imm & 0xc0) >> 6) << ']';
     637        7809 :   } else if ((Imm >= DppCtrl::ROW_SHL_FIRST) &&
     638             :              (Imm <= DppCtrl::ROW_SHL_LAST)) {
     639        1485 :     O << " row_shl:";
     640        1485 :     printU4ImmDecOperand(MI, OpNo, O);
     641        6324 :   } else if ((Imm >= DppCtrl::ROW_SHR_FIRST) &&
     642             :              (Imm <= DppCtrl::ROW_SHR_LAST)) {
     643        1053 :     O << " row_shr:";
     644        1053 :     printU4ImmDecOperand(MI, OpNo, O);
     645        5271 :   } else if ((Imm >= DppCtrl::ROW_ROR_FIRST) &&
     646             :              (Imm <= DppCtrl::ROW_ROR_LAST)) {
     647        1053 :     O << " row_ror:";
     648        1053 :     printU4ImmDecOperand(MI, OpNo, O);
     649        4218 :   } else if (Imm == DppCtrl::WAVE_SHL1) {
     650         528 :     O << " wave_shl:1";
     651        3690 :   } else if (Imm == DppCtrl::WAVE_ROL1) {
     652         528 :     O << " wave_rol:1";
     653        3162 :   } else if (Imm == DppCtrl::WAVE_SHR1) {
     654         528 :     O << " wave_shr:1";
     655        2634 :   } else if (Imm == DppCtrl::WAVE_ROR1) {
     656         528 :     O << " wave_ror:1";
     657        2106 :   } else if (Imm == DppCtrl::ROW_MIRROR) {
     658         526 :     O << " row_mirror";
     659        1580 :   } else if (Imm == DppCtrl::ROW_HALF_MIRROR) {
     660         526 :     O << " row_half_mirror";
     661        1054 :   } else if (Imm == DppCtrl::BCAST15) {
     662         528 :     O << " row_bcast:15";
     663         526 :   } else if (Imm == DppCtrl::BCAST31) {
     664         526 :     O << " row_bcast:31";
     665             :   } else {
     666           0 :     O << " /* Invalid dpp_ctrl value */";
     667             :   }
     668       15205 : }
     669             : 
     670       15205 : void AMDGPUInstPrinter::printRowMask(const MCInst *MI, unsigned OpNo,
     671             :                                      const MCSubtargetInfo &STI,
     672             :                                      raw_ostream &O) {
     673       15205 :   O << " row_mask:";
     674       15205 :   printU4ImmOperand(MI, OpNo, STI, O);
     675       15205 : }
     676             : 
     677       15205 : void AMDGPUInstPrinter::printBankMask(const MCInst *MI, unsigned OpNo,
     678             :                                       const MCSubtargetInfo &STI,
     679             :                                       raw_ostream &O) {
     680       15205 :   O << " bank_mask:";
     681       15205 :   printU4ImmOperand(MI, OpNo, STI, O);
     682       15205 : }
     683             : 
     684       15205 : void AMDGPUInstPrinter::printBoundCtrl(const MCInst *MI, unsigned OpNo,
     685             :                                        const MCSubtargetInfo &STI,
     686             :                                        raw_ostream &O) {
     687       15205 :   unsigned Imm = MI->getOperand(OpNo).getImm();
     688       15205 :   if (Imm) {
     689         992 :     O << " bound_ctrl:0"; // XXX - this syntax is used in sp3
     690             :   }
     691       15205 : }
     692             : 
     693       89697 : void AMDGPUInstPrinter::printSDWASel(const MCInst *MI, unsigned OpNo,
     694             :                                      raw_ostream &O) {
     695             :   using namespace llvm::AMDGPU::SDWA;
     696             : 
     697       89697 :   unsigned Imm = MI->getOperand(OpNo).getImm();
     698       89697 :   switch (Imm) {
     699        2960 :   case SdwaSel::BYTE_0: O << "BYTE_0"; break;
     700        2677 :   case SdwaSel::BYTE_1: O << "BYTE_1"; break;
     701        3070 :   case SdwaSel::BYTE_2: O << "BYTE_2"; break;
     702        2624 :   case SdwaSel::BYTE_3: O << "BYTE_3"; break;
     703        3307 :   case SdwaSel::WORD_0: O << "WORD_0"; break;
     704        4279 :   case SdwaSel::WORD_1: O << "WORD_1"; break;
     705       70780 :   case SdwaSel::DWORD: O << "DWORD"; break;
     706           0 :   default: llvm_unreachable("Invalid SDWA data select operand");
     707             :   }
     708       89697 : }
     709             : 
     710       19769 : void AMDGPUInstPrinter::printSDWADstSel(const MCInst *MI, unsigned OpNo,
     711             :                                         const MCSubtargetInfo &STI,
     712             :                                         raw_ostream &O) {
     713       19769 :   O << "dst_sel:";
     714       19769 :   printSDWASel(MI, OpNo, O);
     715       19769 : }
     716             : 
     717       39422 : void AMDGPUInstPrinter::printSDWASrc0Sel(const MCInst *MI, unsigned OpNo,
     718             :                                          const MCSubtargetInfo &STI,
     719             :                                          raw_ostream &O) {
     720       39422 :   O << "src0_sel:";
     721       39422 :   printSDWASel(MI, OpNo, O);
     722       39422 : }
     723             : 
     724       30506 : void AMDGPUInstPrinter::printSDWASrc1Sel(const MCInst *MI, unsigned OpNo,
     725             :                                          const MCSubtargetInfo &STI,
     726             :                                          raw_ostream &O) {
     727       30506 :   O << "src1_sel:";
     728       30506 :   printSDWASel(MI, OpNo, O);
     729       30506 : }
     730             : 
     731       19769 : void AMDGPUInstPrinter::printSDWADstUnused(const MCInst *MI, unsigned OpNo,
     732             :                                            const MCSubtargetInfo &STI,
     733             :                                            raw_ostream &O) {
     734             :   using namespace llvm::AMDGPU::SDWA;
     735             : 
     736       19769 :   O << "dst_unused:";
     737       19769 :   unsigned Imm = MI->getOperand(OpNo).getImm();
     738       19769 :   switch (Imm) {
     739       18246 :   case DstUnused::UNUSED_PAD: O << "UNUSED_PAD"; break;
     740         530 :   case DstUnused::UNUSED_SEXT: O << "UNUSED_SEXT"; break;
     741         993 :   case DstUnused::UNUSED_PRESERVE: O << "UNUSED_PRESERVE"; break;
     742           0 :   default: llvm_unreachable("Invalid SDWA dest_unused operand");
     743             :   }
     744       19769 : }
     745             : 
     746             : template <unsigned N>
     747        2948 : void AMDGPUInstPrinter::printExpSrcN(const MCInst *MI, unsigned OpNo,
     748             :                                      const MCSubtargetInfo &STI,
     749             :                                      raw_ostream &O) {
     750        2948 :   unsigned Opc = MI->getOpcode();
     751        2948 :   int EnIdx = AMDGPU::getNamedOperandIdx(Opc, AMDGPU::OpName::en);
     752        2948 :   unsigned En = MI->getOperand(EnIdx).getImm();
     753             : 
     754        2211 :   int ComprIdx = AMDGPU::getNamedOperandIdx(Opc, AMDGPU::OpName::compr);
     755             : 
     756             :   // If compr is set, print as src0, src0, src1, src1
     757        4422 :   if (MI->getOperand(ComprIdx).getImm()) {
     758             :     if (N == 1 || N == 2)
     759         226 :       --OpNo;
     760             :     else if (N == 3)
     761         113 :       OpNo -= 2;
     762             :   }
     763             : 
     764        2948 :   if (En & (1 << N))
     765        4886 :     printRegOperand(MI->getOperand(OpNo).getReg(), O, MRI);
     766             :   else
     767         505 :     O << "off";
     768        2948 : }
     769         737 : 
     770             : void AMDGPUInstPrinter::printExpSrc0(const MCInst *MI, unsigned OpNo,
     771             :                                      const MCSubtargetInfo &STI,
     772         737 :                                      raw_ostream &O) {
     773         737 :   printExpSrcN<0>(MI, OpNo, STI, O);
     774         737 : }
     775             : 
     776         737 : void AMDGPUInstPrinter::printExpSrc1(const MCInst *MI, unsigned OpNo,
     777             :                                      const MCSubtargetInfo &STI,
     778             :                                      raw_ostream &O) {
     779        1474 :   printExpSrcN<1>(MI, OpNo, STI, O);
     780             : }
     781             : 
     782             : void AMDGPUInstPrinter::printExpSrc2(const MCInst *MI, unsigned OpNo,
     783         113 :                                      const MCSubtargetInfo &STI,
     784             :                                      raw_ostream &O) {
     785             :   printExpSrcN<2>(MI, OpNo, STI, O);
     786         737 : }
     787        1228 : 
     788             : void AMDGPUInstPrinter::printExpSrc3(const MCInst *MI, unsigned OpNo,
     789         123 :                                      const MCSubtargetInfo &STI,
     790         737 :                                      raw_ostream &O) {
     791         737 :   printExpSrcN<3>(MI, OpNo, STI, O);
     792             : }
     793             : 
     794         737 : void AMDGPUInstPrinter::printExpTgt(const MCInst *MI, unsigned OpNo,
     795         737 :                                     const MCSubtargetInfo &STI,
     796         737 :                                     raw_ostream &O) {
     797             :   // This is really a 6 bit field.
     798         737 :   uint32_t Tgt = MI->getOperand(OpNo).getImm() & ((1 << 6) - 1);
     799             : 
     800             :   if (Tgt <= 7)
     801        1474 :     O << " mrt" << Tgt;
     802             :   else if (Tgt == 8)
     803         113 :     O << " mrtz";
     804             :   else if (Tgt == 9)
     805             :     O << " null";
     806             :   else if (Tgt >= 12 && Tgt <= 15)
     807             :     O << " pos" << Tgt - 12;
     808         737 :   else if (Tgt >= 32 && Tgt <= 63)
     809        1210 :     O << " param" << Tgt - 32;
     810             :   else {
     811         132 :     // Reserved values 10, 11
     812         737 :     O << " invalid_target_" << Tgt;
     813         737 :   }
     814             : }
     815             : 
     816         737 : static bool allOpsDefaultValue(const int* Ops, int NumOps, int Mod,
     817         737 :                                bool IsPacked, bool HasDstSel) {
     818         737 :   int DefaultValue = IsPacked && (Mod == SISrcMods::OP_SEL_1);
     819             : 
     820         737 :   for (int I = 0; I < NumOps; ++I) {
     821             :     if (!!(Ops[I] & Mod) != DefaultValue)
     822             :       return false;
     823        1474 :   }
     824             : 
     825         113 :   if (HasDstSel && (Ops[0] & SISrcMods::DST_OP_SEL) != 0)
     826             :     return false;
     827             : 
     828             :   return true;
     829             : }
     830         737 : 
     831        1206 : void AMDGPUInstPrinter::printPackedModifier(const MCInst *MI,
     832             :                                             StringRef Name,
     833         134 :                                             unsigned Mod,
     834         737 :                                             raw_ostream &O) {
     835         737 :   unsigned Opc = MI->getOpcode();
     836             :   int NumOps = 0;
     837             :   int Ops[3];
     838         737 : 
     839         737 :   for (int OpName : { AMDGPU::OpName::src0_modifiers,
     840         737 :                       AMDGPU::OpName::src1_modifiers,
     841             :                       AMDGPU::OpName::src2_modifiers }) {
     842             :     int Idx = AMDGPU::getNamedOperandIdx(Opc, OpName);
     843             :     if (Idx == -1)
     844             :       break;
     845             : 
     846             :     Ops[NumOps++] = MI->getOperand(Idx).getImm();
     847             :   }
     848             : 
     849             :   const bool HasDstSel =
     850             :     NumOps > 0 &&
     851             :     Mod == SISrcMods::OP_SEL_0 &&
     852         737 :     MII.get(MI->getOpcode()).TSFlags & SIInstrFlags::VOP3_OPSEL;
     853        1242 : 
     854             :   const bool IsPacked =
     855         116 :     MII.get(MI->getOpcode()).TSFlags & SIInstrFlags::IsPacked;
     856         737 : 
     857             :   if (allOpsDefaultValue(Ops, NumOps, Mod, IsPacked, HasDstSel))
     858         737 :     return;
     859             : 
     860             :   O << Name;
     861         737 :   for (int I = 0; I < NumOps; ++I) {
     862         737 :     if (I != 0)
     863             :       O << ',';
     864         737 : 
     865             :     O << !!(Ops[I] & Mod);
     866             :   }
     867         737 : 
     868         737 :   if (HasDstSel) {
     869             :     O << ',' << !!(Ops[0] & SISrcMods::DST_OP_SEL);
     870         737 :   }
     871             : 
     872             :   O << ']';
     873         737 : }
     874         737 : 
     875             : void AMDGPUInstPrinter::printOpSel(const MCInst *MI, unsigned,
     876         737 :                                    const MCSubtargetInfo &STI,
     877             :                                    raw_ostream &O) {
     878             :   printPackedModifier(MI, " op_sel:[", SISrcMods::OP_SEL_0, O);
     879         737 : }
     880         737 : 
     881             : void AMDGPUInstPrinter::printOpSelHi(const MCInst *MI, unsigned OpNo,
     882         737 :                                      const MCSubtargetInfo &STI,
     883             :                                      raw_ostream &O) {
     884             :   printPackedModifier(MI, " op_sel_hi:[", SISrcMods::OP_SEL_1, O);
     885             : }
     886         737 : 
     887             : void AMDGPUInstPrinter::printNegLo(const MCInst *MI, unsigned OpNo,
     888         737 :                                    const MCSubtargetInfo &STI,
     889         474 :                                    raw_ostream &O) {
     890         263 :   printPackedModifier(MI, " neg_lo:[", SISrcMods::NEG, O);
     891          37 : }
     892         226 : 
     893          24 : void AMDGPUInstPrinter::printNegHi(const MCInst *MI, unsigned OpNo,
     894         202 :                                    const MCSubtargetInfo &STI,
     895          51 :                                    raw_ostream &O) {
     896         151 :   printPackedModifier(MI, " neg_hi:[", SISrcMods::NEG_HI, O);
     897         135 : }
     898             : 
     899             : void AMDGPUInstPrinter::printInterpSlot(const MCInst *MI, unsigned OpNum,
     900          16 :                                         const MCSubtargetInfo &STI,
     901             :                                         raw_ostream &O) {
     902         737 :   unsigned Imm = MI->getOperand(OpNum).getImm();
     903             :   switch (Imm) {
     904             :   case 0:
     905             :     O << "p10";
     906       16671 :     break;
     907             :   case 1:
     908       53425 :     O << "p20";
     909       38666 :     break;
     910             :   case 2:
     911             :     O << "p0";
     912             :     break;
     913       14759 :   default:
     914             :     O << "invalid_param_" << Imm;
     915             :   }
     916             : }
     917             : 
     918             : void AMDGPUInstPrinter::printInterpAttr(const MCInst *MI, unsigned OpNum,
     919       16671 :                                         const MCSubtargetInfo &STI,
     920             :                                         raw_ostream &O) {
     921             :   unsigned Attr = MI->getOperand(OpNum).getImm();
     922             :   O << "attr" << Attr;
     923       16671 : }
     924             : 
     925             : void AMDGPUInstPrinter::printInterpAttrChan(const MCInst *MI, unsigned OpNum,
     926             :                                         const MCSubtargetInfo &STI,
     927       90949 :                                         raw_ostream &O) {
     928             :   unsigned Chan = MI->getOperand(OpNum).getImm();
     929       57607 :   O << '.' << "xyzw"[Chan & 0x3];
     930       50013 : }
     931       50013 : 
     932             : void AMDGPUInstPrinter::printVGPRIndexMode(const MCInst *MI, unsigned OpNo,
     933             :                                            const MCSubtargetInfo &STI,
     934       81872 :                                            raw_ostream &O) {
     935             :   unsigned Val = MI->getOperand(OpNo).getImm();
     936             :   if (Val == 0) {
     937             :     O << " 0";
     938       33342 :     return;
     939       16671 :   }
     940       14226 : 
     941             :   if (Val & VGPRIndexMode::DST_ENABLE)
     942             :     O << " dst";
     943       16671 : 
     944             :   if (Val & VGPRIndexMode::SRC0_ENABLE)
     945       16671 :     O << " src0";
     946       14683 : 
     947             :   if (Val & VGPRIndexMode::SRC1_ENABLE)
     948        1988 :     O << " src1";
     949        7365 : 
     950        5377 :   if (Val & VGPRIndexMode::SRC2_ENABLE)
     951             :     O << " src2";
     952             : }
     953        5377 : 
     954             : void AMDGPUInstPrinter::printMemOperand(const MCInst *MI, unsigned OpNo,
     955             :                                         const MCSubtargetInfo &STI,
     956        1988 :                                         raw_ostream &O) {
     957         355 :   printOperand(MI, OpNo, STI, O);
     958             :   O  << ", ";
     959             :   printOperand(MI, OpNo + 1, STI, O);
     960             : }
     961             : 
     962             : void AMDGPUInstPrinter::printIfSet(const MCInst *MI, unsigned OpNo,
     963        7113 :                                    raw_ostream &O, StringRef Asm,
     964             :                                    StringRef Default) {
     965             :   const MCOperand &Op = MI->getOperand(OpNo);
     966        7113 :   assert(Op.isImm());
     967        7113 :   if (Op.getImm() == 1) {
     968             :     O << Asm;
     969        3818 :   } else {
     970             :     O << Default;
     971             :   }
     972        3818 : }
     973        3818 : 
     974             : void AMDGPUInstPrinter::printIfSet(const MCInst *MI, unsigned OpNo,
     975        2870 :                                    raw_ostream &O, char Asm) {
     976             :   const MCOperand &Op = MI->getOperand(OpNo);
     977             :   assert(Op.isImm());
     978        2870 :   if (Op.getImm() == 1)
     979        2870 :     O << Asm;
     980             : }
     981        2870 : 
     982             : void AMDGPUInstPrinter::printHigh(const MCInst *MI, unsigned OpNo,
     983             :                                   const MCSubtargetInfo &STI,
     984        2870 :                                   raw_ostream &O) {
     985        2870 :   if (MI->getOperand(OpNo).getImm())
     986             :     O << " high";
     987         244 : }
     988             : 
     989             : void AMDGPUInstPrinter::printClampSI(const MCInst *MI, unsigned OpNo,
     990         244 :                                      const MCSubtargetInfo &STI,
     991         244 :                                      raw_ostream &O) {
     992         160 :   if (MI->getOperand(OpNo).getImm())
     993         160 :     O << " clamp";
     994         160 : }
     995          20 : 
     996          20 : void AMDGPUInstPrinter::printOModSI(const MCInst *MI, unsigned OpNo,
     997          20 :                                     const MCSubtargetInfo &STI,
     998          46 :                                     raw_ostream &O) {
     999          46 :   int Imm = MI->getOperand(OpNo).getImm();
    1000          46 :   if (Imm == SIOutMods::MUL2)
    1001          18 :     O << " mul:2";
    1002          18 :   else if (Imm == SIOutMods::MUL4)
    1003             :     O << " mul:4";
    1004         244 :   else if (Imm == SIOutMods::DIV2)
    1005             :     O << " div:2";
    1006        1374 : }
    1007             : 
    1008             : void AMDGPUInstPrinter::printSendMsg(const MCInst *MI, unsigned OpNo,
    1009        1374 :                                      const MCSubtargetInfo &STI,
    1010        1374 :                                      raw_ostream &O) {
    1011        1374 :   using namespace llvm::AMDGPU::SendMsg;
    1012             : 
    1013        1374 :   const unsigned SImm16 = MI->getOperand(OpNo).getImm();
    1014             :   const unsigned Id = SImm16 & ID_MASK_;
    1015             :   do {
    1016        1374 :     if (Id == ID_INTERRUPT) {
    1017        1374 :       if ((SImm16 & ~ID_MASK_) != 0) // Unused/unknown bits must be 0.
    1018        1374 :         break;
    1019             :       O << "sendmsg(" << IdSymbolic[Id] << ')';
    1020         112 :       return;
    1021             :     }
    1022             :     if (Id == ID_GS || Id == ID_GS_DONE) {
    1023         112 :       if ((SImm16 & ~(ID_MASK_|OP_GS_MASK_|STREAM_ID_MASK_)) != 0) // Unused/unknown bits must be 0.
    1024         112 :         break;
    1025          49 :       const unsigned OpGs = (SImm16 & OP_GS_MASK_) >> OP_SHIFT_;
    1026          49 :       const unsigned StreamId = (SImm16 & STREAM_ID_MASK_) >> STREAM_ID_SHIFT_;
    1027             :       if (OpGs == OP_GS_NOP && Id != ID_GS_DONE) // NOP to be used for GS_DONE only.
    1028             :         break;
    1029          63 :       if (OpGs == OP_GS_NOP && StreamId != 0) // NOP does not use/define stream id bits.
    1030          32 :         break;
    1031             :       O << "sendmsg(" << IdSymbolic[Id] << ", " << OpGsSymbolic[OpGs];
    1032          63 :       if (OpGs != OP_GS_NOP) {  O << ", " << StreamId; }
    1033          39 :       O << ')';
    1034             :       return;
    1035          63 :     }
    1036           9 :     if (Id == ID_SYSMSG) {
    1037             :       if ((SImm16 & ~(ID_MASK_|OP_SYS_MASK_)) != 0) // Unused/unknown bits must be 0.
    1038          63 :         break;
    1039           8 :       const unsigned OpSys = (SImm16 & OP_SYS_MASK_) >> OP_SHIFT_;
    1040             :       if (! (OP_SYS_FIRST_ <= OpSys && OpSys < OP_SYS_LAST_)) // Unused/unknown.
    1041             :         break;
    1042           0 :       O << "sendmsg(" << IdSymbolic[Id] << ", " << OpSysSymbolic[OpSys] << ')';
    1043             :       return;
    1044             :     }
    1045           0 :   } while (false);
    1046           0 :   O << SImm16; // Unknown simm16 code.
    1047           0 : }
    1048           0 : 
    1049             : static void printSwizzleBitmask(const uint16_t AndMask,
    1050      156391 :                                 const uint16_t OrMask,
    1051             :                                 const uint16_t XorMask,
    1052             :                                 raw_ostream &O) {
    1053             :   using namespace llvm::AMDGPU::Swizzle;
    1054             : 
    1055      156391 :   uint16_t Probe0 = ((0            & AndMask) | OrMask) ^ XorMask;
    1056       26524 :   uint16_t Probe1 = ((BITMASK_MASK & AndMask) | OrMask) ^ XorMask;
    1057             : 
    1058      129867 :   O << "\"";
    1059             : 
    1060      156391 :   for (unsigned Mask = 1 << (BITMASK_WIDTH - 1); Mask > 0; Mask >>= 1) {
    1061             :     uint16_t p0 = Probe0 & Mask;
    1062      373179 :     uint16_t p1 = Probe1 & Mask;
    1063             : 
    1064             :     if (p0 == p1) {
    1065             :       if (p0 == 0) {
    1066      373179 :         O << "0";
    1067             :       } else {
    1068      373179 :         O << "1";
    1069             :       }
    1070         410 :     } else {
    1071             :       if (p0 == 0) {
    1072             :         O << "p";
    1073         410 :       } else {
    1074          32 :         O << "i";
    1075         410 :       }
    1076             :     }
    1077       88713 :   }
    1078             : 
    1079             :   O << "\"";
    1080       88713 : }
    1081        2211 : 
    1082       88713 : void AMDGPUInstPrinter::printSwizzle(const MCInst *MI, unsigned OpNo,
    1083             :                                      const MCSubtargetInfo &STI,
    1084       30551 :                                      raw_ostream &O) {
    1085             :   using namespace llvm::AMDGPU::Swizzle;
    1086             : 
    1087       30551 :   uint16_t Imm = MI->getOperand(OpNo).getImm();
    1088       30551 :   if (Imm == 0) {
    1089         581 :     return;
    1090       29970 :   }
    1091         583 : 
    1092       29387 :   O << " offset:";
    1093         576 : 
    1094       30551 :   if ((Imm & QUAD_PERM_ENC_MASK) == QUAD_PERM_ENC) {
    1095             : 
    1096         128 :     O << "swizzle(" << IdSymbolic[ID_QUAD_PERM];
    1097             :     for (auto i = 0; i < LANE_NUM; ++i) {
    1098             :       O << ",";
    1099             :       O << formatDec(Imm & LANE_MASK);
    1100             :       Imm >>= LANE_SHIFT;
    1101         128 :     }
    1102         128 :     O << ")";
    1103             : 
    1104         128 :   } else if ((Imm & BITMASK_PERM_ENC_MASK) == BITMASK_PERM_ENC) {
    1105          34 : 
    1106             :     uint16_t AndMask = (Imm >> BITMASK_AND_SHIFT) & BITMASK_MASK;
    1107          18 :     uint16_t OrMask  = (Imm >> BITMASK_OR_SHIFT)  & BITMASK_MASK;
    1108          18 :     uint16_t XorMask = (Imm >> BITMASK_XOR_SHIFT) & BITMASK_MASK;
    1109             : 
    1110          94 :     if (AndMask == BITMASK_MAX &&
    1111          72 :         OrMask == 0 &&
    1112             :         countPopulation(XorMask) == 1) {
    1113          72 : 
    1114          72 :       O << "swizzle(" << IdSymbolic[ID_SWAP];
    1115          72 :       O << ",";
    1116             :       O << formatDec(XorMask);
    1117          68 :       O << ")";
    1118             : 
    1119          68 :     } else if (AndMask == BITMASK_MAX &&
    1120          68 :                OrMask == 0 && XorMask > 0 &&
    1121             :                isPowerOf2_64(XorMask + 1)) {
    1122          68 : 
    1123             :       O << "swizzle(" << IdSymbolic[ID_REVERSE];
    1124          22 :       O << ",";
    1125          15 :       O << formatDec(XorMask + 1);
    1126             :       O << ")";
    1127          15 : 
    1128          15 :     } else {
    1129             : 
    1130          10 :       uint16_t GroupSize = BITMASK_MAX - AndMask + 1;
    1131          10 :       if (GroupSize > 1 &&
    1132             :           isPowerOf2_64(GroupSize) &&
    1133             :           OrMask < GroupSize &&
    1134             :           XorMask == 0) {
    1135             : 
    1136             :         O << "swizzle(" << IdSymbolic[ID_BROADCAST];
    1137          55 :         O << ",";
    1138             :         O << formatDec(GroupSize);
    1139             :         O << ",";
    1140             :         O << formatDec(OrMask);
    1141             :         O << ")";
    1142             : 
    1143          55 :       } else {
    1144          55 :         O << "swizzle(" << IdSymbolic[ID_BITMASK_PERM];
    1145             :         O << ",";
    1146          55 :         printSwizzleBitmask(AndMask, OrMask, XorMask, O);
    1147             :         O << ")";
    1148         330 :       }
    1149         275 :     }
    1150         275 :   } else {
    1151             :     printU16ImmDecOperand(MI, OpNo, O);
    1152         275 :   }
    1153         234 : }
    1154         209 : 
    1155             : void AMDGPUInstPrinter::printWaitFlag(const MCInst *MI, unsigned OpNo,
    1156          25 :                                       const MCSubtargetInfo &STI,
    1157             :                                       raw_ostream &O) {
    1158             :   AMDGPU::IsaVersion ISA = AMDGPU::getIsaVersion(STI.getCPU());
    1159          41 : 
    1160          27 :   unsigned SImm16 = MI->getOperand(OpNo).getImm();
    1161             :   unsigned Vmcnt, Expcnt, Lgkmcnt;
    1162          14 :   decodeWaitcnt(ISA, SImm16, Vmcnt, Expcnt, Lgkmcnt);
    1163             : 
    1164             :   bool NeedSpace = false;
    1165             : 
    1166             :   if (Vmcnt != getVmcntBitMask(ISA)) {
    1167          55 :     O << "vmcnt(" << Vmcnt << ')';
    1168          55 :     NeedSpace = true;
    1169             :   }
    1170         281 : 
    1171             :   if (Expcnt != getExpcntBitMask(ISA)) {
    1172             :     if (NeedSpace)
    1173             :       O << ' ';
    1174             :     O << "expcnt(" << Expcnt << ')';
    1175         281 :     NeedSpace = true;
    1176         281 :   }
    1177             : 
    1178             :   if (Lgkmcnt != getLgkmcntBitMask(ISA)) {
    1179             :     if (NeedSpace)
    1180         248 :       O << ' ';
    1181             :     O << "lgkmcnt(" << Lgkmcnt << ')';
    1182         248 :   }
    1183             : }
    1184          14 : 
    1185          70 : void AMDGPUInstPrinter::printHwreg(const MCInst *MI, unsigned OpNo,
    1186          56 :                                    const MCSubtargetInfo &STI, raw_ostream &O) {
    1187          56 :   using namespace llvm::AMDGPU::Hwreg;
    1188          56 : 
    1189             :   unsigned SImm16 = MI->getOperand(OpNo).getImm();
    1190          14 :   const unsigned Id = (SImm16 & ID_MASK_) >> ID_SHIFT_;
    1191             :   const unsigned Offset = (SImm16 & OFFSET_MASK_) >> OFFSET_SHIFT_;
    1192         234 :   const unsigned Width = ((SImm16 & WIDTH_M1_MASK_) >> WIDTH_M1_SHIFT_) + 1;
    1193             : 
    1194         211 :   O << "hwreg(";
    1195         211 :   unsigned Last = ID_SYMBOLIC_LAST_;
    1196         211 :   if (AMDGPU::isSI(STI) || AMDGPU::isCI(STI) || AMDGPU::isVI(STI))
    1197             :     Last = ID_SYMBOLIC_FIRST_GFX9_;
    1198         422 :   if (ID_SYMBOLIC_FIRST_ <= Id && Id < Last && IdSymbolic[Id]) {
    1199         211 :     O << IdSymbolic[Id];
    1200             :   } else {
    1201             :     O << Id;
    1202          44 :   }
    1203          44 :   if (Width != WIDTH_M1_DEFAULT_ + 1 || Offset != OFFSET_DEFAULT_) {
    1204          44 :     O << ", " << Offset << ", " << Width;
    1205          44 :   }
    1206             :   O << ')';
    1207             : }
    1208         167 : 
    1209          35 : #include "AMDGPUGenAsmWriter.inc"
    1210             : 
    1211          35 : void R600InstPrinter::printInst(const MCInst *MI, raw_ostream &O,
    1212          35 :                                 StringRef Annot, const MCSubtargetInfo &STI) {
    1213          35 :   O.flush();
    1214          35 :   printInstruction(MI, O);
    1215             :   printAnnotation(O, Annot);
    1216             : }
    1217             : 
    1218         132 : void R600InstPrinter::printAbs(const MCInst *MI, unsigned OpNo,
    1219             :                                raw_ostream &O) {
    1220         132 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, '|');
    1221         132 : }
    1222          91 : 
    1223             : void R600InstPrinter::printBankSwizzle(const MCInst *MI, unsigned OpNo,
    1224          77 :                                        raw_ostream &O) {
    1225          77 :   int BankSwizzle = MI->getOperand(OpNo).getImm();
    1226          77 :   switch (BankSwizzle) {
    1227          77 :   case 1:
    1228          77 :     O << "BS:VEC_021/SCL_122";
    1229          77 :     break;
    1230             :   case 2:
    1231             :     O << "BS:VEC_120/SCL_212";
    1232          55 :     break;
    1233          55 :   case 3:
    1234          55 :     O << "BS:VEC_102/SCL_221";
    1235          55 :     break;
    1236             :   case 4:
    1237             :     O << "BS:VEC_201";
    1238             :     break;
    1239          23 :   case 5:
    1240             :     O << "BS:VEC_210";
    1241             :     break;
    1242             :   default:
    1243       39195 :     break;
    1244             :   }
    1245             : }
    1246       39195 : 
    1247             : void R600InstPrinter::printClamp(const MCInst *MI, unsigned OpNo,
    1248       39195 :                                  raw_ostream &O) {
    1249             :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, "_SAT");
    1250       39195 : }
    1251             : 
    1252             : void R600InstPrinter::printCT(const MCInst *MI, unsigned OpNo,
    1253             :                                 raw_ostream &O) {
    1254       39195 :   unsigned CT = MI->getOperand(OpNo).getImm();
    1255       17952 :   switch (CT) {
    1256             :   case 0:
    1257             :     O << 'U';
    1258             :     break;
    1259       39195 :   case 1:
    1260        3951 :     O << 'N';
    1261             :     break;
    1262        3951 :   default:
    1263             :     break;
    1264             :   }
    1265             : }
    1266       39195 : 
    1267       23972 : void R600InstPrinter::printKCache(const MCInst *MI, unsigned OpNo,
    1268             :                                   raw_ostream &O) {
    1269       23972 :   int KCacheMode = MI->getOperand(OpNo).getImm();
    1270             :   if (KCacheMode > 0) {
    1271       39195 :     int KCacheBank = MI->getOperand(OpNo - 2).getImm();
    1272             :     O << "CB" << KCacheBank << ':';
    1273         342 :     int KCacheAddr = MI->getOperand(OpNo + 2).getImm();
    1274             :     int LineSize = (KCacheMode == 1) ? 16 : 32;
    1275             :     O << KCacheAddr * 16 << '-' << KCacheAddr * 16 + LineSize;
    1276             :   }
    1277         342 : }
    1278         342 : 
    1279         342 : void R600InstPrinter::printLast(const MCInst *MI, unsigned OpNo,
    1280         342 :                                 raw_ostream &O) {
    1281             :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, "*", " ");
    1282         342 : }
    1283             : 
    1284         342 : void R600InstPrinter::printLiteral(const MCInst *MI, unsigned OpNo,
    1285             :                                    raw_ostream &O) {
    1286         342 :   const MCOperand &Op = MI->getOperand(OpNo);
    1287         281 :   assert(Op.isImm() || Op.isExpr());
    1288             :   if (Op.isImm()) {
    1289             :     int64_t Imm = Op.getImm();
    1290             :     O << Imm << '(' << BitsToFloat(Imm) << ')';
    1291         342 :   }
    1292         580 :   if (Op.isExpr()) {
    1293             :     Op.getExpr()->print(O << '@', &MAI);
    1294             :   }
    1295         342 : }
    1296             : 
    1297             : void R600InstPrinter::printNeg(const MCInst *MI, unsigned OpNo,
    1298             :                                raw_ostream &O) {
    1299       83295 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, '-');
    1300             : }
    1301             : 
    1302       83295 : void R600InstPrinter::printOMOD(const MCInst *MI, unsigned OpNo,
    1303       83295 :                                 raw_ostream &O) {
    1304       83295 :   switch (MI->getOperand(OpNo).getImm()) {
    1305             :   default: break;
    1306      138388 :   case 1:
    1307             :     O << " * 2.0";
    1308      138388 :     break;
    1309      138388 :   case 2:
    1310             :     O << " * 4.0";
    1311       46719 :     break;
    1312             :   case 3:
    1313       46719 :     O << " / 2.0";
    1314       46719 :     break;
    1315         971 :   }
    1316         971 : }
    1317         971 : 
    1318         723 : void R600InstPrinter::printMemOperand(const MCInst *MI, unsigned OpNo,
    1319         723 :                                       raw_ostream &O) {
    1320         723 :   printOperand(MI, OpNo, O);
    1321         115 :   O  << ", ";
    1322         115 :   printOperand(MI, OpNo + 1, O);
    1323         115 : }
    1324         176 : 
    1325         176 : void R600InstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
    1326         176 :                                    raw_ostream &O) {
    1327          30 :   if (OpNo >= MI->getNumOperands()) {
    1328          30 :     O << "/*Missing OP" << OpNo << "*/";
    1329          30 :     return;
    1330             :   }
    1331             : 
    1332             :   const MCOperand &Op = MI->getOperand(OpNo);
    1333       46719 :   if (Op.isReg()) {
    1334             :     switch (Op.getReg()) {
    1335       46719 :     // This is the default predicate state, so we don't need to print it.
    1336             :     case R600::PRED_SEL_OFF:
    1337       46719 :       break;
    1338       46719 : 
    1339             :     default:
    1340        1104 :       O << getRegisterName(Op.getReg());
    1341             :       break;
    1342        1104 :     }
    1343        1104 :   } else if (Op.isImm()) {
    1344             :       O << Op.getImm();
    1345             :   } else if (Op.isFPImm()) {
    1346             :     // We special case 0.0 because otherwise it will be printed as an integer.
    1347             :     if (Op.getFPImm() == 0.0)
    1348             :       O << "0.0";
    1349             :     else {
    1350             :       O << Op.getFPImm();
    1351             :     }
    1352             :   } else if (Op.isExpr()) {
    1353        1104 :     const MCExpr *Exp = Op.getExpr();
    1354             :     Exp->print(O, &MAI);
    1355        7678 :   } else {
    1356             :     O << "/*INV_OP*/";
    1357        7678 :   }
    1358        7678 : }
    1359        3316 : 
    1360        3316 : void R600InstPrinter::printRel(const MCInst *MI, unsigned OpNo,
    1361        3316 :                                raw_ostream &O) {
    1362        3316 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, '+');
    1363        6632 : }
    1364             : 
    1365        7678 : void R600InstPrinter::printRSel(const MCInst *MI, unsigned OpNo,
    1366             :                                   raw_ostream &O) {
    1367       50192 :   unsigned Sel = MI->getOperand(OpNo).getImm();
    1368             :   switch (Sel) {
    1369       50192 :   case 0:
    1370       50192 :     O << 'X';
    1371             :     break;
    1372       27590 :   case 1:
    1373             :     O << 'Y';
    1374             :     break;
    1375             :   case 2:
    1376       27590 :     O << 'Z';
    1377       27577 :     break;
    1378       55154 :   case 3:
    1379             :     O << 'W';
    1380       27590 :     break;
    1381          26 :   case 4:
    1382             :     O << '0';
    1383       27590 :     break;
    1384             :   case 5:
    1385       90989 :     O << '1';
    1386             :     break;
    1387       90989 :   case 7:
    1388       90989 :     O << '_';
    1389             :     break;
    1390       39454 :   default:
    1391             :     break;
    1392       39454 :   }
    1393             : }
    1394           0 : 
    1395           0 : void R600InstPrinter::printUpdateExecMask(const MCInst *MI, unsigned OpNo,
    1396           0 :                                           raw_ostream &O) {
    1397           0 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, "ExecMask,");
    1398           0 : }
    1399           0 : 
    1400           0 : void R600InstPrinter::printUpdatePred(const MCInst *MI, unsigned OpNo,
    1401           0 :                                       raw_ostream &O) {
    1402           0 :   AMDGPUInstPrinter::printIfSet(MI, OpNo, O, "Pred,");
    1403             : }
    1404       39454 : 
    1405             : void R600InstPrinter::printWrite(const MCInst *MI, unsigned OpNo,
    1406        1705 :                                  raw_ostream &O) {
    1407             :   const MCOperand &Op = MI->getOperand(OpNo);
    1408        1705 :   if (Op.getImm() == 0) {
    1409        1705 :     O << " (MASKED)";
    1410        1705 :   }
    1411        1705 : }
    1412             : 
    1413      226308 : #include "R600GenAsmWriter.inc"

Generated by: LCOV version 1.13