RegisterDictionary.h

#ifndef ROSE_BinaryAnalysis_RegisterDictionary_H
#define ROSE_BinaryAnalysis_RegisterDictionary_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/RegisterDescriptor.h>
#include <Rose/BinaryAnalysis/RegisterParts.h>

#include <Sawyer/SharedPointer.h>
#include <Sawyer/SharedObject.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/string.hpp>
#include <map>
#include <ostream>
#include <queue>
#include <string>
#include <vector>

namespace Rose {
namespace BinaryAnalysis {

class RegisterDictionary: public Sawyer::SharedObject {

    // Types
public:
    using Ptr = RegisterDictionaryPtr;

    using Entries = std::map<std::string/*name*/, RegisterDescriptor>;

    using RegisterDescriptors = Rose::BinaryAnalysis::RegisterDescriptors;

private:
    // a descriptor can have more than one name
    using Reverse = std::map<RegisterDescriptor, std::vector<std::string>>;

    // Data members
private:
    std::string name_;                                  // name of the dictionary, usually an architecture name like 'i386'
    Entries forward_;                                   // N:1 forward lookup from name to descriptor
    Reverse reverse_;                                   // 1:N reverse lookup from descriptor to names

    // Serialization
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(name_);
        s & BOOST_SERIALIZATION_NVP(forward_);
        s & BOOST_SERIALIZATION_NVP(reverse_);
    }
#endif

    // Constructors and destructor
protected:
    RegisterDictionary();

    RegisterDictionary(const std::string &name);

    RegisterDictionary(const RegisterDictionary& other);

public:
    static Ptr instance(const std::string &name);

    static Ptr instanceNull();

    static Ptr instanceI8086();

    static Ptr instanceI8088();

    static Ptr instanceI286();

    static Ptr instanceI386();

    static Ptr instanceI386Math();

    static Ptr instanceI486();

    static Ptr instancePentium();

    static Ptr instancePentiumiii();

    static Ptr instancePentium4();

    static Ptr instanceAmd64();

#ifdef ROSE_ENABLE_ASM_AARCH64

    static Ptr instanceAarch64();
#endif

#ifdef ROSE_ENABLE_ASM_AARCH32

    static Ptr instanceAarch32();
#endif

    static Ptr instancePowerpc32();

    static Ptr instancePowerpc64();

    static Ptr instanceMips32();

    static Ptr instanceMips32AlternateNames();

    static Ptr instanceM68000();

    static Ptr instanceM68000AlternateNames();

    static Ptr instanceColdfire();

    static Ptr instanceColdfireEmac();

    static Ptr instanceCil();


    static Ptr instanceForIsa(SgAsmExecutableFileFormat::InsSetArchitecture);
    static Ptr instanceForIsa(SgAsmInterpretation*);
    // Properties
public:

    const std::string &name() const;
    void name(const std::string&);
    const Entries& registers() const;

    // Mutators
public:

    void insert(const std::string &name, RegisterDescriptor);

    void insert(const std::string &name, unsigned majr, unsigned minr, unsigned offset, unsigned nbits);

    void insert(const Ptr&);

    void resize(const std::string &name, unsigned new_nbits);

    // Lookup
public:
    RegisterDescriptor find(const std::string &name) const;

    RegisterDescriptor findOrThrow(const std::string &name) const;

    const std::string& lookup(RegisterDescriptor) const;

    bool exists(RegisterDescriptor) const;

    RegisterDescriptor findLargestRegister(unsigned major, unsigned minor, size_t maxWidth=0) const;

    Rose::BinaryAnalysis::RegisterParts getAllParts() const;

    RegisterDescriptors getDescriptors() const;

    unsigned firstUnusedMajor() const;

    unsigned firstUnusedMinor(unsigned majr) const;

    class SortBySize {
    public:
        enum Direction { ASCENDING, DESCENDING };
        explicit SortBySize(Direction d=DESCENDING): direction(d) {}
        bool operator()(RegisterDescriptor a, RegisterDescriptor b) const {
            return ASCENDING==direction ?
                a.nBits() < b.nBits() :
                a.nBits() > b.nBits();
        }
    protected:
        Direction direction;
    };

    template<class Compare>
    static RegisterDescriptors filterNonoverlapping(RegisterDescriptors reglist,
                                                    Compare order = SortBySize(),
                                                    bool reconsiderParts = true);

    RegisterDescriptors getLargestRegisters() const;

    RegisterDescriptors getSmallestRegisters() const;

    void print(std::ostream&) const;
    friend std::ostream& operator<<(std::ostream&, const RegisterDictionary&);
    size_t size() const;
};

std::ostream&
operator<<(std::ostream&, const RegisterDictionary&);

template<class Compare>
RegisterDictionary::RegisterDescriptors
RegisterDictionary::filterNonoverlapping(RegisterDescriptors desc, Compare order, bool reconsiderParts) {
    RegisterDescriptors retval;
    Map<std::pair<int/*major*/, int/*minor*/>, ExtentMap> have_bits; // the union of the bits of descriptors we will return

    // Process the descriptors in the order specified.
    std::priority_queue<RegisterDescriptor, RegisterDescriptors, Compare> heap(order, desc);
    while (!heap.empty()) {
        const RegisterDescriptor cur_desc = heap.top();
        heap.pop();
        const std::pair<int, int> cur_majmin(cur_desc.majorNumber(), cur_desc.minorNumber());
        const Extent cur_extent(cur_desc.offset(), cur_desc.nBits());
        ExtentMap &have_extents = have_bits[cur_majmin];
        if (have_extents.distinct(cur_extent)) {
            // We're not returning any of these bits yet, so add the whole descriptor
            retval.push_back(cur_desc);
            have_extents.insert(cur_extent);
        } else if (reconsiderParts) {
            // We're already returning some (or all) of these bits. Split the cur_extent into sub-parts by subtracting the
            // stuff we're already returning.
            ExtentMap parts;
            parts.insert(cur_extent);
            parts.erase_ranges(have_extents);
            for (ExtentMap::iterator pi = parts.begin(); pi != parts.end(); ++pi) {
                const Extent &part = pi->first;
                RegisterDescriptor part_desc(cur_desc.majorNumber(), cur_desc.minorNumber(), part.first(), part.size());
                heap.push(part_desc);
            }
        }
    }
    return retval;
}

} // namespace
} // namespace

#endif
#endif