ToSource.h

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

#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/SourceAstSemantics.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/TraceSemantics.h>
#include <Rose/Diagnostics.h>
#include <Rose/Exception.h>

#include <Sawyer/CommandLine.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::BasePtr disassembler_;
    InstructionSemantics::SourceAstSemantics::RiscOperatorsPtr raisingOps_;
    InstructionSemantics::TraceSemantics::RiscOperatorsPtr tracingOps_;
    InstructionSemantics::BaseSemantics::DispatcherPtr raisingCpu_;
    
public:
    BinaryToSource();

    explicit BinaryToSource(const Settings&);

    ~BinaryToSource();

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

    static void initDiagnostics();

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

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

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

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

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

    // Emit the file prologue, #include statements, extern declarations, etc.
    void emitFilePrologue(const Partitioner2::PartitionerConstPtr&, 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::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&, std::ostream&);

    // Emit code for one function
    void emitFunction(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&, std::ostream&);

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

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

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

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

} // namespace
} // namespace

#endif
#endif