fcml_disassembler.hpp

Go to the documentation of this file.

/*
 * FCML - Free Code Manipulation Library.
 * Copyright (C) 2010-2020 Slawomir Wojtasiak
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef FCML_DISASSEMBLER_HPP_
#define FCML_DISASSEMBLER_HPP_

#include <string.h>

#include "fcml_disassembler.h"

#include "fcml_common.hpp"
#include "fcml_errors.hpp"
#include "fcml_dialect.hpp"

namespace fcml {

class DisassemblingFailedException: public ErrorContainerAwareException {
public:
    DisassemblingFailedException(const fcml_cstring &msg,
            const ErrorContainer &errorContainer,
            fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR) :
            ErrorContainerAwareException(msg, errorContainer, error) {
    }
};

class DisassemblerConf {
public:

    DisassemblerConf() :
            _throwExceptionOnError(true),
            _incrementIP(true),
            _enableErrorMessages(true),
            _carryFlagConditionalSuffix(false),
            _conditionalGroup(false),
            _shortForms(false),
            _extendDispToASA(false),
            _failIfUnknownInstruction(false) {
    }

    bool isCarryFlagConditionalSuffix() const {
        return _carryFlagConditionalSuffix;
    }

    void setCarryFlagConditionalSuffix(bool carryFlagConditionalSuffix) {
        _carryFlagConditionalSuffix = carryFlagConditionalSuffix;
    }

    fcml_uint8_t getConditionalGroup() const {
        return _conditionalGroup;
    }

    void setConditionalGroup(fcml_uint8_t conditionalGroup) {
        _conditionalGroup = conditionalGroup;
    }

    bool isEnableErrorMessages() const {
        return _enableErrorMessages;
    }

    void setEnableErrorMessages(bool enableErrorMessages) {
        _enableErrorMessages = enableErrorMessages;
    }

    bool isExtendDispToAsa() const {
        return _extendDispToASA;
    }

    void setExtendDispToAsa(bool extendDispToAsa) {
        _extendDispToASA = extendDispToAsa;
    }

    bool isFailIfUnknownInstruction() const {
        return _failIfUnknownInstruction;
    }

    void setFailIfUnknownInstruction(bool failIfUnknownInstruction) {
        _failIfUnknownInstruction = failIfUnknownInstruction;
    }

    bool isIncrementIp() const {
        return _incrementIP;
    }

    void setIncrementIp(bool incrementIp) {
        _incrementIP = incrementIp;
    }

    bool isShortForms() const {
        return _shortForms;
    }

    void setShortForms(bool shortForms) {
        _shortForms = shortForms;
    }

    bool isThrowExceptionOnError() const {
        return _throwExceptionOnError;
    }

    void setThrowExceptionOnError(bool throwExceptionOnError) {
        _throwExceptionOnError = throwExceptionOnError;
    }

private:
    bool _throwExceptionOnError;
    bool _incrementIP;
    bool _enableErrorMessages;
    bool _carryFlagConditionalSuffix;
    fcml_uint8_t _conditionalGroup;
    bool _shortForms;
    bool _extendDispToASA;
    bool _failIfUnknownInstruction;

};

class DisassemblerContext {
public:

    DisassemblerContext() :
            _code(NULL), _codeLength(0) {
    }

    DisassemblerContext(fcml_ptr code, fcml_usize codeLength) :
            _code(code), _codeLength(codeLength) {
    }

public:

    fcml_ptr getCode() const {
        return _code;
    }

    void setCode(fcml_ptr code) {
        _code = code;
    }

    fcml_usize getCodeLength() const {
        return _codeLength;
    }

    void setCodeLength(fcml_usize codeLength) {
        _codeLength = codeLength;
    }

    const DisassemblerConf& getDisassemblerConf() const {
        return _disassemblerConf;
    }

    DisassemblerConf& getDisassemblerConf() {
        return _disassemblerConf;
    }

    void setDisassemblerConf(DisassemblerConf disassemblerConf) {
        _disassemblerConf = disassemblerConf;
    }

    const EntryPoint& getEntryPoint() const {
        return _entryPoint;
    }

    EntryPoint& getEntryPoint() {
        return _entryPoint;
    }
    void setEntryPoint(const EntryPoint &entryPoint) {
        _entryPoint = entryPoint;
    }

    void setIP(fcml_ip ip) {
        _entryPoint.setIP(ip);
    }

    void incrementIP(fcml_ip ip) {
        _entryPoint.incrementIP(ip);
    }

    void setOperatingMode(EntryPoint::OperatingMode operatingMode) {
        _entryPoint.setOpMode(operatingMode);
    }

    void setAddressSizeAttribute(fcml_usize addressSizeAttribute) {
        _entryPoint.setAddressSizeAttribute(addressSizeAttribute);
    }

    void setOperandSizeAttribute(fcml_usize operandSizeAttribute) {
        _entryPoint.setOperandSizeAttribute(operandSizeAttribute);
    }

private:
    DisassemblerConf _disassemblerConf;
    EntryPoint _entryPoint;
    fcml_ptr _code;
    fcml_usize _codeLength;
};

class InstructionPrefixDetails {
public:

    enum PrefixType {
        PT_GROUP_UNKNOWN = FCML_PT_GROUP_UNKNOWN,
        PT_GROUP_1 = FCML_PT_GROUP_1,
        PT_GROUP_2 = FCML_PT_GROUP_2,
        PT_GROUP_3 = FCML_PT_GROUP_3,
        PT_GROUP_4 = FCML_PT_GROUP_4,
        PT_REX = FCML_PT_REX,
        PT_VEX = FCML_PT_VEX,
        PT_XOP = FCML_PT_XOP,
        PT_EVEX = FCML_PT_EVEX
    };

    bool isMandatoryPrefix() const {
        return _mandatoryPrefix;
    }

    void setMandatoryPrefix(bool mandatoryPrefix) {
        _mandatoryPrefix = mandatoryPrefix;
    }

    fcml_uint8_t getPrefix() const {
        return _prefix;
    }

    void setPrefix(fcml_uint8_t prefix) {
        _prefix = prefix;
    }

    PrefixType getPrefixType() const {
        return _prefixType;
    }

    void setPrefixType(PrefixType prefixType) {
        _prefixType = prefixType;
    }

    const fcml_uint8_t* getAvxBytes() const {
        return _AvxBytes;
    }

    fcml_uint8_t* getAvxBytes() {
        return _AvxBytes;
    }

private:
    fcml_uint8_t _prefix;
    PrefixType _prefixType;
    bool _mandatoryPrefix;
    fcml_uint8_t _AvxBytes[3];
};

class PrefixesDetails {
public:

    PrefixesDetails() :
            _prefixesCount(0),
            _prefixesBytesCount(0),
            _isBranch(false),
            _isNobranch(false),
            _isLock(false),
            _isRep(false),
            _isRepne(false),
            _isXrelease(false),
            _isXacquire(false),
            _isVex(false),
            _isEvex(false),
            _isXop(false),
            _isAvx(false),
            _isRex(false),
            _AvxPrefixFirstByte(false),
            _R(0),
            _RPrim(0),
            _X(0),
            _B(0),
            _W(0),
            _L(0),
            _LPrim(0),
            _mmmm(0),
            _vvvv(0),
            _VPrim(0),
            _pp(0),
            _aaa(0),
            _b(false),
            _z(false) {
    }

    const InstructionPrefixDetails& operator[](fcml_usize index) const {
        if (index >= FCML_DASM_PREFIXES_COUNT) {
            throw IllegalArgumentException(FCML_TEXT("Index out of bound."));
        }
        return _prefixes[index];
    }

    InstructionPrefixDetails& operator[](fcml_usize index) {
        if (index >= FCML_DASM_PREFIXES_COUNT) {
            throw IllegalArgumentException(FCML_TEXT("Index out of bound."));
        }
        return _prefixes[index];
    }

    fcml_uint8_t getB() const {
        return _B;
    }

    void setB(fcml_uint8_t B) {
        _B = B;
    }

    bool isBranch() const {
        return _isBranch;
    }

    void setBranch(bool isBranch) {
        _isBranch = isBranch;
    }

    bool isLock() const {
        return _isLock;
    }

    void setLock(bool isLock) {
        _isLock = isLock;
    }

    bool isNobranch() const {
        return _isNobranch;
    }

    void setNobranch(bool isNobranch) {
        _isNobranch = isNobranch;
    }

    bool isRep() const {
        return _isRep;
    }

    void setRep(bool isRep) {
        _isRep = isRep;
    }

    bool isRepne() const {
        return _isRepne;
    }

    void setRepne(bool isRepne) {
        _isRepne = isRepne;
    }

    bool isRex() const {
        return _isRex;
    }

    void setRex(bool isRex) {
        _isRex = isRex;
    }

    bool isVex() const {
        return _isVex;
    }

    void setVex(bool isVex) {
        _isVex = isVex;
    }

    void setEvex(bool isEvex) {
        _isEvex = isEvex;
    }

    bool isEvex() const {
        return _isEvex;
    }

    bool isXacquire() const {
        return _isXacquire;
    }

    void setXacquire(bool isXacquire) {
        _isXacquire = isXacquire;
    }

    bool isXop() const {
        return _isXop;
    }

    void setXop(bool isXop) {
        _isXop = isXop;
    }

    bool isAvx() const {
        return _isAvx;
    }

    void setAvx(bool isAvx) {
        _isAvx = isAvx;
    }

    bool isXrelease() const {
        return _isXrelease;
    }

    void setXrelease(bool isXrelease) {
        _isXrelease = isXrelease;
    }

    fcml_uint8_t getL() const {
        return _L;
    }

    void setL(fcml_uint8_t L) {
        _L = L;
    }

    fcml_uint8_t getLPrim() const {
        return _LPrim;
    }

    void setLPrim(fcml_uint8_t lPrim) {
        _LPrim = lPrim;
    }

    fcml_uint8_t getMmmm() const {
        return _mmmm;
    }

    void setMmmm(fcml_uint8_t mmmm) {
        _mmmm = mmmm;
    }

    fcml_uint8_t getPp() const {
        return _pp;
    }

    void setPp(fcml_uint8_t pp) {
        _pp = pp;
    }

    const InstructionPrefixDetails& getPrefixes(fcml_usize index) const {
        if (index > FCML_DASM_PREFIXES_COUNT) {
            throw BadArgumentException(FCML_TEXT("Array index out of bound."),
                    FCML_CEH_GEC_VALUE_OUT_OF_RANGE);
        }
        return _prefixes[index];
    }

    InstructionPrefixDetails& getPrefixes(fcml_usize index) {
        if (index > FCML_DASM_PREFIXES_COUNT) {
            throw BadArgumentException(FCML_TEXT("Array index out of bound."),
                    FCML_CEH_GEC_VALUE_OUT_OF_RANGE);
        }
        return _prefixes[index];
    }

    fcml_int getPrefixesBytesCount() const {
        return _prefixesBytesCount;
    }

    void setPrefixesBytesCount(fcml_int prefixesBytesCount) {
        _prefixesBytesCount = prefixesBytesCount;
    }

    fcml_int getPrefixesCount() const {
        return _prefixesCount;
    }

    void setPrefixesCount(fcml_int prefixesCount) {
        _prefixesCount = prefixesCount;
    }

    fcml_uint8_t getR() const {
        return _R;
    }

    void setR(fcml_uint8_t r) {
        _R = r;
    }

    fcml_uint8_t getRPrim() const {
        return _RPrim;
    }

    void setRPrim(fcml_uint8_t rPrim) {
        _RPrim = rPrim;
    }

    fcml_uint8_t getAvxFirstByte() const {
        return _AvxPrefixFirstByte;
    }

    void setAvxFirstByte(fcml_uint8_t avxFirstByte) {
        _AvxPrefixFirstByte = avxFirstByte;
    }

    fcml_uint8_t getVvvv() const {
        return _vvvv;
    }

    void setVvvv(fcml_uint8_t vvvv) {
        _vvvv = vvvv;
    }

    fcml_uint8_t getAaa() const {
        return _aaa;
    }

    void setAaa(fcml_uint8_t aaa) {
        _aaa = aaa;
    }

    fcml_uint8_t getVPrim() const {
        return _VPrim;
    }

    void setVPrim(fcml_uint8_t vPrim) {
        _VPrim = vPrim;
    }

    fcml_uint8_t getW() const {
        return _W;
    }

    void setW(fcml_uint8_t W) {
        _W = W;
    }

    fcml_uint8_t getX() const {
        return _X;
    }

    void setX(fcml_uint8_t X) {
        _X = X;
    }

    bool getBcast() const {
        return _b;
    }

    void setBcast(bool b) {
        _b = b;
    }

    bool getZ() const {
        return _z;
    }

    void setZ(bool z) {
        _z = z;
    }

private:
    InstructionPrefixDetails _prefixes[FCML_DASM_PREFIXES_COUNT];
    fcml_int _prefixesCount;
    fcml_int _prefixesBytesCount;
    bool _isBranch;
    bool _isNobranch;
    bool _isLock;
    bool _isRep;
    bool _isRepne;
    bool _isXrelease;
    bool _isXacquire;
    bool _isVex;
    bool _isEvex;
    bool _isXop;
    bool _isAvx;
    bool _isRex;
    fcml_uint8_t _AvxPrefixFirstByte;
    fcml_uint8_t _R;
    fcml_uint8_t _RPrim;
    fcml_uint8_t _X;
    fcml_uint8_t _B;
    fcml_uint8_t _W;
    fcml_uint8_t _L;
    fcml_uint8_t _LPrim;
    fcml_uint8_t _mmmm;
    fcml_uint8_t _vvvv;
    fcml_uint8_t _VPrim;
    fcml_uint8_t _pp;
    fcml_uint8_t _aaa;
    bool _b;
    bool _z;
};

class OperandDetails {
public:

    enum AccessMode {
        AM_ACCESS_MODE_UNDEFINED = FCML_AM_ACCESS_MODE_UNDEFINED,
        AM_READ = FCML_AM_READ,
        AM_WRITE = FCML_AM_WRITE,
        AM_READ_WRITE = AM_READ | AM_WRITE
    };

    OperandDetails() :
            _accessMode(AM_ACCESS_MODE_UNDEFINED) {
    }

    OperandDetails(AccessMode accessMode) :
            _accessMode(accessMode) {
    }

    AccessMode getAccessMode() const {
        return _accessMode;
    }

    void setAccessMode(AccessMode accessMode) {
        _accessMode = accessMode;
    }

private:
    AccessMode _accessMode;
};

class DecodedModRMDetails {
public:

    DecodedModRMDetails() :
            _isRip(false) {
    }

    bool isRip() const {
        return _isRip;
    }

    void setRip(bool isRip) {
        _isRip = isRip;
    }

    const Nullable<fcml_uint8_t>& getModRM() const {
        return _modRM;
    }

    Nullable<fcml_uint8_t>& getModRM() {
        return _modRM;
    }

    void setModRM(const Nullable<fcml_uint8_t> &modRM) {
        _modRM = modRM;
    }

    const Nullable<fcml_uint8_t>& getSib() const {
        return _sib;
    }

    Nullable<fcml_uint8_t>& getSib() {
        return _sib;
    }

    void setSib(const Nullable<fcml_uint8_t> &sib) {
        _sib = sib;
    }

    const Nullable<fcml_uint32_t>& getN() const {
        return _N;
    }

    Nullable<fcml_uint32_t>& getN() {
        return _N;
    }

    void setN(const Nullable<fcml_uint32_t> &N) {
        _N = N;
    }

    const Integer& getDisplacement() const {
        return _displacement;
    }

    Integer& getDisplacement() {
        return _displacement;
    }

    void setDisplacement(const Integer &displacement) {
        _displacement = displacement;
    }

private:
    Nullable<fcml_uint8_t> _modRM;
    Nullable<fcml_uint8_t> _sib;
    bool _isRip;
    Integer _displacement;
    /* N from AVX-512 compressed disp8.
     * since 1.2.0
     */
    Nullable<fcml_uint32_t> _N;
};

class InstructionDetails {
public:

    fcml_uint16_t getAddrMode() const {
        return _addrMode;
    }

    void setAddrMode(fcml_uint16_t addrMode) {
        _addrMode = addrMode;
    }

    fcml_en_instruction getInstruction() const {
        return _instruction;
    }

    void setInstruction(fcml_en_instruction instruction) {
        _instruction = instruction;
    }

    const fcml_uint8_t* getInstructionCode() const {
        return _instructionCode;
    }

    fcml_uint8_t* getInstructionCode() {
        return _instructionCode;
    }

    fcml_uint64_t getInstructionGroup() const {
        return _instructionGroup;
    }

    void setInstructionGroup(fcml_uint64_t instructionGroup) {
        _instructionGroup = instructionGroup;
    }

    fcml_usize getInstructionSize() const {
        return _instructionSize;
    }

    void setInstructionSize(fcml_usize instructionSize) {
        _instructionSize = instructionSize;
    }

    bool isShortcut() const {
        return _isShortcut;
    }

    void setShortcut(bool isShortcut) {
        _isShortcut = isShortcut;
    }

    const DecodedModRMDetails& getModRmDetails() const {
        return _modRMDetails;
    }

    DecodedModRMDetails& getModRmDetails() {
        return _modRMDetails;
    }

