fcml_assembler.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_ASSEMBLER_HPP_
#define FCML_ASSEMBLER_HPP_

#include <vector>
#include <ostream>

#include "fcml_assembler.h"

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

namespace fcml {

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

class AssembledInstruction {
public:

    AssembledInstruction(const fcml_uint8_t *buffer, fcml_usize len,
            const ErrorContainer &errorContainer) {
        set(buffer, len, errorContainer);
    }

    AssembledInstruction(const AssembledInstruction &cpy) {
        set(cpy._code, cpy._codeLength, cpy._warningContainer);
    }

    AssembledInstruction& operator=(const AssembledInstruction &cpy) {
        if (&cpy != this) {
            if (this->_code) {
                delete[] this->_code;
            }
            set(cpy._code, cpy._codeLength, cpy._warningContainer);
        }
        return *this;
    }

    virtual ~AssembledInstruction() {
        if (_code) {
            delete[] _code;
            _code = NULL;
        }
    }

public:

    const fcml_uint8_t* getCode() const {
        return _code;
    }

    fcml_usize getCodeLength() const {
        return _codeLength;
    }

    const ErrorContainer& getWarningContainer() const {
        return _warningContainer;
    }

private:

    void set(const fcml_uint8_t *buffer, fcml_usize len,
            const ErrorContainer warnigns) {
        _warningContainer = warnigns;
        if (len > 0) {
            _code = new fcml_uint8_t[len];
            for (fcml_usize i = 0; i < len; i++) {
                _code[i] = buffer[i];
            }
        } else {
            _code = NULL;
        }
        _codeLength = len;
    }

private:

    ErrorContainer _warningContainer;

    fcml_uint8_t *_code;

    fcml_usize _codeLength;

};

class Assembler;

class AssemblerResult {
public:

    AssemblerResult() :
            _chosenInstructionIndex(-1) {
    }

public:

    const AssembledInstruction* getChosenInstruction() const {
        if (_chosenInstructionIndex == -1) {
            return NULL;
        }
        return &(_assembledInstructions[_chosenInstructionIndex]);
    }

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

    fcml_usize getSize() const {
        return static_cast<fcml_usize>(_assembledInstructions.size());
    }

    operator const AssembledInstruction*() const {
        if (_chosenInstructionIndex == -1) {
            return NULL;
        }
        return &(_assembledInstructions[_chosenInstructionIndex]);
    }

    const AssembledInstruction& operator[](fcml_usize index) const {
        if (index > _assembledInstructions.size()) {
            throw BadArgumentException(FCML_TEXT("Array index out of bound."),
                    FCML_CEH_GEC_VALUE_OUT_OF_RANGE);
        }
        return _assembledInstructions[index];
    }

    friend std::basic_ostream<fcml_uint8_t>& operator<<(
            std::basic_ostream<fcml_uint8_t> &out,
            const AssemblerResult &result) {
        const AssembledInstruction *assembled = result.getChosenInstruction();
        if (assembled) {
            // If chosen instruction is not available, do not
            // stream anything. It's not so common, because
            // instructions choosers are obliged to chose something.
            if (assembled->getCode() && assembled->getCodeLength() > 0) {
                out.write(assembled->getCode(), assembled->getCodeLength());
            }
        }
        return out;
    }

    void clear() {
        _errorContainer.clean();
        _assembledInstructions.clear();
        _chosenInstructionIndex = -1;
    }

protected:

    friend Assembler;

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

    std::vector<AssembledInstruction>& getAssembledInstructions() {
        return _assembledInstructions;
    }

    void setChoosenInstructionIndex(fcml_int index) {
        _chosenInstructionIndex = index;
    }

private:

    ErrorContainer _errorContainer;
    std::vector<AssembledInstruction> _assembledInstructions;
    fcml_int _chosenInstructionIndex;

};

class AssemblerConf {
public:

    AssemblerConf() :
            _throwExceptionOnError(true),
            _incrementIp(true),
            _enableErrorMessages(true),
            _chooseSibEncoding(false),
            _chooseAbsEncoding(false),
            _forceRexPrefix(false),
            _forceThreeByteVEX(false),
            _noBranchPrediction(false),
            _optimizer(NULL),
            _optimizerFlags(0),
            _chooser(NULL) {
    }

public:

    bool isChooseAbsEncoding() const {
        return _chooseAbsEncoding;
    }

    void setChooseAbsEncoding(bool chooseAbsEncoding) {
        _chooseAbsEncoding = chooseAbsEncoding;
    }

    fcml_fnp_asm_instruction_chooser getChooser() const {
        return _chooser;
    }

