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