    void setModRmDetails(const DecodedModRMDetails &modRmDetails) {
        _modRMDetails = modRmDetails;
    }

    bool isOpcodeFieldSBit() const {
        return _opcodeFieldSBit;
    }

    void setOpcodeFieldSBit(bool opcodeFieldSBit) {
        _opcodeFieldSBit = opcodeFieldSBit;
    }

    bool isOpcodeFieldWBit() const {
        return _opcodeFieldWBit;
    }

    void setOpcodeFieldWBit(bool opcodeFieldWBit) {
        _opcodeFieldWBit = opcodeFieldWBit;
    }

    const OperandDetails& getOperandDetails(fcml_usize index) const {
        if (index > FCML_OPERANDS_COUNT) {
            throw BadArgumentException(FCML_TEXT("Array index out of bound."),
                    FCML_CEH_GEC_VALUE_OUT_OF_RANGE);
        }
        return _operandDetails[index];
    }

    OperandDetails& getOperandDetails(fcml_usize index) {
        if (index > FCML_OPERANDS_COUNT) {
            throw BadArgumentException(FCML_TEXT("Array index out of bound."),
                    FCML_CEH_GEC_VALUE_OUT_OF_RANGE);
        }
        return _operandDetails[index];
    }

    const PrefixesDetails& getPrefixesDetails() const {
        return _prefixesDetails;
    }

