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>
#include <Rose/BinaryAnalysis/Partitioner2/ModulesJvm.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_;
 
    // Listing of open jar files (maybe should be Zippers with
    std::vector<ModulesJvm::Zipper*> jars_; // Zipper owns SgAsmGenericFile*, ie, Zipper{gf}, yeah, will have buffer
                                            // Zipper.find(className)
 
    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&);
 
public:
    ~EngineJvm();
 
    static Ptr instance();
 
    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;
 
    bool loadJarFile(const std::string &);
 
    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> &, std::set<std::string> &);
 
    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*);
 
    // 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*/;
    SgProject* roseFrontendReplacement(const std::vector<std::string> &fileNames);
 
    //                                  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&);
 
bool isJavaJarFile(const boost::filesystem::path&);
 
bool loadClassFile(const std::string &, const std::vector<ModulesJvm::Zipper*> &, rose_addr_t);
 
} // namespace
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif