AsmFunctionIndex.h

Go to the documentation of this file.

#ifndef ROSE_AsmFunctionIndex_H
#define ROSE_AsmFunctionIndex_H

#include <algorithm>
#include <ostream>
#include <vector>

#include "callbacks.h"

class AsmFunctionIndex {
    /**************************************************************************************************************************
     *                                  The main public members
     **************************************************************************************************************************/
public:

    AsmFunctionIndex() {
        init();
    }

    AsmFunctionIndex(SgNode *ast) {
        init();
        add_functions(ast);
    }
    
    virtual ~AsmFunctionIndex() {}

    virtual void add_function(SgAsmFunction*);

    virtual void add_functions(SgNode *ast);

    virtual void clear() {
        functions.clear();
    }

    virtual bool empty() const {
        return functions.empty();
    }

    virtual size_t size() const {
        return functions.size();
    }

    /**************************************************************************************************************************
     *                                  Functors for sorting
     * These are expected to be commonly used, so we define them here for convenience.  The generic sorting method is defined
     * below.
     **************************************************************************************************************************/
public:

    struct SortByEntryAddr {
        bool operator()(SgAsmFunction *a, SgAsmFunction *b) {
            return a->get_entry_va() < b->get_entry_va();
        }
        bool unique(SgAsmFunction *a, SgAsmFunction *b) {
            return a->get_entry_va() != b->get_entry_va();
        }
    };

    struct SortByBeginAddr {
        bool operator()(SgAsmFunction *a, SgAsmFunction *b) {
            return val(a)<val(b);
        }
        bool unique(SgAsmFunction *a, SgAsmFunction *b) {
            return val(a)!=val(b);
        }
        rose_addr_t val(SgAsmFunction *x) {
            rose_addr_t lo;
            x->get_extent(NULL, &lo);
            return lo;
        }
    };

    struct SortByInsnsSize {
        bool operator()(SgAsmFunction *a, SgAsmFunction *b) {
            return val(a) < val(b);
        }
        bool unique(SgAsmFunction *a, SgAsmFunction *b) {
            return val(a) != val(b);
        }
        size_t val(SgAsmFunction *x) {
            return SageInterface::querySubTree<SgAsmInstruction>(x).size();
        }
    };

    struct SortByBytesSize {
        bool operator()(SgAsmFunction *a, SgAsmFunction *b) {
            return val(a) < val(b);
        }
        bool unique(SgAsmFunction *a, SgAsmFunction *b) {
            return val(a) != val(b);
        }
        size_t val(SgAsmFunction *x) {
            ExtentMap extent;
            x->get_extent(&extent);
            return extent.size();
        }
    };

    struct SortByName {
        bool operator()(SgAsmFunction *a, SgAsmFunction *b) {
            return a->get_name().compare(b->get_name()) < 0;
        }
        bool unique(SgAsmFunction *a, SgAsmFunction *b) {
            return 0 != a->get_name().compare(b->get_name());
        }
    };



    /**************************************************************************************************************************
     *                                  Sorting methods
     **************************************************************************************************************************/
public:

    template<class Comparator> AsmFunctionIndex& sort(Comparator comp, bool unique=false) {
        std::stable_sort(functions.begin(), functions.end(), comp);
        if (unique) {
            Functions newlist;
            for (Functions::iterator fi=functions.begin(); fi!=functions.end(); fi++) {
                if (newlist.empty() || comp.unique(newlist.back(), *fi))
                    newlist.push_back(*fi);
            }
            if (newlist.size()!=functions.size())
                functions = newlist;
        }
        return *this;
    }

    AsmFunctionIndex& sort_by_entry_addr(bool unique=false) { return sort(SortByEntryAddr(), unique); }
    AsmFunctionIndex& sort_by_begin_addr(bool unique=false) { return sort(SortByBeginAddr(), unique); }
    AsmFunctionIndex& sort_by_ninsns(bool unique=false)     { return sort(SortByInsnsSize(), unique); }
    AsmFunctionIndex& sort_by_nbytes(bool unique=false)     { return sort(SortByBytesSize(), unique); }
    AsmFunctionIndex& sort_by_name(bool unique=false)       { return sort(SortByName(),      unique); }
    AsmFunctionIndex& reverse() {
        std::reverse(functions.begin(), functions.end());
        return *this;
    }

    /**************************************************************************************************************************
     *                                  Footnotes
     **************************************************************************************************************************/
public:
    class Footnotes {
    public:
        Footnotes() {
            set_footnote_title("== Footnotes ==");
        }

        size_t add_footnote(const std::string &text);

        void change_footnote(size_t idx, const std::string &text);

        const std::string& get_footnote(size_t idx) const;

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

        void set_footnote_title(const std::string &title);

        const std::string& get_footnote_title() const;

        void set_footnote_prefix(const std::string &prefix) { footnote_prefix = prefix; }

        const std::string& get_footnote_prefix() const { return footnote_prefix; }

        std::string get_footnote_name(size_t idx) const;

        void print(std::ostream&) const;

        friend std::ostream& operator<<(std::ostream &o, const Footnotes *footnotes) {
            footnotes->print(o);
            return o;
        }

    protected:
        std::vector<std::string> footnotes;     
        std::string footnote_prefix;            
    };
    