    PrefixesDetails& getPrefixesDetails() {
        return _prefixesDetails;
    }

    void setPrefixesDetails(const PrefixesDetails &prefixesDetails) {
        _prefixesDetails = prefixesDetails;
    }

    fcml_en_pseudo_operations getPseudoOp() const {
        return _pseudoOp;
    }

    void setPseudoOp(fcml_en_pseudo_operations pseudoOp) {
        _pseudoOp = pseudoOp;
    }

    bool isPseudoOp() const {
        return _isPseudoOp;
    }

    void setIsPseudoOp(bool isPseudoOp) {
        _isPseudoOp = isPseudoOp;
    }

    fcml_uint8_t getTupleType() const {
        return _tupleType;
    }

    void setTupleType(fcml_uint8_t tupleType) {
        _tupleType = tupleType;
    }

private:

    bool _isShortcut;
    bool _isPseudoOp;
    fcml_uint8_t _instructionCode[FCML_INSTRUCTION_SIZE];
    fcml_usize _instructionSize;
    PrefixesDetails _prefixesDetails;
    OperandDetails _operandDetails[FCML_OPERANDS_COUNT];
    DecodedModRMDetails _modRMDetails;
    bool _opcodeFieldSBit;
    bool _opcodeFieldWBit;
    fcml_en_instruction _instruction;
    fcml_en_pseudo_operations _pseudoOp;
    fcml_uint16_t _addrMode;
    fcml_uint64_t _instructionGroup;
    fcml_uint8_t _tupleType;
};

