// [AsmJit]
// Complete x86/x64 JIT and Remote Assembler for C++.
//
// [License]
// Zlib - See LICENSE.md file in the package.

// [Export]
#define ASMJIT_EXPORTS

// [Guard]
#include "../asmjit_build.h"
#if !defined(ASMJIT_DISABLE_LOGGING)

// [Dependencies]
#include "../base/misc_p.h"
#include "../x86/x86inst.h"
#include "../x86/x86logging_p.h"
#include "../x86/x86operand.h"

#if !defined(ASMJIT_DISABLE_COMPILER)
#include "../base/codecompiler.h"
#endif // !ASMJIT_DISABLE_COMPILER

// [Api-Begin]
#include "../asmjit_apibegin.h"

namespace asmjit {

// ============================================================================
// [asmjit::X86Logging - Constants]
// ============================================================================

struct X86RegFormatInfo {
  uint8_t count;
  uint8_t formatIndex;
  uint8_t specialIndex;
  uint8_t specialCount;
};

static const char x86RegFormatStrings[] =
  "r%ub"  "\0" // #0
  "r%uh"  "\0" // #5
  "r%uw"  "\0" // #10
  "r%ud"  "\0" // #15
  "r%u"   "\0" // #20
  "xmm%u" "\0" // #24
  "ymm%u" "\0" // #30
  "zmm%u" "\0" // #36
  "rip%u" "\0" // #42
  "seg%u" "\0" // #48
  "fp%u"  "\0" // #54
  "mm%u"  "\0" // #59
  "k%u"   "\0" // #64
  "bnd%u" "\0" // #68
  "cr%u"  "\0" // #74
  "dr%u"  "\0" // #79

  "rip\0"      // #84
  "\0\0\0\0"   // #88
  "\0\0\0\0"   // #92

  "al\0\0" "cl\0\0" "dl\0\0" "bl\0\0" "spl\0"  "bpl\0"  "sil\0"  "dil\0"  // #96
  "ah\0\0" "ch\0\0" "dh\0\0" "bh\0\0" "n/a\0"  "n/a\0"  "n/a\0"  "n/a\0"  // #128
  "eax\0"  "ecx\0"  "edx\0"  "ebx\0"  "esp\0"  "ebp\0"  "esi\0"  "edi\0"  // #160
  "rax\0"  "rcx\0"  "rdx\0"  "rbx\0"  "rsp\0"  "rbp\0"  "rsi\0"  "rdi\0"  // #192
  "n/a\0"  "es\0\0" "cs\0\0" "ss\0\0" "ds\0\0" "fs\0\0" "gs\0\0" "n/a\0"; // #224

template<uint32_t X>
struct X86RegFormatInfo_T {
  enum {
    kFormatIndex  = X == X86Reg::kRegGpbLo ? 0   :
                    X == X86Reg::kRegGpbHi ? 5   :
                    X == X86Reg::kRegGpw   ? 10  :
                    X == X86Reg::kRegGpd   ? 15  :
                    X == X86Reg::kRegGpq   ? 20  :
                    X == X86Reg::kRegXmm   ? 24  :
                    X == X86Reg::kRegYmm   ? 30  :
                    X == X86Reg::kRegZmm   ? 36  :
                    X == X86Reg::kRegRip   ? 42  :
                    X == X86Reg::kRegSeg   ? 48  :
                    X == X86Reg::kRegFp    ? 54  :
                    X == X86Reg::kRegMm    ? 59  :
                    X == X86Reg::kRegK     ? 64  :
                    X == X86Reg::kRegBnd   ? 68  :
                    X == X86Reg::kRegCr    ? 74  :
                    X == X86Reg::kRegDr    ? 79  : 0,

    kSpecialIndex = X == X86Reg::kRegGpbLo ? 96  :
                    X == X86Reg::kRegGpbHi ? 128 :
                    X == X86Reg::kRegGpw   ? 161 :
                    X == X86Reg::kRegGpd   ? 160 :
                    X == X86Reg::kRegGpq   ? 192 :
                    X == X86Reg::kRegRip   ? 84  :
                    X == X86Reg::kRegSeg   ? 224 : 0,

    kSpecialCount = X == X86Reg::kRegGpbLo ? 8   :
                    X == X86Reg::kRegGpbHi ? 4   :
                    X == X86Reg::kRegGpw   ? 8   :
                    X == X86Reg::kRegGpd   ? 8   :
                    X == X86Reg::kRegGpq   ? 8   :
                    X == X86Reg::kRegRip   ? 1   :
                    X == X86Reg::kRegSeg   ? 7   : 0
  };
};

#define ASMJIT_X86_REG_FORMAT(TYPE) {      \
  X86RegTraits<TYPE>::kCount,              \
  X86RegFormatInfo_T<TYPE>::kFormatIndex,  \
  X86RegFormatInfo_T<TYPE>::kSpecialIndex, \
  X86RegFormatInfo_T<TYPE>::kSpecialCount  \
}

static const X86RegFormatInfo x86RegFormatInfo[] = {
  ASMJIT_TABLE_16(ASMJIT_X86_REG_FORMAT, 0 ),
  ASMJIT_TABLE_16(ASMJIT_X86_REG_FORMAT, 16)
};

static const char* x86GetAddressSizeString(uint32_t size) noexcept {
  switch (size) {
    case 1 : return "byte ";
    case 2 : return "word ";
    case 4 : return "dword ";
    case 6 : return "fword ";
    case 8 : return "qword ";
    case 10: return "tword ";
    case 16: return "oword ";
    case 32: return "yword ";
    case 64: return "zword ";
    default: return "";
  }
}

// ============================================================================
// [asmjit::X86Logging - Format Operand]
// ============================================================================

ASMJIT_FAVOR_SIZE Error X86Logging::formatOperand(
  StringBuilder& sb,
  uint32_t logOptions,
  const CodeEmitter* emitter,
  uint32_t archType,
  const Operand_& op) noexcept {

  if (op.isReg())
    return formatRegister(sb, logOptions, emitter, archType, op.as<Reg>().getType(), op.as<Reg>().getId());

  if (op.isMem()) {
    const X86Mem& m = op.as<X86Mem>();
    ASMJIT_PROPAGATE(sb.appendString(x86GetAddressSizeString(m.getSize())));

    // Segment override prefix.
    uint32_t seg = m.getSegmentId();
    if (seg != X86Seg::kIdNone && seg < X86Seg::kIdCount)
      ASMJIT_PROPAGATE(sb.appendFormat("%s:", x86RegFormatStrings + 224 + seg * 4));

    ASMJIT_PROPAGATE(sb.appendChar('['));
    if (m.isAbs())
      ASMJIT_PROPAGATE(sb.appendString("abs "));

    if (m.hasBase()) {
      if (m.hasBaseLabel()) {
        ASMJIT_PROPAGATE(Logging::formatLabel(sb, logOptions, emitter, m.getBaseId()));
      }
      else {
        if (m.isArgHome()) ASMJIT_PROPAGATE(sb.appendString("$"));
        if (m.isRegHome()) ASMJIT_PROPAGATE(sb.appendString("&"));
        ASMJIT_PROPAGATE(formatRegister(sb, logOptions, emitter, archType, m.getBaseType(), m.getBaseId()));
      }
    }

    if (m.hasIndex()) {
      ASMJIT_PROPAGATE(sb.appendChar('+'));
      ASMJIT_PROPAGATE(formatRegister(sb, logOptions, emitter, archType, m.getIndexType(), m.getIndexId()));
      if (m.hasShift())
        ASMJIT_PROPAGATE(sb.appendFormat("*%u", 1 << m.getShift()));
    }

    uint64_t off = static_cast<uint64_t>(m.getOffset());
    if (off) {
      uint32_t base = 10;
      char prefix = '+';

      if (static_cast<int64_t>(off) < 0) {
        off = ~off + 1;
        prefix = '-';
      }

      ASMJIT_PROPAGATE(sb.appendChar(prefix));
      if ((logOptions & Logger::kOptionHexDisplacement) != 0 && off > 9) {
        ASMJIT_PROPAGATE(sb.appendString("0x", 2));
        base = 16;
      }
      ASMJIT_PROPAGATE(sb.appendUInt(off, base));
    }

    return sb.appendChar(']');
  }

  if (op.isImm()) {
    const Imm& i = op.as<Imm>();
    int64_t val = i.getInt64();

    if ((logOptions & Logger::kOptionHexImmediate) != 0 && static_cast<uint64_t>(val) > 9)
      return sb.appendUInt(static_cast<uint64_t>(val), 16);
    else
      return sb.appendInt(val, 10);
  }

  if (op.isLabel()) {
    return Logging::formatLabel(sb, logOptions, emitter, op.getId());
  }

  return sb.appendString("<None>");
}

// ============================================================================
// [asmjit::X86Logging - Format Immediate (Extension)]
// ============================================================================

struct ImmBits {
  enum Mode {
    kModeLookup = 0x0,
    kModeFormat = 0x1
  };

  uint8_t mask;
  uint8_t shift;
  uint8_t mode;
  char text[45];
};

ASMJIT_FAVOR_SIZE static Error X86Logging_formatImmShuf(StringBuilder& sb, uint32_t u8, uint32_t bits, uint32_t count) noexcept {
  ASMJIT_PROPAGATE(sb.appendChar('<'));
  uint32_t mask = (1 << bits) - 1;

  for (uint32_t i = 0; i < count; i++, u8 >>= bits) {
    uint32_t value = u8 & mask;
    if (i != 0)
      ASMJIT_PROPAGATE(sb.appendChar('|'));
    ASMJIT_PROPAGATE(sb.appendUInt(value));
  }

  return sb.appendChar('>');
}

ASMJIT_FAVOR_SIZE static Error X86Logging_formatImmBits(StringBuilder& sb, uint32_t u8, const ImmBits* bits, uint32_t count) noexcept {
  uint32_t n = 0;
  char buf[64];

  for (uint32_t i = 0; i < count; i++) {
    const ImmBits& spec = bits[i];

    uint32_t value = (u8 & static_cast<uint32_t>(spec.mask)) >> spec.shift;
    const char* str = nullptr;

    switch (spec.mode) {
      case ImmBits::kModeLookup:
        str = Utils::findPackedString(spec.text, value);
        break;

      case ImmBits::kModeFormat:
        snprintf(buf, sizeof(buf), spec.text, static_cast<unsigned int>(value));
        str = buf;
        break;

      default:
        return DebugUtils::errored(kErrorInvalidState);
    }

    if (!str[0])
      continue;

    ASMJIT_PROPAGATE(sb.appendChar(++n == 1 ? '<' : '|'));
    ASMJIT_PROPAGATE(sb.appendString(str));
  }

  return n ? sb.appendChar('>') : static_cast<Error>(kErrorOk);
}

ASMJIT_FAVOR_SIZE static Error X86Logging_formatImmText(StringBuilder& sb, uint32_t u8, uint32_t bits, uint32_t advance, const char* text, uint32_t count = 1) noexcept {
  ASMJIT_PROPAGATE(sb.appendChar('<'));

  uint32_t mask = (1 << bits) - 1;
  uint32_t pos = 0;

  for (uint32_t i = 0; i < count; i++, u8 >>= bits, pos += advance) {
    uint32_t value = (u8 & mask) + pos;
    if (i != 0)
      ASMJIT_PROPAGATE(sb.appendChar('|'));
    ASMJIT_PROPAGATE(sb.appendString(Utils::findPackedString(text, value)));
  }

  return sb.appendChar('>');
}

