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>
 
#include <Sawyer/ProgressBar.h>
 
#include <memory>
#include <utility>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
class EngineJvm: public Engine {
    //                                  Types
public:
    using Ptr = EngineJvmPtr;
 
    using Super = Engine;
 
    // Data members
private:
    struct ArchiveProgress {
        enum class Kind { JAR, WAR };
 
        Kind kind = Kind::JAR;
        ModulesJvm::Zipper *parentWar = nullptr;
        size_t nClassFiles = 0;
        size_t nClassesHandled = 0;
        size_t nJarFiles = 0;
        size_t nJarsHandled = 0;
        std::vector<ModulesJvm::Zipper*> childJars;
        std::unique_ptr<Sawyer::ProgressBar<size_t>> classProgressBar;
        std::unique_ptr<Sawyer::ProgressBar<size_t>> jarProgressBar;
    };
 
    // 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)
 
    // Multi-release JAR handling currently chooses the highest META-INF/versions/N class present in an archive instead of
    // selecting for a configured Java runtime version. This differs from JVM semantics, but keeps eagerly loaded specimens
    // self-consistent until runtime-version selection is exposed.
    std::map<ModulesJvm::Zipper*, std::map<std::string, std::string>> archivePreferredClassFiles_;
 
    // Progress totals for loaded zip containers.
    std::map<ModulesJvm::Zipper*, ArchiveProgress> archiveProgress_;
 
    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:
    bool matchFactory(const Sawyer::CommandLine::ParserResult &result, const std::vector<std::string> &specimen) const override;
 
    EnginePtr instanceFromFactory(const Settings&) override;
 
    std::list<Sawyer::CommandLine::SwitchGroup> commandLineSwitches() override;
    std::pair<std::string, std::string> specimenNameDocumentation() override;
 
    static Ptr promote(const Engine::Ptr&);
 
    //                                  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:
    virtual void checkSettings() override;
 
    static Sawyer::CommandLine::SwitchGroup jvmSwitches(JvmSettings&);
 
    //                                  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 loadWarFile(const std::string &);
 
    bool loadJarFile(const std::string &);
 
    bool loadJarFile(const std::string &, ModulesJvm::Zipper* zip);
 
    Address loadClassFile(boost::filesystem::path, SgAsmGenericFileList*, Address);
 
    Address loadBaseClassAndInterfaces(const std::string &, SgAsmGenericFileList*, Address);
 
    Address loadDiscoverableClasses(SgAsmGenericFileList*, Address);
 
    Address loadClass(uint16_t, SgAsmJvmConstantPool*, SgAsmGenericFileList*, Address);
 
    boost::filesystem::path pathToClass(const std::string &fqcn);
 
    void discoverFunctionCalls(SgAsmJvmMethod*, SgAsmJvmConstantPool*, std::map<std::string,Address> &, std::set<std::string> &);
 
private:
    void registerWarProgress(ModulesJvm::Zipper*);
    void registerJarProgress(ModulesJvm::Zipper*, ModulesJvm::Zipper *parentWar = nullptr);
    const std::map<std::string, std::string>& preferredArchiveClassFiles(ModulesJvm::Zipper*);
    Address loadArchiveClassFiles(ModulesJvm::Zipper*, SgAsmGenericFileList*, Address);
    void beginArchiveClassProgress(ModulesJvm::Zipper*);
    void beginWarJarProgress(ModulesJvm::Zipper*);
    void noteWarJarHandled(ModulesJvm::Zipper*);
    void noteArchiveClassHandled(ModulesJvm::Zipper*);
    void updateLoaderProgress(size_t current, size_t total) const;
    void createClassProgressBar(ArchiveProgress&, const std::string&) const;
    void createJarProgressBar(ArchiveProgress&, const std::string&) const;
 
public:
    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:
 
    // 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::vector<std::string>& classPath() const;
 
    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);
 
    Architecture::BaseConstPtr obtainArchitecture() override;
 
    //                                  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 isJavaWarFile(const boost::filesystem::path&);
 
boost::filesystem::path pathToClassFile(const std::string &fqcn, const std::vector<std::string> &cp);
 
bool present(const std::string &fqcn, const std::string &path);
 
} // namespace ModulesJvm
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif