bddisasm/bddisasm/bdformat.c

/*
 * Copyright (c) 2020 Bitdefender
 * SPDX-License-Identifier: Apache-2.0
 */
#include "include/nd_crt.h"
#include "../inc/bddisasm.h"



#ifndef BDDISASM_NO_FORMAT

static const char *gReg8Bit[] =
{
    "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
};

static const char *gReg8Bit64[] =
{
    "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
    "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b",
};

static const char *gReg16Bit[] =
{
    "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
    "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w",
};

static const char *gReg32Bit[] =
{
    "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
    "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d",
};

static const char *gReg64Bit[] =
{
    "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
    "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15"
};

static const char *gRegFpu[] =
{
    "st0", "st1", "st2", "st3", "st4", "st5", "st6", "st7",
};

static const char *gRegMmx[] =
{
    "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
};

static const char *gRegControl[] =
{
    "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
    "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
};

static const char *gRegDebug[] =
{
    "dr0", "dr1", "dr2", "dr3", "dr4", "dr5", "dr6", "dr7",
    "dr8", "dr9", "dr10", "dr11", "dr12", "dr13", "dr14", "dr15",
};

static const char *gRegTest[] =
{
    "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
    "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15",
};

static const char *gRegXmm[] =
{
    "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
    "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
    "xmm16", "xmm17", "xmm18", "xmm19", "xmm20", "xmm21", "xmm22", "xmm23",
    "xmm24", "xmm25", "xmm26", "xmm27", "xmm28", "xmm29", "xmm30", "xmm31",
};

static const char *gRegYmm[] =
{
    "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
    "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
    "ymm16", "ymm17", "ymm18", "ymm19", "ymm20", "ymm21", "ymm22", "ymm23",
    "ymm24", "ymm25", "ymm26", "ymm27", "ymm28", "ymm29", "ymm30", "ymm31"
};

static const char *gRegZmm[] =
{
    "zmm0", "zmm1", "zmm2", "zmm3", "zmm4", "zmm5", "zmm6", "zmm7",
    "zmm8", "zmm9", "zmm10", "zmm11", "zmm12", "zmm13", "zmm14", "zmm15",
    "zmm16", "zmm17", "zmm18", "zmm19", "zmm20", "zmm21", "zmm22", "zmm23",
    "zmm24", "zmm25", "zmm26", "zmm27", "zmm28", "zmm29", "zmm30", "zmm31",
};

static const char *gRegSeg[] =
{
    "es", "cs", "ss", "ds", "fs", "gs", "segr6", "segr7",
};

static const char *gRegBound[] =
{
    "bnd0", "bnd1", "bnd2", "bnd3",
};

static const char *gRegMask[] =
{
    "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7",
};

static const char *gRegTile[] =
{
    "tmm0", "tmm1", "tmm2", "tmm3", "tmm4", "tmm5", "tmm6", "tmm7",
};

static const char *gConditionCodes[] =
{
    "EQ", "LT", "LE", "UNORD", "NEQ", "NLT", "NLE", "ORD",
    "EQ_UQ", "NGE", "NGT", "ND_FALSE", "NEQ_OQ", "GE", "GT", "TRUE",
    "EQ_OS", "LT_OQ", "LE_OQ", "UNORD_S", "NEQ_US", "NLT_UQ", "NLE_UQ", "ORD_S",
    "EQ_US", "NGE_UQ", "NGT_UQ", "FALSE_OS", "NEQ_OS", "GE_OQ", "GT_OQ", "TRUE_US",
};

static const char *gEmbeddedRounding[] =
{
    "rn", "rd", "ru", "rz",
};



//
// NdSprintf
//
static NDSTATUS
NdSprintf(
    char *Destination,
    ND_SIZET DestinationSize,
    const char *Formatstring,
    ...
    )
