LibraryIdentification.h

#ifndef ROSE_BinaryAnalysis_LibraryIdentification_H
#define ROSE_BinaryAnalysis_LibraryIdentification_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_LIBRARY_IDENTIFICATION

#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>

#include <Sawyer/Database.h>
#include <Sawyer/SharedObject.h>
#include <Sawyer/SharedPointer.h>
#include <ctime>
#include <regex>
#include <string>
#include <vector>

namespace Rose {
namespace BinaryAnalysis {

class LibraryIdentification {
    // Settings
public:
    struct Settings {
        Sawyer::Container::Set<std::string> includeNames;

        std::vector<std::regex> includeRes;

        boost::filesystem::path includeFile;

        Sawyer::Container::Set<std::string> excludeNames;

        std::vector<std::regex> excludeRes;

        boost::filesystem::path excludeFile;

        size_t minFunctionInsns = 0;

        bool identifyFunctionsByHash = false;
    };

    // Libraries
public:
    class Library: public Sawyer::SharedObject {
    public:
        using Ptr = Sawyer::SharedPointer<Library>;

    private:
        std::string hash_;                              // required unique key for library
        std::string name_;                              // required name of library
        std::string version_;                           // optional version of library
        std::string architecture_;                      // optional architecture string
        time_t ctime_ = 0;                              // Unix time at which this object was created; zero if unknown
        std::string cversion_;                          // ROSE version which created this object; empty if unknown

    protected:
        Library(const std::string &hash, const std::string &name, const std::string &version, const std::string &architecture,
                time_t ctime, const std::string &cversion);

    public:
        static Ptr instance(const std::string &hash, const std::string &name, const std::string &version,
                            const std::string &architecture);

        static Ptr instance(const std::string &hash, const std::string &name, const std::string &version,
                            const std::string &architecture, time_t creationTime, const std::string &creationVersion);

    public:
        const std::string& hash() const;

        const std::string& name() const;

        const std::string& version() const;

        const std::string& architecture() const;

        time_t creationTime() const;

        const std::string& creationVersion() const;
    };

    // Functions
public:
    class Function: public Sawyer::SharedObject {
    public:
        using Ptr = Sawyer::SharedPointer<Function>;

    private:
        rose_addr_t address_;                           // required starting address that identifies function in library
        std::string name_;                              // optional name of function (possibly mangled)
        std::string demangledName_;                     // optional demangled name of function
        std::string hash_;                              // hash used for matching
        size_t nInsns_;                                 // number of instructions in function
        Library::Ptr library_;                          // library to which function belongs
        time_t ctime_ = 0;                              // time at which this object was created; zero if unknown
        std::string cversion_;                          // ROSE version that created this object; empty if unknown

    protected:
        Function(rose_addr_t address, const std::string &name, const std::string &demangledName, const std::string &hash,
                 size_t nInsns, time_t ctime, const std::string &cversion, const Library::Ptr &library);

    public:
        static Ptr instance(rose_addr_t address, const std::string &name, const std::string &demangledName,
                            const std::string &hash, size_t nInsns, const Library::Ptr &library);

        static Ptr instance(rose_addr_t address, const std::string &name, const std::string &demangledName,
                            const std::string &hash, size_t nInsns, time_t creationTime, const std::string &creationVersion,
                            const Library::Ptr &library);

    public:
        rose_addr_t address() const;

        const std::string& name() const;

        const std::string& demangledName() const;

        const std::string& hash() const;

        size_t nInsns() const;

        Library::Ptr library() const;

        time_t creationTime() const;

        const std::string& creationVersion() const;
    };

    // Data members
public:
    static Sawyer::Message::Facility mlog;              // diagnostic facility for debugger
private:
    Settings settings_;
    std::string databaseUrl_;                           // name of database to which this object is communicating
    Sawyer::Database::Connection db_;                   // the database, when connected

    // Cached info from the settings_.includeFile and settings_.excludeFile
    boost::filesystem::path cachedIncludeFile_;
    Sawyer::Container::Set<std::string> cachedIncludeNames_;
    boost::filesystem::path cachedExcludeFile_;
    Sawyer::Container::Set<std::string> cachedExcludeNames_;

    using LibraryCache = Sawyer::Container::Map<std::string /*hash*/, Library::Ptr>;
    LibraryCache libraryCache_;                         // cache of library objects read from or written to database

    // Configuration settings
public:
    const Settings& settings() const;
    Settings& settings();
    void settings(const Settings&);
    static Sawyer::CommandLine::SwitchGroup commandLineSwitches(Settings&);

    // Functions for attaching to the database.
public:
    void connect(const std::string &databaseUrl);

    void createDatabase(const std::string &databaseUrl);

    // Functions that modify a database.
public:
    Function::Ptr insertFunction(const Library::Ptr&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&);
    bool insertFunction(const Function::Ptr&);
    size_t insertLibrary(const Library::Ptr&, const Partitioner2::PartitionerConstPtr&);

    // Functions for querying a database.
public:
    Library::Ptr library(const std::string &hash);

    std::vector<Library::Ptr> libraries();

    std::vector<Function::Ptr> functions();
    std::vector<Function::Ptr> functions(const Library::Ptr&);
    std::vector<Function::Ptr> search(const Partitioner2::PartitionerConstPtr &partitioner, const Partitioner2::FunctionPtr&);

    // Utilities
public:
    static void initDiagnostics();

    std::string hash(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&) const;

    static size_t nInsns(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&);

private:
    // Throws an Exception if the database driver version is not adequate.
    void checkVersion();

    // Returns the database version number if there is one.
    Sawyer::Optional<unsigned> version();

    // Create the tables needed by a new database.
    void createTables();

    // Upgrade the database to the current version
    void upgradeDatabase();

    // Create or update the properties of a library in the database.
    void createLibrary(const Library::Ptr&);

    // Create or update the properties of a function in the database. It is not possible to update the address or library
    // to which a function belongs with this call since those properties are what identifies the function -- attempting to
    // change them simply creates a new function record without deleting the old one.
    void createFunction(const Function::Ptr&);

    // Whether the current settings specifically include this function from consideration. Exactly one of f1 or f2 should be
    // non-null.
    bool isIncluded(const Function::Ptr&);
    bool isIncluded(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&);

    // Whether the current settings exclude a function from consideration. Exactly one of f1 or f2 should be non-null.
    bool isExcluded(const Function::Ptr&);
    bool isExcluded(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&);

    // Whether to consider a function for insertion into a database or as a possible match of a database function to a
    // non-database function.
    bool isConsidered(const Function::Ptr&);
    bool isConsidered(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&);

    // Load function names from files if necessary.
    void cacheFiles();
    void cacheNamesFromFile(const boost::filesystem::path &fileName, boost::filesystem::path &cachedFileName /*in,out*/,
                            Sawyer::Container::Set<std::string> &cachedNames /*out*/);

    // Return functions based on query.
    std::vector<Function::Ptr> functions(Sawyer::Database::Statement);
};

} // namespace
} // namespace

#endif
#endif