class DisassemblerResult {

public:

    const ErrorContainer& getErrorContainer() const {
        return _errorContainer;
    }

    const Instruction& getInstruction() const {
        return _instruction;
    }

    const InstructionDetails& getInstructionDetails() const {
        return _instructionDetails;
    }

    void clean() {
        _errorContainer.clean();
        _instructionDetails = InstructionDetails();
        _instruction = Instruction();
    }

protected:

    friend class Disassembler;
    friend class DisassemblerTypeConverter;

    InstructionDetails& getInstructionDetailsInternal() {
        return _instructionDetails;
    }

    void setInstructionDetails(const InstructionDetails &instructionDetails) {
        _instructionDetails = instructionDetails;
    }

    Instruction& getInstructionInternal() {
        return _instruction;
    }

    void setInstruction(const Instruction &instruction) {
        _instruction = instruction;
    }

    void setErrorContainer(const ErrorContainer &errorContainer) {
        _errorContainer = errorContainer;
    }

private:

    ErrorContainer _errorContainer;
    InstructionDetails _instructionDetails;
    Instruction _instruction;

};

class DisassemblerTypeConverter {

public:

    static void convert(const DisassemblerContext &src,
            fcml_st_disassembler_context &dest) {
        dest.code = src.getCode();
        dest.code_length = src.getCodeLength();
        TypeConverter::convert(src.getEntryPoint(), dest.entry_point);
        convert(src.getDisassemblerConf(), dest.configuration);
    }

