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/CommandLine.h>
#include <Sawyer/Database.h>
#include <Sawyer/Message.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:
        Address 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(Address 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(Address address, const std::string &name, const std::string &demangledName, const std::string &hash,
                            size_t nInsns, const Library::Ptr &library);
 
        static Ptr instance(Address 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:
        Address 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