BinaryToSource.h

#ifndef ROSE_BinaryAnalysis_BinaryToSource_H
#define ROSE_BinaryAnalysis_BinaryToSource_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Diagnostics.h>
#include <Partitioner2/Partitioner.h>
#include <RoseException.h>
#include <Sawyer/CommandLine.h>
#include <SourceAstSemantics2.h>
#include <TraceSemantics2.h>

namespace Rose {
namespace BinaryAnalysis {

class BinaryToSource {
public:

    struct Settings {
        bool traceRiscOps;

        bool traceInsnExecution;

        Sawyer::Optional<rose_addr_t> initialInstructionPointer;

        Sawyer::Optional<rose_addr_t> initialStackPointer;

        Sawyer::Optional<rose_addr_t> allocateMemoryArray;

        bool zeroMemoryArray;

        Settings()
            : traceRiscOps(false), traceInsnExecution(false), allocateMemoryArray(false), zeroMemoryArray(false) {}
    };

    class Exception: public Rose::Exception {
    public:
        Exception(const std::string &mesg): Rose::Exception(mesg) {}
    };

private:
    static Diagnostics::Facility mlog;
    Settings settings_;
    Disassembler *disassembler_;
    InstructionSemantics2::SourceAstSemantics::RiscOperatorsPtr raisingOps_;
    InstructionSemantics2::TraceSemantics::RiscOperatorsPtr tracingOps_;
    InstructionSemantics2::BaseSemantics::DispatcherPtr raisingCpu_;
    
public:
    BinaryToSource()
        : disassembler_(NULL) {}

    explicit BinaryToSource(const Settings &settings)
        : settings_(settings), disassembler_(NULL) {}

    static Sawyer::CommandLine::SwitchGroup commandLineSwitches(Settings&);

    static void initDiagnostics();

    const Settings& settings() const { return settings_; }

    void generateSource(const Partitioner2::Partitioner&, std::ostream&);

#if 0 // [Robb P. Matzke 2015-10-06]: not implemented yet

    void generateSource(const Partitioner2::Partitioner&, SgSourceFile *sourceAst);
#endif

private:
    // (Re)initialize the instruction semantics machinery so it is suitable for this architecture.
    void init(const Partitioner2::Partitioner&);

    // Emit the file prologue, #include statements, extern declarations, etc.
    void emitFilePrologue(const Partitioner2::Partitioner&, std::ostream&);

    // Declare the global register variables
    void declareGlobalRegisters(std::ostream&);

    // Define interrupt handlers
    void defineInterrupts(std::ostream&);

    // Emit accumulated side effects and/or SSA. */
    void emitEffects(std::ostream&);

    // Emit code for one instruction
    void emitInstruction(SgAsmInstruction*, std::ostream&);

    // Emit code for one basic block
    void emitBasicBlock(const Partitioner2::Partitioner&, const Partitioner2::BasicBlock::Ptr&, std::ostream&);

    // Emit code for one function
    void emitFunction(const Partitioner2::Partitioner&, const Partitioner2::Function::Ptr&, std::ostream&);

    // Emit code for all functions
    void emitAllFunctions(const Partitioner2::Partitioner&, std::ostream&);

    // Emit the function_call dispatcher that decides which C function should be called next.
    void emitFunctionDispatcher(const Partitioner2::Partitioner&, std::ostream&);

    // Emit the initialize_memory function.
    void emitMemoryInitialization(const Partitioner2::Partitioner&, std::ostream&);

    // Emit the "main" function.
    void emitMain(const Partitioner2::Partitioner&, std::ostream&);
};

} // namespace
} // namespace

#endif
#endif