fcml_lag_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_LAG_ASSEMBLER_HPP_
#define FCML_LAG_ASSEMBLER_HPP_

#include "fcml_assembler.hpp"
#include "fcml_symbols.hpp"

#include "fcml_lag_assembler.h"

namespace fcml {

class MultiPassAssemblerResult {
public:

    MultiPassAssemblerResult() {
    }

    virtual ~MultiPassAssemblerResult() {
    }

public:

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

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

    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];
    }

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

    CodeIterator getCodeIterator() {
        return CodeIterator(_assembledInstructions);
    }

    void clear() {
        _errorContainer.clean();
        _assembledInstructions.clear();
    }

protected:

    friend class MultiPassAssembler;

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

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

private:

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

};

class MultiPassAssemblerContext {

public:

    MultiPassAssemblerContext() :
            _symbolTable( NULL) {
    }

    MultiPassAssemblerContext(EntryPoint::OperatingMode operatingMode,
            fcml_ip ip = 0) :
            _entryPoint(operatingMode, ip), _symbolTable( NULL) {
    }

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);
    }

    const SymbolTable* getSymbolTable() const {
        return _symbolTable;
    }

    SymbolTable* getSymbolTable() {
        return _symbolTable;
    }

    void setSymbolTable(SymbolTable *symbolTable) {
        _symbolTable = symbolTable;
    }

private:
    EntryPoint _entryPoint;
    AssemblerConf _config;
    SymbolTable *_symbolTable;
};

class MultiPassAssembler: public NonCopyable,
        protected DialectAware,
        protected SymbolTableAware {
public:

    MultiPassAssembler(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 ~MultiPassAssembler() {
        if (_assembler) {
            ::fcml_fn_assembler_free(_assembler);
            _assembler = NULL;
        }
    }

public:

    fcml_ceh_error assemble(MultiPassAssemblerContext &ctx,
            const fcml_string *instructions, MultiPassAssemblerResult &result) {

        /* Prepare assembler context. */
        fcml_st_lag_assembler_context context = { 0 };

        AssemblerTypeConverter::convert(ctx.getConfig(), context.configuration);
        TypeConverter::convert(ctx.getEntryPoint(), context.entry_point);

        SymbolTable *symbolTable = ctx.getSymbolTable();
        context.symbol_table =
                symbolTable ? extractSymbolTable(*symbolTable) : NULL;
        context.assembler = _assembler;

        /* Prepare assembler result. */
        fcml_st_lag_assembler_result res;
        ::fcml_fn_lag_assembler_result_prepare(&res);

        fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR;

        try {

            result.clear();

            error = ::fcml_fn_lag_assemble(&context, instructions, &res);

            /* 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_lag_assembler_result_free(&res);
                throw AssemblingFailedException(
                        errorContainer.prepareErrorMessage(
                                FCML_TEXT("Assembling failed")), errorContainer,
                        error);
            }

            if (!error) {

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

                assembledInstructions.clear();

                ErrorContainer instructionWarnings;
                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);
                    const AssembledInstruction assembledInstruction(
                            next_instruction->code,
                            next_instruction->code_length, instructionWarnings);
                    assembledInstructions.push_back(assembledInstruction);
                    next_instruction = next_instruction->next;
                }

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

            }

            ::fcml_fn_lag_assembler_result_free(&res);

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

        return error;
    }

private:

    // The dialect used by the assembler.
    Dialect &_dialect;
    // The initialized assembler instance used by the wrapper.
    fcml_st_assembler *_assembler;

};

}

#endif /* FCML_LAG_ASSEMBLER_HPP_ */