    static void convert(const DisassemblerConf &src,
            fcml_st_disassembler_conf &dest) {
        dest.conditional_group = src.getConditionalGroup();
        dest.carry_flag_conditional_suffix = src.isCarryFlagConditionalSuffix();
        dest.enable_error_messages = src.isEnableErrorMessages();
        dest.extend_disp_to_asa = src.isExtendDispToAsa();
        dest.fail_if_unknown_instruction = src.isFailIfUnknownInstruction();
        dest.increment_ip = src.isIncrementIp();
        dest.short_forms = src.isShortForms();
    }

    static void convert(const fcml_st_decoded_modrm_details &src,
            DecodedModRMDetails &dest) {
        dest.setRip(FCML_TO_CPP_BOOL(src.is_rip));
        Nullable<fcml_uint8_t> &modRM = dest.getModRM();
        modRM.setNotNull(FCML_TO_CPP_BOOL(src.is_modrm));
        modRM.setValue(src.modrm);
        Nullable<fcml_uint8_t> &sib = dest.getSib();
        sib.setNotNull(FCML_TO_CPP_BOOL(src.sib.is_not_null));
        sib.setValue(src.sib.value);
        TypeConverter::convert(src.displacement.displacement,
                dest.getDisplacement());
        Nullable<fcml_uint32_t> N;
        N.setNotNull(FCML_TO_CPP_BOOL(src.displacement.N.is_not_null));
        N.setValue(src.displacement.N.value);
        dest.setN(N);
    }

    static void convert(const DecodedModRMDetails &src,
            fcml_st_decoded_modrm_details &dest) {
        dest.is_modrm = src.getModRM().isNotNull();
        dest.is_rip = src.isRip();
        dest.modrm = src.getModRM().getValue();
        fcml_nuint8_t &sib = dest.sib;
        sib.is_not_null = src.getSib().isNotNull();
        sib.value = src.getSib().getValue();
        TypeConverter::convert(src.getDisplacement(),
                dest.displacement.displacement);
        dest.displacement.N.is_not_null = src.getN().isNotNull();
        dest.displacement.N.value = src.getN().getValue();
    }

    static void convert(const fcml_st_operand_details &src,
            OperandDetails &dest) {
        dest.setAccessMode(
                static_cast<OperandDetails::AccessMode>(src.access_mode));
    }

    static void convert(const OperandDetails &src,
            fcml_st_operand_details &dest) {
        dest.access_mode =
                static_cast<fcml_en_access_mode>(src.getAccessMode());
    }

    static void convert(const fcml_st_instruction_prefix &src,
            InstructionPrefixDetails &dest) {
        dest.setMandatoryPrefix(FCML_TO_CPP_BOOL(src.mandatory_prefix));
        dest.setPrefix(src.prefix);
        dest.setPrefixType(
                static_cast<InstructionPrefixDetails::PrefixType>(src.prefix_type));
        ::memcpy(dest.getAvxBytes(), src.avx_bytes, sizeof(src.avx_bytes));
    }

    static void convert(const InstructionPrefixDetails &src,
            fcml_st_instruction_prefix &dest) {
        dest.mandatory_prefix = src.isMandatoryPrefix();
        dest.prefix = src.getPrefix();
        dest.prefix_type =
                static_cast<fcml_en_prefix_types>(src.getPrefixType());
        ::memcpy(dest.avx_bytes, src.getAvxBytes(), sizeof(dest.avx_bytes));
    }

