AsmFunctionIndex.h

#ifndef ROSE_BinaryAnalysis_AsmFunctionIndex_H
#define ROSE_BinaryAnalysis_AsmFunctionIndex_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <RoseFirst.h>
 
#include <Rose/Diagnostics.h>
#include <callbacks.h>                                  // rose
 
#include <SgAsmFunction.h>
 
#include <algorithm>
#include <ostream>
#include <vector>
 
namespace Rose {
namespace BinaryAnalysis {
 
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_entryVa() < b->get_entryVa();
        }
        bool unique(SgAsmFunction *a, SgAsmFunction *b) {
            return a->get_entryVa() != b->get_entryVa();
        }
    };
 
    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*);
    };
 
    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) {
            AddressIntervalSet 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_require(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("CallConv", 8) {}
        virtual bool operator()(bool enabled, const DataArgs&);
    } callingConventionCallback;
 
    class MayReturnCallback: public OutputCallback {
    public:
        MayReturnCallback(): OutputCallback("Returns", 9) {}
        virtual bool operator()(bool enabled, const DataArgs&);
    } mayReturnCallback;
 
    class StackDeltaCallback: public OutputCallback {
    public:
        StackDeltaCallback(): OutputCallback("Stack", 9) {}
        virtual bool operator()(bool enabled, const HeadingArgs&);
        virtual bool operator()(bool enabled, const DataArgs&);
    } stackDeltaCallback;
 
    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();
 
    Callbacks::List<OutputCallback> output_callbacks;
};
 
} // namespace
} // namespace
 
#endif
#endif