ASMJIT_FAVOR_SIZE static Error X86Logging_formatImmExtended(
  StringBuilder& sb,
  uint32_t logOptions,
  uint32_t instId,
  uint32_t vecSize,
  const Imm& imm) noexcept {

  static const char vcmpx[] =
    "eq_oq\0" "lt_os\0"  "le_os\0"  "unord_q\0"  "neq_uq\0" "nlt_us\0" "nle_us\0" "ord_q\0"
    "eq_uq\0" "nge_us\0" "ngt_us\0" "false_oq\0" "neq_oq\0" "ge_os\0"  "gt_os\0"  "true_uq\0"
    "eq_os\0" "lt_oq\0"  "le_oq\0"  "unord_s\0"  "neq_us\0" "nlt_uq\0" "nle_uq\0" "ord_s\0"
    "eq_us\0" "nge_uq\0" "ngt_uq\0" "false_os\0" "neq_os\0" "ge_oq\0"  "gt_oq\0"  "true_us\0";

  // Try to find 7 differences...
  static const char vpcmpx[] = "eq\0" "lt\0" "le\0" "false\0" "neq\0" "ge\0"  "gt\0"    "true\0";
  static const char vpcomx[] = "lt\0" "le\0" "gt\0" "ge\0"    "eq\0"  "neq\0" "false\0" "true\0";

  static const char vshufpd[] = "a0\0a1\0b0\0b1\0a2\0a3\0b2\0b3\0a4\0a5\0b4\0b5\0a6\0a7\0b6\0b7\0";
  static const char vshufps[] = "a0\0a1\0a2\0a3\0a0\0a1\0a2\0a3\0b0\0b1\0b2\0b3\0b0\0b1\0b2\0b3\0";

  static const ImmBits vfpclassxx[] = {
    { 0x07, 0, ImmBits::kModeLookup, "qnan\0" "+0\0" "-0\0" "+inf\0" "-inf\0" "denormal\0" "-finite\0" "snan\0" }
  };

  static const ImmBits vgetmantxx[] = {
    { 0x03, 0, ImmBits::kModeLookup, "[1, 2)\0" "[1/2, 2)\0" "1/2, 1)\0" "[3/4, 3/2)\0" },
    { 0x04, 2, ImmBits::kModeLookup, "\0" "no-sign\0" },
    { 0x08, 3, ImmBits::kModeLookup, "\0" "qnan-if-sign\0" }
  };

  static const ImmBits vmpsadbw[] = {
    { 0x04, 2, ImmBits::kModeLookup, "blk1[0]\0" "blk1[1]\0" },
    { 0x03, 0, ImmBits::kModeLookup, "blk2[0]\0" "blk2[1]\0" "blk2[2]\0" "blk2[3]\0" },
    { 0x40, 6, ImmBits::kModeLookup, "blk1[4]\0" "blk1[5]\0" },
    { 0x30, 4, ImmBits::kModeLookup, "blk2[4]\0" "blk2[5]\0" "blk2[6]\0" "blk2[7]\0" }
  };

  static const ImmBits vpclmulqdq[] = {
    { 0x01, 0, ImmBits::kModeLookup, "lq\0" "hq\0" },
    { 0x10, 4, ImmBits::kModeLookup, "lq\0" "hq\0" }
  };

  static const ImmBits vperm2x128[] = {
    { 0x0B, 0, ImmBits::kModeLookup, "a0\0" "a1\0" "b0\0" "b1\0" "\0" "\0" "\0" "\0" "0\0" "0\0" "0\0" "0\0" },
    { 0xB0, 4, ImmBits::kModeLookup, "a0\0" "a1\0" "b0\0" "b1\0" "\0" "\0" "\0" "\0" "0\0" "0\0" "0\0" "0\0" }
  };

  static const ImmBits vrangexx[] = {
    { 0x03, 0, ImmBits::kModeLookup, "min\0" "max\0" "min-abs\0" "max-abs\0" },
    { 0x0C, 2, ImmBits::kModeLookup, "sign=src1\0" "sign=src2\0" "sign=0\0" "sign=1\0" }
  };

  static const ImmBits vreducexx_vrndscalexx[] = {
    { 0x07, 0, ImmBits::kModeLookup, "\0" "\0" "\0" "\0" "round\0" "floor\0" "ceil\0" "truncate\0" },
    { 0x08, 3, ImmBits::kModeLookup, "\0" "suppress\0" },
    { 0xF0, 4, ImmBits::kModeFormat, "len=%d" }
  };

  static const ImmBits vroundxx[] = {
    { 0x07, 0, ImmBits::kModeLookup, "round\0" "floor\0" "ceil\0" "truncate\0" "\0" "\0" "\0" "\0" },
    { 0x08, 3, ImmBits::kModeLookup, "\0" "inexact\0" }
  };

  uint32_t u8 = imm.getUInt8();
  switch (instId) {
    case X86Inst::kIdVblendpd:
    case X86Inst::kIdBlendpd:
      return X86Logging_formatImmShuf(sb, u8, 1, vecSize / 8);

    case X86Inst::kIdVblendps:
    case X86Inst::kIdBlendps:
      return X86Logging_formatImmShuf(sb, u8, 1, vecSize / 4);

    case X86Inst::kIdVcmppd:
    case X86Inst::kIdVcmpps:
    case X86Inst::kIdVcmpsd:
    case X86Inst::kIdVcmpss:
      return X86Logging_formatImmText(sb, u8, 5, 0, vcmpx);

    case X86Inst::kIdCmppd:
    case X86Inst::kIdCmpps:
    case X86Inst::kIdCmpsd:
    case X86Inst::kIdCmpss:
      return X86Logging_formatImmText(sb, u8, 3, 0, vcmpx);

    case X86Inst::kIdVdbpsadbw:
      return X86Logging_formatImmShuf(sb, u8, 2, 4);

    case X86Inst::kIdVdppd:
    case X86Inst::kIdVdpps:
    case X86Inst::kIdDppd:
    case X86Inst::kIdDpps:
      return X86Logging_formatImmShuf(sb, u8, 1, 8);

    case X86Inst::kIdVmpsadbw:
    case X86Inst::kIdMpsadbw:
      return X86Logging_formatImmBits(sb, u8, vmpsadbw, std::min<uint32_t>(vecSize / 8, 4));

    case X86Inst::kIdVpblendw:
    case X86Inst::kIdPblendw:
      return X86Logging_formatImmShuf(sb, u8, 1, 8);

    case X86Inst::kIdVpblendd:
      return X86Logging_formatImmShuf(sb, u8, 1, std::min<uint32_t>(vecSize / 4, 8));

    case X86Inst::kIdVpclmulqdq:
    case X86Inst::kIdPclmulqdq:
      return X86Logging_formatImmBits(sb, u8, vpclmulqdq, ASMJIT_ARRAY_SIZE(vpclmulqdq));

    case X86Inst::kIdVroundpd:
    case X86Inst::kIdVroundps:
    case X86Inst::kIdVroundsd:
    case X86Inst::kIdVroundss:
    case X86Inst::kIdRoundpd:
    case X86Inst::kIdRoundps:
    case X86Inst::kIdRoundsd:
    case X86Inst::kIdRoundss:
      return X86Logging_formatImmBits(sb, u8, vroundxx, ASMJIT_ARRAY_SIZE(vroundxx));

    case X86Inst::kIdVshufpd:
    case X86Inst::kIdShufpd:
      return X86Logging_formatImmText(sb, u8, 1, 2, vshufpd, std::min<uint32_t>(vecSize / 8, 8));

    case X86Inst::kIdVshufps:
    case X86Inst::kIdShufps:
      return X86Logging_formatImmText(sb, u8, 2, 4, vshufps, 4);

    case X86Inst::kIdVcvtps2ph:
      return X86Logging_formatImmBits(sb, u8, vroundxx, 1);

    case X86Inst::kIdVperm2f128:
    case X86Inst::kIdVperm2i128:
      return X86Logging_formatImmBits(sb, u8, vperm2x128, ASMJIT_ARRAY_SIZE(vperm2x128));

    case X86Inst::kIdVpermilpd:
      return X86Logging_formatImmShuf(sb, u8, 1, vecSize / 8);

    case X86Inst::kIdVpermilps:
      return X86Logging_formatImmShuf(sb, u8, 2, 4);

    case X86Inst::kIdVpshufd:
    case X86Inst::kIdPshufd:
      return X86Logging_formatImmShuf(sb, u8, 2, 4);

    case X86Inst::kIdVpshufhw:
    case X86Inst::kIdVpshuflw:
    case X86Inst::kIdPshufhw:
    case X86Inst::kIdPshuflw:
    case X86Inst::kIdPshufw:
      return X86Logging_formatImmShuf(sb, u8, 2, 4);

    // TODO: Maybe?
    case X86Inst::kIdVfixupimmpd:
    case X86Inst::kIdVfixupimmps:
    case X86Inst::kIdVfixupimmsd:
    case X86Inst::kIdVfixupimmss:
      return kErrorOk;

    case X86Inst::kIdVfpclasspd:
    case X86Inst::kIdVfpclassps:
    case X86Inst::kIdVfpclasssd:
    case X86Inst::kIdVfpclassss:
      return X86Logging_formatImmBits(sb, u8, vfpclassxx, ASMJIT_ARRAY_SIZE(vfpclassxx));

    case X86Inst::kIdVgetmantpd:
    case X86Inst::kIdVgetmantps:
    case X86Inst::kIdVgetmantsd:
    case X86Inst::kIdVgetmantss:
      return X86Logging_formatImmBits(sb, u8, vgetmantxx, ASMJIT_ARRAY_SIZE(vgetmantxx));

    case X86Inst::kIdVpcmpb:
    case X86Inst::kIdVpcmpd:
    case X86Inst::kIdVpcmpq:
    case X86Inst::kIdVpcmpw:
    case X86Inst::kIdVpcmpub:
    case X86Inst::kIdVpcmpud:
    case X86Inst::kIdVpcmpuq:
    case X86Inst::kIdVpcmpuw:
      return X86Logging_formatImmText(sb, u8, 2, 4, vpcmpx, 4);

    case X86Inst::kIdVpcomb:
    case X86Inst::kIdVpcomd:
    case X86Inst::kIdVpcomq:
    case X86Inst::kIdVpcomw:
    case X86Inst::kIdVpcomub:
    case X86Inst::kIdVpcomud:
    case X86Inst::kIdVpcomuq:
    case X86Inst::kIdVpcomuw:
      return X86Logging_formatImmText(sb, u8, 2, 4, vpcomx, 4);

    case X86Inst::kIdVpermq:
    case X86Inst::kIdVpermpd:
      return X86Logging_formatImmShuf(sb, u8, 2, 4);

    case X86Inst::kIdVpternlogd:
    case X86Inst::kIdVpternlogq:
      return X86Logging_formatImmShuf(sb, u8, 1, 8);

    case X86Inst::kIdVrangepd:
    case X86Inst::kIdVrangeps:
    case X86Inst::kIdVrangesd:
    case X86Inst::kIdVrangess:
      return X86Logging_formatImmBits(sb, u8, vrangexx, ASMJIT_ARRAY_SIZE(vrangexx));

    case X86Inst::kIdVreducepd:
    case X86Inst::kIdVreduceps:
    case X86Inst::kIdVreducesd:
    case X86Inst::kIdVreducess:
    case X86Inst::kIdVrndscalepd:
    case X86Inst::kIdVrndscaleps:
    case X86Inst::kIdVrndscalesd:
    case X86Inst::kIdVrndscaless:
      return X86Logging_formatImmBits(sb, u8, vreducexx_vrndscalexx, ASMJIT_ARRAY_SIZE(vreducexx_vrndscalexx));

    case X86Inst::kIdVshuff32x4:
    case X86Inst::kIdVshuff64x2:
    case X86Inst::kIdVshufi32x4:
    case X86Inst::kIdVshufi64x2: {
      uint32_t count = std::max<uint32_t>(vecSize / 16, 2);
      uint32_t bits = count <= 2 ? 1 : 2;
      return X86Logging_formatImmShuf(sb, u8, bits, count);
    }

    default:
      return kErrorOk;
  }
}