    static void convert(const fcml_st_prefixes_details src,
            PrefixesDetails &dest) {
        for (int i = 0; i < FCML_DASM_PREFIXES_COUNT; i++) {
            convert(src.prefixes[i], dest.getPrefixes(i));
        }
        dest.setPrefixesCount(src.prefixes_count);
        dest.setPrefixesBytesCount(src.prefixes_bytes_count);
        dest.setBranch(FCML_TO_CPP_BOOL(src.is_branch));
        dest.setNobranch(FCML_TO_CPP_BOOL(src.is_nobranch));
        dest.setLock(FCML_TO_CPP_BOOL(src.is_lock));
        dest.setRep(FCML_TO_CPP_BOOL(src.is_rep));
        dest.setRepne(FCML_TO_CPP_BOOL(src.is_repne));
        dest.setXrelease(FCML_TO_CPP_BOOL(src.is_xrelease));
        dest.setXacquire(FCML_TO_CPP_BOOL(src.is_xacquire));
        dest.setVex(FCML_TO_CPP_BOOL(src.is_vex));
        dest.setEvex(FCML_TO_CPP_BOOL(src.is_evex));
        dest.setXop(FCML_TO_CPP_BOOL(src.is_xop));
        dest.setAvx(FCML_TO_CPP_BOOL(src.is_avx));
        dest.setRex(FCML_TO_CPP_BOOL(src.is_rex));
        dest.setAvxFirstByte(src.avx_first_byte);
        dest.setR(src.R);
        dest.setRPrim(src.R_prim);
        dest.setX(src.X);
        dest.setB(src.B);
        dest.setW(src.W);
        dest.setL(src.L);
        dest.setLPrim(src.L_prim);
        dest.setMmmm(src.mmmm);
        dest.setVvvv(src.vvvv);
        dest.setVPrim(src.V_prim);
        dest.setPp(src.pp);
        dest.setAaa(src.aaa);
        dest.setBcast(src.b);
        dest.setZ(src.z);
    }

    static void convert(const PrefixesDetails src,
            fcml_st_prefixes_details &dest) {
        for (int i = 0; i < FCML_DASM_PREFIXES_COUNT; i++) {
            convert(src.getPrefixes(i), dest.prefixes[i]);
        }
        dest.prefixes_count = src.getPrefixesCount();
        dest.prefixes_bytes_count = src.getPrefixesBytesCount();
        dest.is_branch = src.isBranch();
        dest.is_nobranch = src.isNobranch();
        dest.is_lock = src.isLock();
        dest.is_rep = src.isRep();
        dest.is_repne = src.isRepne();
        dest.is_xrelease = src.isXrelease();
        dest.is_xacquire = src.isXacquire();
        dest.is_vex = src.isVex();
        dest.is_xop = src.isXop();
        dest.is_avx = src.isAvx();
        dest.is_evex = src.isEvex();
        dest.is_rex = src.isRex();
        dest.avx_first_byte = src.getAvxFirstByte();
        dest.R = src.getR();
        dest.R_prim = src.getRPrim();
        dest.X = src.getX();
        dest.B = src.getB();
        dest.W = src.getW();
        dest.L = src.getL();
        dest.L_prim = src.getLPrim();
        dest.mmmm = src.getMmmm();
        dest.vvvv = src.getVvvv();
        dest.V_prim = src.getVPrim();
        dest.pp = src.getPp();
        dest.aaa = src.getAaa();
        dest.b = src.getBcast();
        dest.z = src.getZ() ? 1 : 0;
    }

    static void convert(const fcml_st_instruction_details &src,
            InstructionDetails &dest) {
        dest.setTupleType(src.tuple_type);
        dest.setAddrMode(src.addr_mode);
        dest.setInstruction(src.instruction);
        dest.setInstructionGroup(src.instruction_group);
        dest.setInstructionSize(src.instruction_size);
        dest.setOpcodeFieldSBit(FCML_TO_CPP_BOOL(src.opcode_field_s_bit));
        dest.setOpcodeFieldWBit(FCML_TO_CPP_BOOL(src.opcode_field_w_bit));
        dest.setIsPseudoOp(FCML_TO_CPP_BOOL(src.is_pseudo_op));
        dest.setPseudoOp(src.pseudo_op);
        dest.setShortcut(FCML_TO_CPP_BOOL(src.is_shortcut));
        convert(src.modrm_details, dest.getModRmDetails());
        for (int i = 0; i < FCML_OPERANDS_COUNT; i++) {
            convert(src.operand_details[i], dest.getOperandDetails(i));
        }
        fcml_uint8_t *code = dest.getInstructionCode();
        for (int i = 0; i < FCML_INSTRUCTION_SIZE; i++) {
            code[i] = src.instruction_code[i];
        }
        convert(src.prefixes_details, dest.getPrefixesDetails());
    }