    /**************************************************************************************************************************
     *                                  Output methods
     **************************************************************************************************************************/
public:
    virtual void print(std::ostream&) const;
    friend std::ostream& operator<<(std::ostream&, const AsmFunctionIndex&);



    /**************************************************************************************************************************
     *                                  Output callback base classes
     **************************************************************************************************************************/
public:

    class OutputCallback {
    public:
        struct GeneralArgs {
            GeneralArgs(const AsmFunctionIndex *index, std::ostream &output, Footnotes *footnotes)
                : index(index), output(output), footnotes(footnotes) {}
            const AsmFunctionIndex *index;              
            std::ostream &output;                       
            Footnotes *footnotes;                       
        };

        struct BeforeAfterArgs: public GeneralArgs {
            BeforeAfterArgs(const AsmFunctionIndex *index, std::ostream &output, Footnotes *footnotes, int when)
                : GeneralArgs(index, output, footnotes), when(when) {}
            int when;                                  
        };

        struct HeadingArgs: public GeneralArgs {
            HeadingArgs(const AsmFunctionIndex *index, std::ostream &output, Footnotes *footnotes, char sep='\0')
                : GeneralArgs(index, output, footnotes), sep(sep) {}
            char sep;                                   
        };

        struct DataArgs: public GeneralArgs {
            DataArgs(const AsmFunctionIndex *index, std::ostream &output, Footnotes *footnotes, SgAsmFunction *func, size_t rowid)
                : GeneralArgs(index, output, footnotes), func(func), rowid(rowid) {}
            SgAsmFunction *func;
            size_t rowid;
        };

        OutputCallback(const std::string &name, size_t width, const std::string description="")
            : name(name), desc(description), width(width), header_prefix(" "), separator_prefix(" "), data_prefix(" ") {
            assert(width>0 || name.empty());
        }

        virtual ~OutputCallback() {}

        void set_prefix(const std::string &header, const std::string &separator=" ", const std::string &data=" ");

        virtual bool operator()(bool enabled, const BeforeAfterArgs&);

        virtual bool operator()(bool enabled, const HeadingArgs&);

        virtual bool operator()(bool enabled, const DataArgs&);

    protected:
        std::string center(const std::string&, size_t width); 
        std::string name;                               
        std::string desc;                               
        size_t width;                                   
        std::string header_prefix;                      
        std::string separator_prefix;                   
        std::string data_prefix;                        
    };



    /**************************************************************************************************************************
     *                                  Predefined output callbacks
     **************************************************************************************************************************/
public:

    class RowIdCallback: public OutputCallback {
    public:
        RowIdCallback(): OutputCallback("Num", 4) {}
        virtual bool operator()(bool enabled, const DataArgs&);
    } rowIdCallback;

    class EntryAddrCallback: public OutputCallback {
    public:
        EntryAddrCallback(): OutputCallback("Entry-Addr", 10) {}
        virtual bool operator()(bool enabled, const DataArgs&);
    } entryAddrCallback;

    class BeginAddrCallback: public OutputCallback {
    public:
        BeginAddrCallback(): OutputCallback("Begin-Addr", 10) {}
        virtual bool operator()(bool enabled, const DataArgs&);
    } beginAddrCallback;

    class EndAddrCallback: public OutputCallback {
    public:
        EndAddrCallback(): OutputCallback("End-Addr", 10) {}
        virtual bool operator()(bool enabled, const DataArgs&);
    } endAddrCallback;

    class SizeInsnsCallback: public OutputCallback {
    public:
        SizeInsnsCallback(): OutputCallback("Insns", 5) {}
        virtual bool operator()(bool enabled, const DataArgs&);
    } sizeInsnsCallback;

    class SizeBytesCallback: public OutputCallback {
    public:
        SizeBytesCallback(): OutputCallback("Bytes", 6) {
            set_prefix("/", "-", "/");
        }
        virtual bool operator()(bool enabled, const DataArgs&);
    } sizeBytesCallback;

    class ReasonCallback: public OutputCallback {
    public:
        ReasonCallback(): OutputCallback("Reason", 1) {} // width will be overridden in the callback
        virtual bool operator()(bool enabled, const HeadingArgs&);
        virtual bool operator()(bool enabled, const DataArgs&);
    } reasonCallback;

    class CallingConventionCallback: public OutputCallback {
    public:
        CallingConventionCallback(): OutputCallback("Kind", 8) {}
        virtual bool operator()(bool enabled, const DataArgs&);
    } callingConventionCallback;

    class NameCallback: public OutputCallback {
    public:
        NameCallback(): OutputCallback("Name", 32) {}
        virtual bool operator()(bool enabled, const DataArgs&);
    } nameCallback;

    class FootnotesCallback: public OutputCallback {
    public:
        FootnotesCallback(): OutputCallback("", 0) {}   // not a table column
        virtual bool operator()(bool enabled, const BeforeAfterArgs&);
    } footnotesCallback;



    /**************************************************************************************************************************
     *                                  Miscellaneous
     **************************************************************************************************************************/
protected:
    typedef std::vector<SgAsmFunction*> Functions;
    Functions functions;                                
    virtual void init();

    ROSE_Callbacks::List<OutputCallback> output_callbacks;
};

    
#endif

---