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 <rose_extent.h>
#include <Map.h>                                        // rose
 
#include <Sawyer/SharedPointer.h>
#include <Sawyer/SharedObject.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/string.hpp>
#endif
 
#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
    RegisterDescriptor instructionPointer_;             // optional special instruction pointer register
    RegisterDescriptor stackPointer_;                   // optional special stack pointer register
    RegisterDescriptor stackFrame_;                     // optional special stack frame pointer register
    RegisterDescriptor stackSegment_;                   // optional special stack segment register
    RegisterDescriptor callReturn_;                     // optional special call return address register
 
    // Serialization
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
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);
    RegisterDictionary& operator=(const RegisterDictionary&) = default;
 
public:
    static Ptr instance(const std::string &name);
 
    static Ptr instanceNull();
 
    // Properties
public:
 
    const std::string &name() const;
    void name(const std::string&);
    const Entries& registers() const;
 
    size_t size() 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;
 
    // Register names
 
    Sawyer::Optional<std::string> name(RegisterDescriptor) const;
 
    std::string nameOrQuad(RegisterDescriptor) const;
 
    std::string nameAndQuad(RegisterDescriptor) const;
 
    std::string quadAndName(RegisterDescriptor) const;
 
    // Special registers
public:
    RegisterDescriptor instructionPointerRegister() const;
    void instructionPointerRegister(RegisterDescriptor);
    void instructionPointerRegister(const std::string&);
    RegisterDescriptor stackPointerRegister() const;
    void stackPointerRegister(RegisterDescriptor);
    void stackPointerRegister(const std::string&);
    RegisterDescriptor stackFrameRegister() const;
    void stackFrameRegister(RegisterDescriptor);
    void stackFrameRegister(const std::string&);
    RegisterDescriptor stackSegmentRegister() const;
    void stackSegmentRegister(RegisterDescriptor);
    void stackSegmentRegister(const std::string&);
    RegisterDescriptor callReturnRegister() const;
    void callReturnRegister(RegisterDescriptor);
    void callReturnRegister(const std::string&);
    // Other queries
 
    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;
    };
    class SortBySize {…};
 
    template<class Compare>
    static RegisterDescriptors filterNonoverlapping(RegisterDescriptors reglist,
                                                    Compare order = SortBySize(),
                                                    bool reconsiderParts = true);
 
    RegisterDescriptors getLargestRegisters() const;
 
    RegisterDescriptors getSmallestRegisters() const;
 
    // Debugging
 
    void print(std::ostream&) const;
    friend std::ostream& operator<<(std::ostream&, const RegisterDictionary&);
};
class RegisterDictionary: public Sawyer::SharedObject {…};
 
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;
}
RegisterDictionary::filterNonoverlapping(RegisterDescriptors desc, Compare order, bool reconsiderParts) {…}
 
} // namespace
} // namespace
 
#endif
#endif