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 {
    //                                  Types
public:
    using Ptr = EngineJvmPtr;
 
private:
    using Super = Engine;
 
    // 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, Address> functions_;
 
    // Mapping of unresolved (added to partitioner) function names to virtual address
    std::map<std::string, Address> 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 Address vaDefaultIncrement{4*1024};
    Address 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();
 
    //                                  Overrides documented in the base class
public:
    virtual bool matchFactory(const std::vector<std::string> &specimen) const override;
    virtual EnginePtr instanceFromFactory(const Settings&) override;
 
    virtual std::list<Sawyer::CommandLine::SwitchGroup> commandLineSwitches() override;
    virtual std::pair<std::string, std::string> specimenNameDocumentation() 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
 
    //                                  Command-line parsing
public:
 
    static Sawyer::CommandLine::SwitchGroup engineSwitches(EngineSettings&);
 
    // Flag to load all classes in jar files listed on the command line
    static bool loadAllClasses;
 
    //                                  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 &);
 
    Address loadClassFile(boost::filesystem::path, SgAsmGenericFileList*, Address);
 
    Address loadSuperClasses(const std::string &, SgAsmGenericFileList*, Address);
 
    Address loadDiscoverableClasses(SgAsmGenericFileList*, Address);
 
    Address loadClass(uint16_t, SgAsmJvmConstantPool*, SgAsmGenericFileList*, Address);
 
    boost::filesystem::path pathToClass(const std::string &);
 
    void discoverFunctionCalls(SgAsmJvmMethod*, SgAsmJvmConstantPool*, std::map<std::string,Address> &, 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<Address>& functionStartingVas() const /*final*/;
    std::vector<Address>& 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;
};
class EngineJvm: public Engine {…};
 
//                                      JVM Module
 
namespace ModulesJvm {
 
bool isJavaClassFile(const boost::filesystem::path&);
 
bool isJavaJarFile(const boost::filesystem::path&);
 
} // namespace ModulesJvm
namespace ModulesJvm {…}
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif