BinaryBestMapAddress.h

#ifndef ROSE_BinaryAnalysis_BestMapAddress
#define ROSE_BinaryAnalysis_BestMapAddress

#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Diagnostics.h>
#include <Partitioner2/Engine.h>
#include <Progress.h>
#include <RoseException.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 MemoryMap::Ptr align(const MemoryMap::Ptr&,
                                const Partitioner2::Engine::Settings &settings = Partitioner2::Engine::Settings(),
                                const Progress::Ptr &progress = Progress::Ptr());
};

} // namespace
} // namespace

#endif
#endif