    static void convert(const InstructionDetails &src,
            fcml_st_instruction_details &dest) {
        dest.tuple_type = src.getTupleType();
        dest.addr_mode = src.getAddrMode();
        dest.instruction = src.getInstruction();
        dest.instruction_group = src.getInstructionGroup();
        dest.instruction_size = src.getInstructionSize();
        dest.opcode_field_s_bit = src.isOpcodeFieldSBit();
        dest.opcode_field_w_bit = src.isOpcodeFieldWBit();
        dest.is_pseudo_op = src.isPseudoOp();
        dest.pseudo_op = src.getPseudoOp();
        dest.is_shortcut = src.isShortcut();
        convert(src.getModRmDetails(), dest.modrm_details);
        for (int i = 0; i < FCML_OPERANDS_COUNT; i++) {
            convert(src.getOperandDetails(i), dest.operand_details[i]);
        }
        for (int i = 0; i < FCML_INSTRUCTION_SIZE; i++) {
            dest.instruction_code[i] = src.getInstructionCode()[i];
        }
        convert(src.getPrefixesDetails(), dest.prefixes_details);
    }

    static void convert(const fcml_st_disassembler_result &src,
            DisassemblerResult &dest) {
        TypeConverter::convert(src.instruction, dest.getInstructionInternal());
        convert(src.instruction_details, dest.getInstructionDetailsInternal());
    }

    static void convert(const DisassemblerResult &src,
            fcml_st_disassembler_result &dest) {
        TypeConverter::convert(src.getInstruction(), dest.instruction);
        convert(src.getInstructionDetails(), dest.instruction_details);
    }

    static void free(fcml_st_disassembler_result &src) {
        TypeConverter::free(src.instruction);
    }

};

class Disassembler: public NonCopyable, protected DialectAware {
public:

    Disassembler(Dialect &dialect) :
            _dialect(dialect) {
        fcml_ceh_error error = ::fcml_fn_disassembler_init(
                extractDialect(dialect), &_disassembler);
        if (error) {
            throw InitException(
                    FCML_TEXT("Cannot initialize the disassembler."), error);
        }
    }

    virtual ~Disassembler() {
        if (_disassembler) {
            ::fcml_fn_disassembler_free(_disassembler);
            _disassembler = NULL;
        }
    }

public:

    fcml_ceh_error disassemble(DisassemblerContext &ctx,
            DisassemblerResult &disassemblerResult) {

        fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR;

        fcml_st_disassembler_context context;
        DisassemblerTypeConverter::convert(ctx, context);

        context.disassembler = _disassembler;

        /* Prepare assembler result. */
        fcml_st_disassembler_result disassembler_result;
        ::fcml_fn_disassembler_result_prepare(&disassembler_result);

        try {

            disassemblerResult.clean();

            error = ::fcml_fn_disassemble(&context, &disassembler_result);

            ErrorContainer errorContainer;
            ErrorTypeConverter::convert(disassembler_result.errors,
                    errorContainer);

            disassemblerResult.setErrorContainer(errorContainer);

            if (error && ctx.getDisassemblerConf().isThrowExceptionOnError()) {
                ::fcml_fn_disassembler_result_free(&disassembler_result);
                throw DisassemblingFailedException(
                        FCML_TEXT("Assembling failed."), errorContainer, error);
            }

            if (!error) {

                // Convert result.
                DisassemblerTypeConverter::convert(disassembler_result,
                        disassemblerResult);

                ctx.getEntryPoint().setIP(context.entry_point.ip);
                ctx.setCode(context.code);
                ctx.setCodeLength(context.code_length);

            }

            ::fcml_fn_disassembler_result_free(&disassembler_result);

        } catch (std::exception &exc) {
            // If anything failed, free assembler results.
            ::fcml_fn_disassembler_result_free(&disassembler_result);
            throw exc;
        }

        return error;
    }

    Dialect& getDialect() const {
        return _dialect;
    }

private:

    Dialect &_dialect;
    fcml_st_disassembler *_disassembler;

};

}

#endif //FCML_DISASSEMBLER_HPP_