//
// Wrapper on vsnprintf.
//
{
    int res;
    va_list args;

    if (ND_NULL == Destination)
    {
        return ND_STATUS_INVALID_PARAMETER;
    }

    if (ND_NULL == Formatstring)
    {
        return ND_STATUS_INVALID_PARAMETER;
    }

    nd_memzero(Destination, DestinationSize);

    va_start(args, Formatstring);

    // _vsnprintf is used instead of the more secure _vsnprintf_s because the mini-Petru supports just
    // the unsecured version, and we depend on it.
    res = nd_vsnprintf_s(Destination, DestinationSize, DestinationSize - 1, Formatstring, args);

    va_end(args);

    if ((res < 0) || ((ND_SIZET)res >= DestinationSize - 1))
    {
        return ND_STATUS_BUFFER_OVERFLOW;
    }

    return ND_STATUS_SUCCESS;
}


//
// NdToText
//
NDSTATUS
NdToText(
    const INSTRUX *Instrux,
    ND_UINT64 Rip,
    ND_UINT32 BufferSize,
    char *Buffer
    )
{
    NDSTATUS status;
    char *res, temp[64];
    ND_UINT32 opIndex, opsStored;
    const ND_OPERAND *pOp;
    ND_BOOL alignmentStored;

    // pre-init
    status = ND_STATUS_SUCCESS;
    res = (char *)ND_NULL;
    opIndex = 0;
    opsStored = 0;
    pOp = (const ND_OPERAND *)ND_NULL;
    alignmentStored = ND_FALSE;

    // Validate args.
    if (ND_NULL == Instrux)
    {
        return ND_STATUS_INVALID_PARAMETER;
    }

    if (ND_NULL == Buffer)
    {
        return ND_STATUS_INVALID_PARAMETER;
    }

    if (BufferSize < ND_MIN_BUF_SIZE)
    {
        return ND_STATUS_INVALID_PARAMETER;
    }

    // init the text.
    nd_memzero(Buffer, BufferSize);
    nd_memzero(temp, sizeof(temp));

    // First, store the prefixes.
    if (Instrux->Rep != 0)
    {
        // Check for REPZ/REPNZ support, and store prefixes.
        if (ND_REPC_SUPPORT(Instrux))
        {
            if (Instrux->Rep == ND_PREFIX_G1_REPE_REPZ)
            {
                res = nd_strcat_s(Buffer, BufferSize, "REPZ ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            else if (Instrux->Rep == ND_PREFIX_G1_REPNE_REPNZ)
            {
                res = nd_strcat_s(Buffer, BufferSize, "REPNZ ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
        }

        // Check for REP support and store prefixes.
        if (ND_REP_SUPPORT(Instrux))
        {
            if (Instrux->Rep == ND_PREFIX_G1_REPE_REPZ)
            {
                res = nd_strcat_s(Buffer, BufferSize, "REP ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            else if (Instrux->Rep == ND_PREFIX_G1_REPNE_REPNZ)
            {
                res = nd_strcat_s(Buffer, BufferSize, "REPNZ ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
        }

        if (Instrux->IsXreleaseEnabled)
        {
            res = nd_strcat_s(Buffer, BufferSize, "XRELEASE ");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
        else if (Instrux->IsXacquireEnabled)
        {
            res = nd_strcat_s(Buffer, BufferSize, "XACQUIRE ");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
    }

    if (Instrux->HasLock)
    {
        if (ND_LOCK_SUPPORT(Instrux))
        {
            res = nd_strcat_s(Buffer, BufferSize, "LOCK ");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
    }

    if (Instrux->Rep == ND_PREFIX_G1_BND)
    {
        if (ND_BND_SUPPORT(Instrux))
        {
            res = nd_strcat_s(Buffer, BufferSize, "BND ");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
    }

    if (Instrux->HasSeg && ND_BHINT_SUPPORT(Instrux))
    {
        switch (Instrux->Seg)
        {
        case ND_PREFIX_G2_BR_TAKEN:
            res = nd_strcat_s(Buffer, BufferSize, "BHT ");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            break;

        case ND_PREFIX_G2_BR_NOT_TAKEN:
            res = nd_strcat_s(Buffer, BufferSize, "BHNT ");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            break;

        case ND_PREFIX_G2_BR_ALT:
            res = nd_strcat_s(Buffer, BufferSize, "BHALT ");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            break;

        default:
            break;
        }
    }

    if (Instrux->HasSeg && ND_DNT_SUPPORT(Instrux))
    {
        if (!Instrux->IsCetTracked)
        {
            res = nd_strcat_s(Buffer, BufferSize, "DNT ");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
    }

    // Store the mnemonic.
    res = nd_strcat_s(Buffer, BufferSize, Instrux->Mnemonic);
    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);

    // Store condition code, if any.
    if (ND_HAS_SSE_CONDITION(Instrux))
    {
        res = nd_strcat_s(Buffer, BufferSize, gConditionCodes[Instrux->SseCondition]);
        RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
    }

    // If there are no explicit operands, we can leave.
    if (0 == Instrux->ExpOperandsCount)
    {
        return ND_STATUS_SUCCESS;
    }

    // Now the operands.
    for (opIndex = 0; opIndex < Instrux->OperandsCount; opIndex++)
    {
        status = ND_STATUS_SUCCESS;

        pOp = &Instrux->Operands[opIndex];

        if (pOp->Type == ND_OP_NOT_PRESENT)
        {
            break;
        }

        if (pOp->Flags.IsDefault)
        {
            continue;
        }

        // If this is a mask operand that has been used as masking for a previous operand, than we
        // can safely skip it. We check this by seeing where is the operand encoded. If it's encoded
        // in the evex.aaa field, than it is a conventional mask.
        if ((pOp->Encoding == ND_OPE_A) && (pOp->Type == ND_OP_REG) &&
            (pOp->Info.Register.Type == ND_REG_MSK) && (opIndex > 0))
        {
            continue;
        }

        // Store alignment.
        if (!alignmentStored)
        {
            ND_SIZET idx = 0;

            while ((idx < BufferSize) && (Buffer[idx]))
            {
                idx++;
            }

            while ((idx < 9) && (idx + 1 < BufferSize))
            {
                Buffer[idx++] = 0x20;
            }

            if (idx + 1 < BufferSize)
            {
                Buffer[idx++] = 0x20;
            }

            Buffer[idx] = 0;

            alignmentStored = ND_TRUE;
        }

        // Store the comma, if this isn't the first operand.
        if (opsStored > 0)
        {
            res = nd_strcat_s(Buffer, BufferSize, ", ");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }

        opsStored++;

        switch (pOp->Type)
        {
        case ND_OP_REG:
            switch (pOp->Info.Register.Type)
            {
            case ND_REG_GPR:
            {
                if (pOp->Info.Register.Reg >= ND_MAX_GPR_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                // General purpose register.
                switch (pOp->Info.Register.Size)
                {
                case ND_SIZE_8BIT:
                    // 8 bit register.
                    if ((Instrux->EncMode != ND_ENCM_LEGACY) || Instrux->HasRex)
                    {
                        res = nd_strcat_s(Buffer, BufferSize, gReg8Bit64[pOp->Info.Register.Reg]);
                        RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    }
                    else
                    {
                        res = nd_strcat_s(Buffer, BufferSize, gReg8Bit[pOp->Info.Register.Reg]);
                        RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    }
                    break;

                case ND_SIZE_16BIT:
                    // 16 bit register.
                    res = nd_strcat_s(Buffer, BufferSize, gReg16Bit[pOp->Info.Register.Reg]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;

                case ND_SIZE_32BIT:
                    // 32 bit register.
                    res = nd_strcat_s(Buffer, BufferSize, gReg32Bit[pOp->Info.Register.Reg]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;

                case ND_SIZE_64BIT:
                    // 64 bit register.
                    res = nd_strcat_s(Buffer, BufferSize, gReg64Bit[pOp->Info.Register.Reg]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;

                default:
                    return ND_STATUS_INVALID_INSTRUX;
                }
            }
            break;

            case ND_REG_SEG:
            {
                if (pOp->Info.Register.Reg >= ND_MAX_SEG_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                res = nd_strcat_s(Buffer, BufferSize, gRegSeg[pOp->Info.Register.Reg]);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            break;

            case ND_REG_FPU:
            {
                if (pOp->Info.Register.Reg >= ND_MAX_FPU_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                res = nd_strcat_s(Buffer, BufferSize, gRegFpu[pOp->Info.Register.Reg]);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            break;

            case ND_REG_MMX:
            {
                if (pOp->Info.Register.Reg >= ND_MAX_MMX_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                res = nd_strcat_s(Buffer, BufferSize, gRegMmx[pOp->Info.Register.Reg]);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            break;

            case ND_REG_SSE:
            {
                if (pOp->Info.Register.Reg >= ND_MAX_SSE_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                switch (pOp->Info.Register.Size)
                {
                case ND_SIZE_128BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gRegXmm[pOp->Info.Register.Reg]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_256BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gRegYmm[pOp->Info.Register.Reg]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_512BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gRegZmm[pOp->Info.Register.Reg]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                default:
                    return ND_STATUS_INVALID_INSTRUX;
                }
            }
            break;

            case ND_REG_CR:
            {
                if (pOp->Info.Register.Reg >= ND_MAX_CR_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                res = nd_strcat_s(Buffer, BufferSize, gRegControl[pOp->Info.Register.Reg]);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            break;

            case ND_REG_DR:
            {
                if (pOp->Info.Register.Reg >= ND_MAX_DR_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                res = nd_strcat_s(Buffer, BufferSize, gRegDebug[pOp->Info.Register.Reg]);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            break;

            case ND_REG_TR:
            {
                if (pOp->Info.Register.Reg >= ND_MAX_TR_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                res = nd_strcat_s(Buffer, BufferSize, gRegTest[pOp->Info.Register.Reg]);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            break;

            case ND_REG_BND:
            {
                // Sanity check.
                if (pOp->Info.Register.Reg >= ND_MAX_BND_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                res = nd_strcat_s(Buffer, BufferSize, gRegBound[pOp->Info.Register.Reg]);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            break;

            case ND_REG_MSK:
            {
                // Sanity check.
                if (pOp->Info.Register.Reg >= ND_MAX_MSK_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                res = nd_strcat_s(Buffer, BufferSize, gRegMask[pOp->Info.Register.Reg]);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            break;

            case ND_REG_TILE:
            {
                // Sanity check.
                if (pOp->Info.Register.Reg >= ND_MAX_TILE_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                res = nd_strcat_s(Buffer, BufferSize, gRegTile[pOp->Info.Register.Reg]);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }
            break;

            default:
                break;
            }

            if (pOp->Info.Register.Count > 1)
            {
                status = NdSprintf(temp, sizeof(temp), "+%d", pOp->Info.Register.Count - 1);
                if (!ND_SUCCESS(status))
                {
                    return status;
                }

                res = nd_strcat_s(Buffer, BufferSize, temp);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }

            break;

        case ND_OP_BANK:
            // Nothing to show.
            break;

        case ND_OP_CONST:
        {
            // Implicit constant
            status = NdSprintf(temp, sizeof(temp), "%d", pOp->Info.Constant.Const);
            if (!ND_SUCCESS(status))
            {
                return status;
            }

            res = nd_strcat_s(Buffer, BufferSize, temp);
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
        break;

        case ND_OP_IMM:
        {
            switch (pOp->Size)
            {
            case 1:
                status = NdSprintf(temp, sizeof(temp), "0x%02x", (ND_UINT8)pOp->Info.Immediate.Imm);
                break;
            case 2:
                status = NdSprintf(temp, sizeof(temp), "0x%04x", (ND_UINT16)pOp->Info.Immediate.Imm);
                break;
            case 4:
                status = NdSprintf(temp, sizeof(temp), "0x%08x", (ND_UINT32)pOp->Info.Immediate.Imm);
                break;
            case 8:
                status = NdSprintf(temp, sizeof(temp), "0x%016llx", (ND_UINT64)pOp->Info.Immediate.Imm);
                break;
            }
            if (!ND_SUCCESS(status))
            {
                return status;
            }

            res = nd_strcat_s(Buffer, BufferSize, temp);
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
        break;

        case ND_OP_OFFS:
        {
            ND_UINT64 dest = Rip + Instrux->Length + pOp->Info.RelativeOffset.Rel;

            // Truncate to the actual word length.
            switch (Instrux->WordLength)
            {
            case 2:
                dest &= 0xFFFF;
                break;
            case 4:
                dest &= 0xFFFFFFFF;
                break;
            default:
                break;
            }

            status = NdSprintf(temp, sizeof(temp), "0x%llx", dest);
            if (!ND_SUCCESS(status))
            {
                return status;
            }

            res = nd_strcat_s(Buffer, BufferSize, temp);
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
        break;

        case ND_OP_ADDR:
        {
            switch (Instrux->AddrLength)
            {
            case 4:
                status = NdSprintf(temp, sizeof(temp), "0x%04x:0x%04x",
                    pOp->Info.Address.BaseSeg, (ND_UINT16)pOp->Info.Address.Offset);
                break;
            case 6:
                status = NdSprintf(temp, sizeof(temp), "0x%04x:0x%08x",
                    pOp->Info.Address.BaseSeg, (ND_UINT32)pOp->Info.Address.Offset);
                break;
            case 10:
                status = NdSprintf(temp, sizeof(temp), "0x%04x:0x%016llx",
                    pOp->Info.Address.BaseSeg, (ND_UINT64)pOp->Info.Address.Offset);
                break;
            default:
                return ND_STATUS_INVALID_INSTRUX;
            }

            if (!ND_SUCCESS(status))
            {
                return status;
            }

            res = nd_strcat_s(Buffer, BufferSize, temp);
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
        break;

        case ND_OP_MEM:
        {
            // Prepend the size. For VSIB addressing, store the VSIB element size, not the total accessed size.
            ND_OPERAND_SIZE size = pOp->Info.Memory.IsVsib ? pOp->Info.Memory.Vsib.ElemSize : pOp->Size;

            switch (size)
            {
            case 1:
                res = nd_strcat_s(Buffer, BufferSize, "byte ptr ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                break;
            case 2:
                res = nd_strcat_s(Buffer, BufferSize, "word ptr ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                break;
            case 4:
                res = nd_strcat_s(Buffer, BufferSize, "dword ptr ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                break;
            case 6:
                res = nd_strcat_s(Buffer, BufferSize, "fword ptr ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                break;
            case 8:
                res = nd_strcat_s(Buffer, BufferSize, "qword ptr ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                break;
            case 10:
                res = nd_strcat_s(Buffer, BufferSize, "tbyte ptr ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                break;
            case 16:
                res = nd_strcat_s(Buffer, BufferSize, "xmmword ptr ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                break;
            case 32:
                res = nd_strcat_s(Buffer, BufferSize, "ymmword ptr ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                break;
            case 48:
                res = nd_strcat_s(Buffer, BufferSize, "m384 ptr ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                break;
            case 64:
                res = nd_strcat_s(Buffer, BufferSize, "zmmword ptr ");
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                break;
            default:
                break;
            }

            // Perpend the segment, only if it is overridden via a prefix.
            if (pOp->Info.Memory.HasSeg && Instrux->HasSeg)
            {
                if (pOp->Info.Memory.Seg >= ND_MAX_SEG_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                if ((ND_CODE_64 != Instrux->DefCode) || (NDR_FS == pOp->Info.Memory.Seg) ||
                    (NDR_GS == pOp->Info.Memory.Seg))
                {
                    res = nd_strcat_s(Buffer, BufferSize, gRegSeg[pOp->Info.Memory.Seg]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);

                    res = nd_strcat_s(Buffer, BufferSize, ":");
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                }
            }

            // Prepend the "["
            res = nd_strcat_s(Buffer, BufferSize, "[");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);

            // Base, if any.
            if (pOp->Info.Memory.HasBase)
            {
                if (pOp->Info.Memory.Base >= ND_MAX_GPR_REGS)
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                switch (pOp->Info.Memory.BaseSize)
                {
                case ND_SIZE_8BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gReg8Bit[pOp->Info.Memory.Base]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_16BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gReg16Bit[pOp->Info.Memory.Base]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_32BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gReg32Bit[pOp->Info.Memory.Base]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_64BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gReg64Bit[pOp->Info.Memory.Base]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                default:
                    return ND_STATUS_INVALID_INSTRUX;
                }
            }

            // Index, if any. Special treatment for VSIB addressing. Also, perpend a "+" if base is present.
            if (pOp->Info.Memory.HasIndex)
            {
                if (pOp->Info.Memory.Index >= (pOp->Info.Memory.IsVsib ? ND_MAX_SSE_REGS : ND_MAX_GPR_REGS))
                {
                    return ND_STATUS_INVALID_INSTRUX;
                }

                if (pOp->Info.Memory.HasBase)
                {
                    res = nd_strcat_s(Buffer, BufferSize, "+");
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                }

                switch (pOp->Info.Memory.IndexSize)
                {
                case ND_SIZE_8BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gReg8Bit[pOp->Info.Memory.Index]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_16BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gReg16Bit[pOp->Info.Memory.Index]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_32BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gReg32Bit[pOp->Info.Memory.Index]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_64BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gReg64Bit[pOp->Info.Memory.Index]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_128BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gRegXmm[pOp->Info.Memory.Index]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_256BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gRegYmm[pOp->Info.Memory.Index]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                case ND_SIZE_512BIT:
                    res = nd_strcat_s(Buffer, BufferSize, gRegZmm[pOp->Info.Memory.Index]);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                    break;
                default:
                    return ND_STATUS_INVALID_INSTRUX;
                }

                // If index is present, scale is also present.
                if (pOp->Info.Memory.Scale != 1 && !pOp->Info.Memory.IsMib)
                {
                    status = NdSprintf(temp, sizeof(temp), "*%d", pOp->Info.Memory.Scale);
                    if (!ND_SUCCESS(status))
                    {
                        return status;
                    }

                    res = nd_strcat_s(Buffer, BufferSize, temp);
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                }
            }

            // Handle displacement.
            if (pOp->Info.Memory.HasDisp)
            {
                ND_UINT64 normDisp, disp;

                disp = pOp->Info.Memory.Disp;

                // If this is direct addressing (O operand) or we don't have base or index, than we don't normalize
                // the displacement, since it is used as a direct offset. Note that the second condition also
                // includes the RIP-relative case.
                if (pOp->Info.Memory.IsDirect || !(pOp->Info.Memory.HasBase || pOp->Info.Memory.HasIndex))
                {
                    normDisp = disp;
                }
                else
                {
                    switch (pOp->Info.Memory.DispSize)
                    {
                    case 1:
                        normDisp = ((disp & 0x80) ? ~disp + 1ULL : disp) & 0xFF;
                        break;
                    case 2:
                        normDisp = ((disp & 0x8000) ? ~disp + 1ULL : disp) & 0xFFFF;
                        break;
                    case 4:
                        normDisp = ((disp & 0x80000000) ? ~disp + 1ULL : disp) & 0xFFFFFFFF;
                        break;
                    default:
                        normDisp = disp;
                        break;
                    }

                    // Handle compressed displacement. It is fine to cast the normDisp to ND_UINT32, as the
                    // compressed displacement only works with ND_UINT8 displacements. Also, in this phase,
                    // the normDisp is converted to a positive quantity, so no sign-extension is needed.
                    if (pOp->Info.Memory.HasCompDisp)
                    {
                        normDisp = (ND_UINT64)(ND_UINT32)normDisp * pOp->Info.Memory.CompDispSize;
                    }
                }


                // Now displacement.
                if (pOp->Info.Memory.HasBase || pOp->Info.Memory.HasIndex)
                {
                    res = nd_strcat_s(Buffer, BufferSize, Instrux->SignDisp ? "-" : "+");
                    RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
                }

                if (pOp->Info.Memory.IsRipRel)
                {
                    ND_UINT64 target = disp + Rip + Instrux->Length;

                    if (Instrux->AddrMode == ND_ADDR_32)
                    {
                        target &= 0xFFFFFFFF;
                    }

                    status = NdSprintf(temp, sizeof(temp), "rel 0x%llx", target);
                }
                else
                {
                    ND_UINT8 trimSize;

                    trimSize = (Instrux->AddrMode == ND_ADDR_16) ? 2 : ((Instrux->AddrMode == ND_ADDR_32) ? 4 : 8);

                    // Truncate the displacement size to the size of the address length.
                    normDisp = ND_TRIM(trimSize, normDisp);

                    status = NdSprintf(temp, sizeof(temp), "0x%llx", normDisp);
                }
                if (!ND_SUCCESS(status))
                {
                    return status;
                }

                res = nd_strcat_s(Buffer, BufferSize, temp);
                RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
            }

            // And the ending "]"
            res = nd_strcat_s(Buffer, BufferSize, "]");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
        break;

        default:
            return ND_STATUS_INVALID_INSTRUX;
        }

        // Handle memory broadcast.
        if (pOp->Decorator.HasBroadcast)
        {
            status = NdSprintf(temp, sizeof(temp), "{1to%d}", pOp->Decorator.Broadcast.Count);
            if (!ND_SUCCESS(status))
            {
                return status;
            }

            res = nd_strcat_s(Buffer, BufferSize, temp);
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }

        // Handle masking.
        if (pOp->Decorator.HasMask)
        {
            if (pOp->Decorator.Mask.Msk >= ND_MAX_MSK_REGS)
            {
                return ND_STATUS_INVALID_INSTRUX;
            }

            status = NdSprintf(temp, sizeof(temp), "{%s}", gRegMask[pOp->Decorator.Mask.Msk]);
            if (!ND_SUCCESS(status))
            {
                return status;
            }

            res = nd_strcat_s(Buffer, BufferSize, temp);
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }

        // Handle zeroing. Note that zeroing without masking is ignored.
        if (pOp->Decorator.HasZero && pOp->Decorator.HasMask)
        {
            res = nd_strcat_s(Buffer, BufferSize, "{z}");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }

        // Append Suppress All Exceptions decorator.
        if (pOp->Decorator.HasSae && !pOp->Decorator.HasEr)
        {
            // ER implies SAE, so if we have ER, we will list that.
            res = nd_strcat_s(Buffer, BufferSize, ", {sae}");
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }

        // Append Embedded Rounding decorator.
        if (pOp->Decorator.HasEr)
        {
            if (Instrux->RoundingMode >= 4)
            {
                return ND_STATUS_INVALID_INSTRUX;
            }

            status = NdSprintf(temp, sizeof(temp), ", {%s-sae}", gEmbeddedRounding[Instrux->RoundingMode]);
            if (!ND_SUCCESS(status))
            {
                return status;
            }

            res = nd_strcat_s(Buffer, BufferSize, temp);
            RET_EQ(res, ND_NULL, ND_STATUS_BUFFER_OVERFLOW);
        }
    }

    return ND_STATUS_SUCCESS;
}
#else
NDSTATUS
NdToText(
    const INSTRUX *Instrux,
    ND_UINT64 Rip,
    ND_UINT32 BufferSize,
    char *Buffer
    )
{
    UNREFERENCED_PARAMETER(Instrux);
    UNREFERENCED_PARAMETER(Rip);

    // At least make sure the buffer is ND_NULL-terminated so integrators can use NdToText without checking if the
    // BDDISASM_NO_FORMAT macro is defined. This makes switching between versions with formatting and versions without
    // formatting easier.
    if (Buffer != ND_NULL && BufferSize >= 1)
    {
        *Buffer = '\0';
    }

    return ND_STATUS_SUCCESS;
}
#endif // !BDDISASM_NO_FORMAT