    void setChooser(fcml_fnp_asm_instruction_chooser chooser) {
        _chooser = chooser;
    }

    bool isChooseSibEncoding() const {
        return _chooseSibEncoding;
    }

    void setChooseSibEncoding(bool chooseSibEncoding) {
        _chooseSibEncoding = chooseSibEncoding;
    }

    bool isEnableErrorMessages() const {
        return _enableErrorMessages;
    }

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

    bool isForceRexPrefix() const {
        return _forceRexPrefix;
    }

    void setForceRexPrefix(bool forceRexPrefix) {
        _forceRexPrefix = forceRexPrefix;
    }

    bool isForceThreeByteVex() const {
        return _forceThreeByteVEX;
    }

    void setForceThreeByteVex(bool forceThreeByteVex) {
        _forceThreeByteVEX = forceThreeByteVex;
    }

    bool isIncrementIp() const {
        return _incrementIp;
    }

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

    fcml_fnp_asm_optimizer getOptimizer() const {
        return _optimizer;
    }

    void setOptimizer(fcml_fnp_asm_optimizer optimizer) {
        _optimizer = optimizer;
    }

    fcml_uint16_t getOptimizerFlags() const {
        return _optimizerFlags;
    }

    void setOptimizerFlags(fcml_uint16_t optimizerFlags) {
        _optimizerFlags = optimizerFlags;
    }

    bool isThrowExceptionOnError() const {
        return _throwExceptionOnError;
    }

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

private:
    bool _throwExceptionOnError;
    bool _incrementIp;
    bool _enableErrorMessages;
    bool _chooseSibEncoding;
    bool _chooseAbsEncoding;
    bool _forceRexPrefix;
    bool _forceThreeByteVEX;
    bool _noBranchPrediction;
    fcml_fnp_asm_optimizer _optimizer;
    fcml_uint16_t _optimizerFlags;
    fcml_fnp_asm_instruction_chooser _chooser;
};

class AssemblerContext {

public:

    AssemblerContext() {
    }

    AssemblerContext(EntryPoint::OperatingMode operatingMode, fcml_ip ip = 0) :
            _entryPoint(operatingMode, ip) {
    }

public:

    const AssemblerConf& getConfig() const {
        return _config;
    }

    AssemblerConf& getConfig() {
        return _config;
    }

    void setConfig(const AssemblerConf &config) {
        _config = config;
    }

    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:

    EntryPoint _entryPoint;
    AssemblerConf _config;

};

class AssemblerTypeConverter {
public:

    static void convert(const fcml_st_assembler_context &src,
            AssemblerContext &dest) {
        // Converts assembler configuration and entry point.
        // Both of them have dedicated conversion methods.
        convert(src.configuration, dest.getConfig());
        TypeConverter::convert(src.entry_point, dest.getEntryPoint());
    }

    static void convert(const AssemblerContext &src,
            fcml_st_assembler_context &dest) {
        // Converts assembler configuration and entry point. Both of them
        // have dedicated conversion methods.
        convert(src.getConfig(), dest.configuration);
        TypeConverter::convert(src.getEntryPoint(), dest.entry_point);
    }

    static void convert(const fcml_st_assembler_conf &src,
            AssemblerConf &dest) {
        dest.setChooseAbsEncoding(FCML_TO_CPP_BOOL(src.choose_abs_encoding));
        dest.setChooseSibEncoding(FCML_TO_CPP_BOOL(src.choose_sib_encoding));
        dest.setChooser(src.chooser);
        dest.setEnableErrorMessages(
                FCML_TO_CPP_BOOL(src.enable_error_messages));
        dest.setForceRexPrefix(FCML_TO_CPP_BOOL(src.force_rex_prefix));
        dest.setForceThreeByteVex(FCML_TO_CPP_BOOL(src.force_three_byte_VEX));
        dest.setIncrementIp(FCML_TO_CPP_BOOL(src.increment_ip));
        dest.setOptimizer(src.optimizer);
        dest.setOptimizerFlags(src.optimizer_flags);
    }

    static void convert(const AssemblerConf &src,
            fcml_st_assembler_conf &dest) {
        dest.choose_abs_encoding = src.isChooseAbsEncoding();
        dest.choose_sib_encoding = src.isChooseSibEncoding();
        dest.chooser = src.getChooser();
        dest.enable_error_messages = src.isEnableErrorMessages();
        dest.force_rex_prefix = src.isForceRexPrefix();
        dest.force_three_byte_VEX = src.isForceThreeByteVex();
        dest.increment_ip = src.isIncrementIp();
        dest.optimizer = src.getOptimizer();
        dest.optimizer_flags = src.getOptimizerFlags();
    }

};

class Assembler: public NonCopyable, protected DialectAware {
public:

