Rose/BinaryAnalysis/Concolic/Database.h

#ifndef ROSE_BinaryAnalysis_Concolic_Database_H
#define ROSE_BinaryAnalysis_Concolic_Database_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/Constants.h>
#include <rose_strtoull.h>
 
#include <Sawyer/BiMap.h>
#include <Sawyer/Database.h>
#include <Sawyer/Optional.h>
 
#include <boost/numeric/conversion/cast.hpp>
 
#include <ctype.h>
#include <string>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {
 
class Database: public Sawyer::SharedObject, public Sawyer::SharedFromThis<Database>, boost::noncopyable {
public:
    typedef Sawyer::SharedPointer<Database> Ptr;
    
private:
    Sawyer::Database::Connection connection_;
 
    // Memoization of ID to object mappings
    Sawyer::Container::BiMap<SpecimenId, SpecimenPtr> specimens_;
    Sawyer::Container::BiMap<TestCaseId, TestCasePtr> testCases_;
    Sawyer::Container::BiMap<TestSuiteId, TestSuitePtr> testSuites_;
    Sawyer::Container::BiMap<ExecutionEventId, ExecutionEventPtr> executionEvents_;
 
    TestSuiteId testSuiteId_;                           // database scope is restricted to this single test suite
 
protected:
    Database();
 
public:
    ~Database();
 
    static Ptr instance(const std::string &url);
 
    Sawyer::Database::Connection connection() {
        return connection_;
    }
 
    static Ptr create(const std::string &url);
    static Ptr create(const std::string &url, const std::string &testSuiteName);
    //------------------------------------------------------------------------------------------------------------------------
    // Test suites
    //------------------------------------------------------------------------------------------------------------------------
 
    std::vector<TestSuiteId> testSuites();
 
    TestSuitePtr testSuite();
    TestSuiteId testSuite(const TestSuitePtr&);
    //------------------------------------------------------------------------------------------------------------------------
    // Specimens
    //------------------------------------------------------------------------------------------------------------------------
 
    std::vector<SpecimenId> specimens();
 
    std::vector<SpecimenId> specimens(TestSuiteId);
 
    void eraseSpecimens(TestSuiteId);
 
    //------------------------------------------------------------------------------------------------------------------------
    // Test cases
    //------------------------------------------------------------------------------------------------------------------------
 
    std::vector<TestCaseId> testCases();
 
    std::vector<TestCaseId> testCases(SpecimenId);
 
    void eraseTestCases(SpecimenId);
 
    //------------------------------------------------------------------------------------------------------------------------
    // Execution events
    //------------------------------------------------------------------------------------------------------------------------
 
    std::vector<ExecutionEventId> executionEvents();
 
    std::vector<ExecutionEventId> executionEvents(TestCaseId);
 
    size_t nExecutionEvents(TestCaseId);
 
    std::vector<ExecutionEventId> executionEvents(TestCaseId, uint64_t primaryKey);
 
    std::vector<ExecutionEventId> executionEventsSince(TestCaseId, ExecutionEventId startingAt);
 
    std::vector<uint64_t> executionEventKeyFrames(TestCaseId);
 
    void eraseExecutionEvents(TestCaseId);
 
    //------------------------------------------------------------------------------------------------------------------------
    // Overloaded methods for all objects.
    //------------------------------------------------------------------------------------------------------------------------
 
    TestSuitePtr object(TestSuiteId, Update update = Update::YES);
    TestCasePtr object(TestCaseId, Update update = Update::YES);
    SpecimenPtr object(SpecimenId, Update update = Update::YES);
    ExecutionEventPtr object(ExecutionEventId, Update update = Update::YES);
    TestSuiteId id(const TestSuitePtr&, Update update = Update::YES);
    TestCaseId id(const TestCasePtr&, Update update = Update::YES);
    SpecimenId id(const SpecimenPtr&, Update update = Update::YES);
    ExecutionEventId id(const ExecutionEventPtr&, Update update = Update::YES);
    TestSuiteId erase(TestSuiteId);
    TestCaseId erase(TestCaseId);
    SpecimenId erase(SpecimenId);
    ExecutionEventId erase(ExecutionEventId);
    template<class ObjectPointer>
    typename ObjectTraits<typename ObjectPointer::Pointee>::Id
    save(const ObjectPointer &obj) {
        return id(obj);
    }
 
    template<class ObjectPointer>
    void save(const std::vector<ObjectPointer> &objects) {
        for (auto object: objects)
            save(object);
    }
 
    template<class Id>
    std::vector<typename Id::Pointer>
    objects(const std::vector<Id> &ids, Update update = Update::YES) {
        std::vector<typename Id::Pointer> retval;
        for (auto id: ids)
            retval.push_back(object(id, update));
        return retval;
    }
 
    template<class ObjectPointer>
    std::vector<typename ObjectTraits<ObjectPointer>::Id>
    ids(const std::vector<ObjectPointer> &objects, Update update = Update::YES) {
        std::vector<typename ObjectTraits<ObjectPointer>::Id> retval;
        for (auto object: objects)
            retval.push_back(id(object, update));
        return retval;
    }
 
    TestSuitePtr findTestSuite(const std::string &nameOrId);
 
    std::vector<SpecimenId> findSpecimensByName(const std::string &name);
 
    //------------------------------------------------------------------------------------------------------------------------
    // Cached info about disassembly. This is large data. Each specimen has zero or one associated RBA data blob.
    //------------------------------------------------------------------------------------------------------------------------
 
    bool rbaExists(SpecimenId);
 
    void saveRbaFile(const boost::filesystem::path&, SpecimenId);
 
    void extractRbaFile(const boost::filesystem::path&, SpecimenId);
 
    void eraseRba(SpecimenId);
 
    //------------------------------------------------------------------------------------------------------------------------
    // Cached symbolic state.
    //------------------------------------------------------------------------------------------------------------------------
 
    bool symbolicStateExists(TestCaseId);
 
    void saveSymbolicState(TestCaseId, const InstructionSemantics::BaseSemantics::StatePtr&);
 
    InstructionSemantics::BaseSemantics::StatePtr extractSymbolicState(TestCaseId);
 
    void eraseSymbolicState(TestCaseId);
 
    //------------------------------------------------------------------------------------------------------------------------
    // Cached concrete execution results. This is large data. Each test case has zero or one associated concrete results.
    //------------------------------------------------------------------------------------------------------------------------
 
    bool concreteResultExists(TestCaseId);
 
    void saveConcreteResult(const TestCasePtr&, const ConcreteResultPtr&);
 
    ConcreteResultPtr readConcreteResult(TestCaseId);
 
   std::vector<TestCaseId> needConcreteTesting(size_t n = UNLIMITED);
 
 
 
 
   void assocTestCaseWithTestSuite(TestCaseId, TestSuiteId);
 
   std::vector<TestCaseId> needConcolicTesting(size_t n = UNLIMITED);
 
#if 0 // [Robb Matzke 2020-07-15]
    // Use saveConcreteResults instead, which allows concrete results to also be removed.
   void insertConcreteResults(const TestCasePtr &testCase, const ConcreteResult& details);
#endif
 
   bool hasUntested();
 
    static std::string timestamp();
 
private:
    static Ptr create(const std::string &url, const Sawyer::Optional<std::string> &testSuiteName);
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif