fcml_stateful_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_STATEFUL_ASSEMBLER_HPP_
#define FCML_STATEFUL_ASSEMBLER_HPP_

#include <vector>

#include "fcml_assembler.hpp"
#include "fcml_parser.hpp"

namespace fcml {

class StatefulAssembler {
public:

    class SAFlush {
    };

    StatefulAssembler(Assembler &assembler, AssemblerContext &context,
            bool enableParser = false) :
            _instructionBuilder(IB(FCML_TEXT("")), false),
            _assembler(assembler),
            _context(context),
            _codeLength(0) {
        // Create parser if needed.
        _parser = enableParser ? new Parser(assembler.getDialect()) : NULL;
    }

    virtual ~StatefulAssembler() {
        if (_parser) {
            delete _parser;
        }
    }

    StatefulAssembler& operator <<(const IB &ib) {
        return add(ib);
    }

    StatefulAssembler& add(const IB &ib) {
        flush();
        _instructionBuilder.setNotNull(true);
        _instructionBuilder.setValue(ib);
        return *this;
    }

    StatefulAssembler& operator <<(const fcml_cstring &mnemonic) {
        return inst(mnemonic);
    }

    StatefulAssembler& inst(const fcml_cstring &mnemonic) {
        flush();
        if (_parser) {
            // Parse instruction and then pass it to the assembler.
            _parserContext.setIp(_context.getEntryPoint().getIP());
            ParserConfig &config = _parserContext.getConfig();
            config.setThrowExceptionOnError(true);
            _parser->parse(_parserContext, mnemonic, _parserResult);
            *this << _parserResult.getInstruction();
        } else {
            // Parser is not available, so treat this string as a full
            // instruction which have to be parsed.
            _instructionBuilder.setNotNull(true);
            _instructionBuilder.setValue(IB(mnemonic));
        }
        return *this;
    }

    StatefulAssembler& operator <<(const Register &reg) {
        return op(Operand(reg));
    }

    StatefulAssembler& operator <<(const Integer &imm) {
        return op(Operand(imm));
    }

    StatefulAssembler& operator <<(const Address &address) {
        return op(Operand(address));
    }

    StatefulAssembler& operator <<(const FarPointer &pointer) {
        return op(Operand(pointer));
    }

    StatefulAssembler& operator <<(const Operand &operand) {
        return op(operand);
    }

    StatefulAssembler& op(const Operand &operand) {
        if (!_instructionBuilder.isNotNull()) {
            throw IllegalStateException(
                    FCML_TEXT("No instruction builder available."));
        }
        IB &ib = _instructionBuilder.getValue();
        ib.op(operand);
        return *this;
    }

    StatefulAssembler& op(const Register &reg) {
        return op(Operand(reg));
    }

    StatefulAssembler& op(const Integer &imm) {
        return op(Operand(imm));
    }

    StatefulAssembler& op(const Address &address) {
        return op(Operand(address));
    }

    StatefulAssembler& op(const FarPointer &pointer) {
        return op(Operand(pointer));
    }

    StatefulAssembler& operator <<(const SAFlush &indic) {
        flush();
        return *this;
    }

    StatefulAssembler& operator <<(const Instruction &instruction) {
        return inst(instruction);
    }

    StatefulAssembler& operator <<(const InstructionPrefix &prefix) {
        return set(prefix);
    }

    StatefulAssembler& operator <<(const InstructionHint &hint) {
        return set(hint);
    }

    StatefulAssembler& operator <<(const OperandHint &hint) {
        return set(hint);
    }

    StatefulAssembler& set(const InstructionPrefix &prefix) {
        if (!_instructionBuilder.isNotNull()) {
            throw IllegalStateException(
                    FCML_TEXT("No instruction builder available."));
        }
        _instructionBuilder.getValue() << prefix;
        return *this;
    }

    StatefulAssembler& set(const InstructionHint &hint) {
        if (!_instructionBuilder.isNotNull()) {
            throw IllegalStateException(
                    FCML_TEXT("No instruction builder available."));
        }
        _instructionBuilder.getValue() << hint;
        return *this;
    }

    StatefulAssembler& set(const OperandHint &hint) {
        if (!_instructionBuilder.isNotNull()) {
            throw IllegalStateException(
                    FCML_TEXT("No instruction builder available."));
        }
        _instructionBuilder.getValue() << hint;
        return *this;
    }

    StatefulAssembler& inst(const Instruction &instruction) {

        // Flush pending instruction if there is any.
        flush();

        // Just in case.
        AssemblerConf &config = _context.getConfig();
        config.setIncrementIp(true);
        config.setThrowExceptionOnError(true);

        // Assembler the instruction.
        _assembler.assemble(_context, instruction, _result);

        // Store the chosen assembled instruction for future use.
        const AssembledInstruction *assembledInstruction =
                _result.getChosenInstruction();
        if (assembledInstruction) {
            _assembledInstructions.push_back(*assembledInstruction);
            _codeLength += assembledInstruction->getCodeLength();
        } else {
            throw AssemblingFailedException(
                    FCML_TEXT("Chosen instruction hasn't been set. It seems "
                            "that the instruction chooser isn't working "
                            "correctly."));
        }

        return *this;
    }

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

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

    fcml_usize getCodeLength() {
        flush();
        return _codeLength;
    }

    void flush() {
        if (_instructionBuilder.isNotNull()) {
            // Build an instruction using the instruction builder.
            Instruction instruction = _instructionBuilder.getValue().build();
            // And clean the builder, is everything succeed.
            _instructionBuilder.setNotNull(false);
            // Assemble the instruction.
            *this << instruction;
        }
    }

    static SAFlush FLUSH() {
        return SAFlush();
    }

    const ParserConfig& getParserConfig() const {
        return _parserContext.getConfig();
    }

    ParserConfig& getParserConfig() {
        return _parserContext.getConfig();
    }

    const SymbolTable* getSymbolTable() const {
        return _parserContext.getSymbolTable();
    }

    SymbolTable* getSymbolTable() {
        return _parserContext.getSymbolTable();
    }

    void setSymbolTable(SymbolTable *symbolTable) {
        _parserContext.setSymbolTable(symbolTable);
    }

private:

    Parser *_parser;
    ParserResult _parserResult;
    ParserContext _parserContext;
    AssemblerResult _result;
    Nullable<IB> _instructionBuilder;
    /* Assembler used to assemble code. */
    Assembler &_assembler;
    AssemblerContext &_context;
    // Assembled instructions.
    std::vector<AssembledInstruction> _assembledInstructions;
    fcml_usize _codeLength;

};

}

#endif /* FCML_STATEFUL_ASSEMBLER_HPP_ */