EngineJvm.h

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

#include <Rose/BinaryAnalysis/ByteCode/Jvm.h>
#include <Rose/BinaryAnalysis/Partitioner2/Engine.h>

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

class EngineJvm: public Engine {
public:
    using Ptr = EngineJvmPtr;

  //TODO:DELETE_ME/MOVE_ME
    class Exception: public Rose::Exception {
    public:
        Exception(const std::string &mesg)
            : Rose::Exception(mesg) {}
        ~Exception() throw () {}
    };

    // Internal data structures
private:

    // Data members
private:
    // Mapping of class names to virtual address
    std::map<std::string, SgAsmGenericFile*> classes_;

    // Mapping of function names to virtual address
    std::map<std::string, rose_addr_t> functions_;

    // Mapping of unresolved (added to partitioner) function names to virtual address
    std::map<std::string, rose_addr_t> unresolvedFunctions_;

    static constexpr rose_addr_t vaDefaultIncrement{4*1024};
    rose_addr_t nextFunctionVa_;

    // Constructors
public:
    EngineJvm() = delete;
    EngineJvm(const EngineJvm&) = delete;
    EngineJvm& operator=(const EngineJvm&) = delete;

protected:
    explicit EngineJvm(const Settings &settings);

public:
    ~EngineJvm();

    static Ptr instance(const Settings&);

    static Ptr factory();

    virtual bool matchFactory(const std::vector<std::string> &specimen) const override;
    virtual EnginePtr instanceFromFactory(const Settings&) override;

    //                                  The very top-level use case
public:
    virtual SgAsmBlock* frontend(const std::vector<std::string> &args,
                                 const std::string &purpose, const std::string &description) override;
    //                                  Basic top-level steps
public:

    //                                  Command-line parsing

    virtual std::pair<std::string, std::string> specimenNameDocumentation() override;

    //                                  Container parsing
public:
    virtual SgAsmInterpretation* parseContainers(const std::vector<std::string> &fileNames) override;

    virtual bool isNonContainer(const std::string&) override;

    virtual bool areContainersParsed() const override;

    //                                  Load specimens
    //
    // top-level: loadSpecimens
public:

    virtual bool areSpecimensLoaded() const override;

    virtual MemoryMapPtr loadSpecimens(const std::vector<std::string> &fileNames = std::vector<std::string>()) override;

    rose_addr_t loadClassFile(boost::filesystem::path, SgAsmGenericFileList*, rose_addr_t);

    rose_addr_t loadSuperClasses(const std::string &, SgAsmGenericFileList*, rose_addr_t);

    rose_addr_t loadDiscoverableClasses(SgAsmGenericFileList*, rose_addr_t);

    rose_addr_t loadClass(uint16_t, SgAsmJvmConstantPool*, SgAsmGenericFileList*, rose_addr_t);

    boost::filesystem::path pathToClass(const std::string &);

    void discoverFunctionCalls(SgAsmJvmMethod*, SgAsmJvmConstantPool*, std::map<std::string,rose_addr_t> &);

    virtual PartitionerPtr partition(const std::vector<std::string> &fileNames = std::vector<std::string>()) override;

    // Disassembler
public:

    // Partitioner high-level functions
    //
    // top-level: partition
public:

    virtual void checkCreatePartitionerPrerequisites() const override;

    PartitionerPtr createJvmTunedPartitioner();

    virtual PartitionerPtr createPartitioner() override;

    virtual void runPartitionerInit(const PartitionerPtr&) override;

    virtual void runPartitionerRecursive(const PartitionerPtr&) override;

    virtual void runPartitionerFinal(const PartitionerPtr&) override;

    // Partitioner mid-level functions
    //
    // These are the functions called by the partitioner high-level stuff.  These are sometimes overridden in subclasses,
    // although it is more likely that the high-level stuff is overridden.
public:

    virtual void discoverBasicBlocks(const PartitionerPtr&, const ByteCode::Method*);

    virtual void discoverFunctions(const PartitionerPtr&, const ByteCode::Class*);

    // Partitioner low-level functions
    //
    // These are functions that a subclass seldom overrides, and maybe even shouldn't override because of their complexity or
    // the way the interact with one another.
public:

    // Build AST
public:
    virtual SgAsmBlock* buildAst(const std::vector<std::string> &fileNames = std::vector<std::string>()) override;
    //                                  Settings and properties
public:
    const std::string& isaName() const /*final*/;
    virtual void isaName(const std::string&);
    const std::vector<rose_addr_t>& functionStartingVas() const /*final*/;
    std::vector<rose_addr_t>& functionStartingVas() /*final*/;
    //                                  Internal stuff
protected:
    // Similar to ::frontend but a lot less complicated.
    virtual SgProject* roseFrontendReplacement(const std::vector<boost::filesystem::path> &fileNames) override;
};

//                                      JVM Module

namespace ModulesJvm {

bool isJavaClassFile(const boost::filesystem::path&);

} // namespace

} // namespace
} // namespace
} // namespace

#endif
#endif