contrib/llvm/lib/Target/AMDGPU/InstPrinter/AMDGPUInstPrinter.cpp

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