Registers.h

Go to the documentation of this file.

#ifndef ROSE_BINARY_REGISTERS_H
#define ROSE_BINARY_REGISTERS_H

#include <map>
#include <queue>
#include <string>

class RegisterDictionary {
public:
    typedef std::map<std::string/*name*/, RegisterDescriptor> Entries;
    typedef std::vector<RegisterDescriptor> RegisterDescriptors;

    /* Functions that return a dictionary for a particular machine architecute. (See implementation for documentation.) */
    static const RegisterDictionary *dictionary_i8086();
    static const RegisterDictionary *dictionary_i8088();
    static const RegisterDictionary *dictionary_i286();
    static const RegisterDictionary *dictionary_i386();
    static const RegisterDictionary *dictionary_i386_387();
    static const RegisterDictionary *dictionary_i486();
    static const RegisterDictionary *dictionary_pentium();
    static const RegisterDictionary *dictionary_pentium4();
    static const RegisterDictionary *dictionary_amd64();
    static const RegisterDictionary *dictionary_arm7();
    static const RegisterDictionary *dictionary_powerpc();
    static const RegisterDictionary *dictionary_mips32();
    static const RegisterDictionary *dictionary_mips32_altnames();

    RegisterDictionary(const std::string &name)
        :name(name) {}
    RegisterDictionary(const RegisterDictionary& other) {
        *this = other;
    }

    static const RegisterDictionary *dictionary_for_isa(SgAsmExecutableFileFormat::InsSetArchitecture);
    static const RegisterDictionary *dictionary_for_isa(SgAsmInterpretation*);
    const std::string &get_architecture_name() const {
        return name;
    }

    void set_architecture_name(const std::string &name) {
        this->name = name;
    }

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

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

    void insert(const RegisterDictionary*);

    void insert(const RegisterDictionary&);

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

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

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

    const Entries& get_registers() const;
    Entries& get_registers();
    RegisterDescriptors get_descriptors() const;

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

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

    RegisterDescriptors get_largest_registers() const;

    RegisterDescriptors get_smallest_registers() const;

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

    size_t size() const { return forward.size(); }

private:
    typedef std::map<uint64_t/*desc_hash*/, std::vector<std::string> > Reverse;
    static uint64_t hash(const RegisterDescriptor&);
    std::string name; /*name of the dictionary, usually an architecture name like 'i386'*/
    Entries forward;
    Reverse reverse;
};

class RegisterNames {
public:
    explicit RegisterNames(const RegisterDictionary *dict=NULL)
        : dflt_dict(dict), prefix("REG"), show_offset(-1), offset_prefix("@"), show_size(false) {}

    std::string operator()(const RegisterDescriptor&, const RegisterDictionary *dict=NULL) const;

    const RegisterDictionary *dflt_dict;
    std::string prefix;                 
    std::string suffix;                 
    int show_offset;                    
    std::string offset_prefix;          
    std::string offset_suffix;          
    bool show_size;                     
    std::string size_prefix;            
    std::string size_suffix;            
};

/*******************************************************************************************************************************
 *                                      Template definitions
 *******************************************************************************************************************************/



template<class Compare>
RegisterDictionary::RegisterDescriptors
RegisterDictionary::filter_nonoverlapping(RegisterDescriptors desc, Compare order, bool reconsider_parts)
{
    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.get_major(), cur_desc.get_minor());
        const Extent cur_extent(cur_desc.get_offset(), cur_desc.get_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 (reconsider_parts) {
            // 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.get_major(), cur_desc.get_minor(), part.first(), part.size());
                heap.push(part_desc);
            }
        }
    }
    return retval;
}
    
#endif