    Assembler(Dialect &dialect) :
            _dialect(dialect) {
        fcml_ceh_error error = ::fcml_fn_assembler_init(extractDialect(dialect),
                &_assembler);
        if (error) {
            throw InitException(FCML_TEXT("Cannot initialize the assembler."),
                    error);
        }
    }

    virtual ~Assembler() {
        if (_assembler) {
            ::fcml_fn_assembler_free(_assembler);
            _assembler = NULL;
        }
    }

public:

    fcml_ceh_error assemble(AssemblerContext &ctx,
            const Instruction &instruction, AssemblerResult &result) {

        // Prepare assembler context.
        fcml_st_assembler_context context;
        AssemblerTypeConverter::convert(ctx, context);

        context.assembler = _assembler;

        // Prepare instruction.
        fcml_st_instruction inst;
        TypeConverter::convert(instruction, inst);

        // Prepare assembler result.
        fcml_st_assembler_result res;
        ::fcml_fn_assembler_result_prepare(&res);

        fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR;

        try {

            result.clear();

            error = ::fcml_fn_assemble(&context, &inst, &res);

            // Free instruction mnemonic.
            TypeConverter::free(inst);

            // Failed or not, convert assembler errors.
            ErrorContainer errorContainer;
            ErrorTypeConverter::convert(res.errors, errorContainer);

            // Prepares assembler result.
            result.setErrorContainer(errorContainer);

            if (error && ctx.getConfig().isThrowExceptionOnError()) {
                ::fcml_fn_assembler_result_free(&res);
                throw AssemblingFailedException(FCML_TEXT("Assembling failed."),
                        errorContainer, error);
            }

            if (!error) {

                std::vector<AssembledInstruction> &assembledInstructions =
                        result.getAssembledInstructions();

                assembledInstructions.clear();

                if (res.number_of_instructions > 0) {
                    ErrorContainer instructionWarnings;
                    fcml_int i = 0;
                    fcml_st_assembled_instruction *next_instruction =
                            res.instructions;
                    while (next_instruction) {
                        fcml_st_ceh_error_container &instruction_warnings =
                                next_instruction->warnings;
                        ErrorTypeConverter::convert(instruction_warnings,
                                instructionWarnings);
                        AssembledInstruction assembledInstruction(
                                next_instruction->code,
                                next_instruction->code_length,
                                instructionWarnings);
                        assembledInstructions.push_back(assembledInstruction);
                        if (next_instruction == res.chosen_instruction) {
                            result.setChoosenInstructionIndex(i);
                        }
                        next_instruction = next_instruction->next;
                        i++;
                    }
                }

                // Convert it back to the context because it might have been
                // modified during assembling process (IP incrementing etc).
                TypeConverter::convert(context.entry_point,
                        ctx.getEntryPoint());

            }

            ::fcml_fn_assembler_result_free(&res);

        } catch (std::exception &exc) {
            // If anything failed, free assembler results.
            TypeConverter::free(inst);
            ::fcml_fn_assembler_result_free(&res);
            throw exc;
        }

        return error;
    }

    Dialect& getDialect() const {
        return _dialect;
    }

private:

    // A dialect used by the assembler.
    Dialect &_dialect;

    // An initialized assembler instance.
    fcml_st_assembler *_assembler;

};

class CodeIterator: public Iterator<fcml_uint8_t> {
public:

    CodeIterator(std::vector<AssembledInstruction> &assembledInstructions) :
            _buffer(NULL), _len(0), _pos(0), _iterator(
                    assembledInstructions.begin()), _assembledInstructions(
                    assembledInstructions) {
    }

    virtual ~CodeIterator() {
    }

    bool hasNext() {
        if (_buffer && _pos >= _len) {
            _buffer = NULL;
        }
        if (!_buffer) {
            if (_iterator == _assembledInstructions.end()) {
                return false;
            }
            AssembledInstruction &current = *_iterator++;
            _buffer = current.getCode();
            _len = current.getCodeLength();
            _pos = 0;
        }
        return true;
    }

    fcml_uint8_t next() {
        if ((!_buffer || _pos >= _len) && !hasNext()) {
            throw IllegalStateException(
                    FCML_TEXT("No more elements in the iterator."));
        }
        return _buffer[_pos++];
    }

private:

    const fcml_uint8_t *_buffer;
    fcml_usize _len;
    fcml_usize _pos;
    std::vector<AssembledInstruction>::iterator _iterator;
    std::vector<AssembledInstruction> &_assembledInstructions;

};

}

#endif //FCML_ASSEMBLER_HPP_