BestMapAddress.h

#ifndef ROSE_BinaryAnalysis_BestMapAddress_H
#define ROSE_BinaryAnalysis_BestMapAddress_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/Diagnostics.h>
#include <Rose/BinaryAnalysis/Partitioner2/Engine.h>
#include <Rose/Progress.h>
#include <Rose/Exception.h>
#include <Sawyer/Set.h>
 
namespace Rose {
namespace BinaryAnalysis {
 
class BestMapAddress {
public:
    class Exception: public Rose::Exception {
    public:
        explicit Exception(const std::string &mesg)
            : Rose::Exception(mesg) {}
 
        ~Exception() throw () {}
    };
 
    typedef Sawyer::Container::Set<rose_addr_t> AddressSet;
 
    static Diagnostics::Facility mlog;
 
    struct Settings {
        Sawyer::Optional<size_t> nThreads;              
    };
 
private:
    typedef Sawyer::Container::Map<size_t /*nMatches*/, std::vector<rose_addr_t>/*deltas*/> MatchedDeltas;
 
    Settings settings_;
    AddressSet entryVas_;                               // set of function entry virtual addresses
    AddressSet targetVas_;                              // set of call target (callee) addresses
    MatchedDeltas results_;                             // results of analyze() call
    bool upToDate_;                                     // are results_ up-to-date w.r.t. address sets?
    size_t maxMatches_;                                 // maximum number of matches possible for results_
    size_t nBits_;                                      // number of bits in an address
    Progress::Ptr progress_;                            // for progress reporting
 
public:
    BestMapAddress()
        : upToDate_(true), maxMatches_(0), nBits_(0), progress_(Progress::instance()) {}
 
    const Settings& settings() const {
        return settings_;
    }
    Settings& settings() {
        return settings_;
    }
    void reset() {
        entryVas_.clear();
        targetVas_.clear();
        results_.clear();
        maxMatches_ = 0;
        upToDate_ = true;
    }
 
    static void initDiagnostics();
 
    Progress::Ptr progress() const { return progress_; }
    void progress(const Progress::Ptr &p) { progress_ = p; }
    size_t nBits() const { return nBits_; }
    void nBits(size_t n);
    rose_addr_t mask() const;
 
    void gatherAddresses(Partitioner2::Engine &engine);
 
    void insertEntryAddress(rose_addr_t va) {
        if (entryVas_.insert(va))
            upToDate_ = false;
    }
 
    void insertTargetAddress(rose_addr_t va) {
        if (targetVas_.insert(va))
            upToDate_ = false;
    }
 
    const AddressSet& entryAddresses() const {
        return entryVas_;
    }
 
    const AddressSet& targetAddresses() const {
        return targetVas_;
    }
 
    BestMapAddress& analyze(const AddressInterval &restrictEntryAddresses = AddressInterval::whole(),
                            const AddressInterval &restrictTargetAddresses = AddressInterval::whole());
 
    const std::vector<rose_addr_t>& bestDeltas() const;
 
    double bestDeltaRatio() const;
 
    static MemoryMapPtr align(const MemoryMapPtr&,
                              const Partitioner2::Engine::Settings &settings = Partitioner2::Engine::Settings(),
                              const Progress::Ptr &progress = Progress::Ptr());
};
 
} // namespace
} // namespace
 
#endif
#endif