// ============================================================================
// [asmjit::X86Logging - Format Register]
// ============================================================================

ASMJIT_FAVOR_SIZE Error X86Logging::formatRegister(
  StringBuilder& sb,
  uint32_t logOptions,
  const CodeEmitter* emitter,
  uint32_t archType,
  uint32_t rType,
  uint32_t rId) noexcept {

  ASMJIT_UNUSED(logOptions);
  ASMJIT_UNUSED(archType);

  if (Operand::isPackedId(rId)) {
#if !defined(ASMJIT_DISABLE_COMPILER)
    if (emitter && emitter->getType() == CodeEmitter::kTypeCompiler) {
      const CodeCompiler* cc = static_cast<const CodeCompiler*>(emitter);

      if (cc->isVirtRegValid(rId)) {
        VirtReg* vReg = cc->getVirtRegById(rId);
        ASMJIT_ASSERT(vReg != nullptr);

        const char* name = vReg->getName();
        if (name && name[0] != '\0')
          return sb.appendString(name);
        else
          return sb.appendFormat("v%u", static_cast<unsigned int>(Operand::unpackId(rId)));
      }
    }
#endif // !ASMJIT_DISABLE_COMPILER

    return sb.appendFormat("VirtReg<Type=%u Id=%u>", rType, rId);
  }
  else {
    if (rType < ASMJIT_ARRAY_SIZE(x86RegFormatInfo)) {
      const X86RegFormatInfo& rfi = x86RegFormatInfo[rType];

      if (rId < rfi.specialCount)
        return sb.appendString(x86RegFormatStrings + rfi.specialIndex + rId * 4);

      if (rId < rfi.count)
        return sb.appendFormat(x86RegFormatStrings + rfi.formatIndex, static_cast<unsigned int>(rId));
    }

    return sb.appendFormat("PhysReg<Type=%u Id=%u>", rType, rId);
  }
}

// ============================================================================
// [asmjit::X86Logging - Format Instruction]
// ============================================================================

ASMJIT_FAVOR_SIZE Error X86Logging::formatInstruction(
  StringBuilder& sb,
  uint32_t logOptions,
  const CodeEmitter* emitter,
  uint32_t archType,
  const Inst::Detail& detail, const Operand_* opArray, uint32_t opCount) noexcept {

  uint32_t instId = detail.instId;
  uint32_t options = detail.options;

  // Format instruction options and instruction mnemonic.
  if (instId < X86Inst::_kIdCount) {
    const X86Inst& instInfo = X86Inst::getInst(instId);

    // SHORT|LONG options.
    if (options & X86Inst::kOptionShortForm) ASMJIT_PROPAGATE(sb.appendString("short "));
    if (options & X86Inst::kOptionLongForm) ASMJIT_PROPAGATE(sb.appendString("long "));

    // LOCK|XACQUIRE|XRELEASE options.
    if (options & X86Inst::kOptionXAcquire) ASMJIT_PROPAGATE(sb.appendString("xacquire "));
    if (options & X86Inst::kOptionXRelease) ASMJIT_PROPAGATE(sb.appendString("xrelease "));
    if (options & X86Inst::kOptionLock) ASMJIT_PROPAGATE(sb.appendString("lock "));

    // REP|REPNZ options.
    if (options & (X86Inst::kOptionRep | X86Inst::kOptionRepnz)) {
      sb.appendString((options & X86Inst::kOptionRep) ? "rep " : "repnz ");
      if (detail.hasExtraReg()) {
        ASMJIT_PROPAGATE(sb.appendChar('{'));
        ASMJIT_PROPAGATE(formatOperand(sb, logOptions, emitter, archType, detail.extraReg.toReg<Reg>()));
        ASMJIT_PROPAGATE(sb.appendString("} "));
      }
    }

    // REX options.
    if (options & X86Inst::kOptionRex) {
      const uint32_t kRXBWMask = X86Inst::kOptionOpCodeR |
                                 X86Inst::kOptionOpCodeX |
                                 X86Inst::kOptionOpCodeB |
                                 X86Inst::kOptionOpCodeW ;
      if (options & kRXBWMask) {
        sb.appendString("rex.");
        if (options & X86Inst::kOptionOpCodeR) sb.appendChar('r');
        if (options & X86Inst::kOptionOpCodeX) sb.appendChar('x');
        if (options & X86Inst::kOptionOpCodeB) sb.appendChar('b');
        if (options & X86Inst::kOptionOpCodeW) sb.appendChar('w');
        sb.appendChar(' ');
      }
      else {
        ASMJIT_PROPAGATE(sb.appendString("rex "));
      }
    }

    // VEX|EVEX options.
    if (options & X86Inst::kOptionVex3) ASMJIT_PROPAGATE(sb.appendString("vex3 "));
    if (options & X86Inst::kOptionEvex) ASMJIT_PROPAGATE(sb.appendString("evex "));

    ASMJIT_PROPAGATE(sb.appendString(instInfo.getName()));
  }
  else {
    ASMJIT_PROPAGATE(sb.appendFormat("<unknown id=#%u>", static_cast<unsigned int>(instId)));
  }

  for (uint32_t i = 0; i < opCount; i++) {
    const Operand_& op = opArray[i];
    if (op.isNone()) break;

    ASMJIT_PROPAGATE(sb.appendString(i == 0 ? " " : ", "));
    ASMJIT_PROPAGATE(formatOperand(sb, logOptions, emitter, archType, op));

    if (op.isImm() && (logOptions & Logger::kOptionImmExtended)) {
      uint32_t vecSize = 16;
      for (uint32_t j = 0; j < opCount; j++)
        if (opArray[j].isReg())
          vecSize = std::max<uint32_t>(vecSize, opArray[j].getSize());
      ASMJIT_PROPAGATE(X86Logging_formatImmExtended(sb, logOptions, instId, vecSize, op.as<Imm>()));
    }

    // Support AVX-512 {k}{z}.
    if (i == 0) {
      if (detail.extraReg.getKind() == X86Reg::kKindK) {
        ASMJIT_PROPAGATE(sb.appendString(" {"));
        ASMJIT_PROPAGATE(formatOperand(sb, logOptions, emitter, archType, detail.extraReg.toReg<Reg>()));
        ASMJIT_PROPAGATE(sb.appendChar('}'));

        if (options & X86Inst::kOptionZMask)
          ASMJIT_PROPAGATE(sb.appendString("{z}"));
      }
      else if (options & X86Inst::kOptionZMask) {
        ASMJIT_PROPAGATE(sb.appendString(" {z}"));
      }
    }

    // Support AVX-512 {1tox}.
    if (op.isMem() && (options & X86Inst::kOption1ToX))
      ASMJIT_PROPAGATE(sb.appendString(" {1tox}"));
  }

  return kErrorOk;
}

} // asmjit namespace

// [Api-End]
#include "../asmjit_apiend.h"

// [Guard]
#endif // !ASMJIT_DISABLE_LOGGING