BinaryLoader.h

#ifndef ROSE_BinaryAnalysis_BinaryLoader_H
#define ROSE_BinaryAnalysis_BinaryLoader_H

#include "Sawyer/Message.h"

namespace Rose {
namespace BinaryAnalysis {

class BinaryLoader {
    /*========================================================================================================================
     * Types
     *======================================================================================================================== */
public:

    enum MappingContribution 
        {
        CONTRIBUTE_NONE,                
        CONTRIBUTE_ADD,                 
        CONTRIBUTE_SUB                  
    };

    enum ConflictResolution 
        {
        RESOLVE_THROW,                  
        RESOLVE_OVERMAP,                
        RESOLVE_REMAP,                  
        RESOLVE_REMAP_ABOVE,            
    };



    /*========================================================================================================================
     * Exceptions
     *======================================================================================================================== */
public:
    class Exception: public std::runtime_error {
    public:
        Exception(const std::string &reason): std::runtime_error(reason) {}
        void print(std::ostream&) const;
        friend std::ostream& operator<<(std::ostream&, const Exception&);
    };



    /*========================================================================================================================
     * Constructors, etc.
     *======================================================================================================================== */
public:
    BinaryLoader()
        : p_perform_dynamic_linking(false), p_perform_remap(true), p_perform_relocations(false)
        { init(); }

    BinaryLoader(const BinaryLoader &other)
        : p_perform_dynamic_linking(other.p_perform_dynamic_linking),
          p_perform_remap(other.p_perform_remap), p_perform_relocations(other.p_perform_relocations) {
        preloads = other.preloads;
        directories = other.directories;
    }

    virtual ~BinaryLoader(){}

    static void initDiagnostics();

private:
    static void initclass();



    /*==========================================================================================================================
     * Registration and lookup methods
     *========================================================================================================================== */
public:
    static void register_subclass(BinaryLoader*);

    virtual bool can_load(SgAsmGenericHeader*) const {
        return true;
    }

    static BinaryLoader *lookup(SgAsmGenericHeader*);
    
    static BinaryLoader *lookup(SgAsmInterpretation*);

    virtual BinaryLoader *clone() const {
        return new BinaryLoader(*this);
    }



    /*========================================================================================================================
     * Accessors for properties.
     *======================================================================================================================== */
public:
    void set_perform_dynamic_linking(bool b) { p_perform_dynamic_linking = b; }

    bool get_perform_dynamic_linking() const { return p_perform_dynamic_linking; }

    void set_perform_remap(bool b) { p_perform_remap = b; }

    bool get_perform_remap() const { return p_perform_remap; }

    void set_perform_relocations(bool b) { p_perform_relocations = b; }

    bool get_perform_relocations() const { return p_perform_relocations; }



    
    /*========================================================================================================================
     * Searching for shared objects
     *======================================================================================================================== */
public:
    void add_preload(const std::string &libname) {
        preloads.push_back(libname);
    }

    const std::vector<std::string>& get_preloads() const {
        return preloads;
    }

    void add_directory(const std::string &dirname) {
        directories.push_back(dirname);
    }

    void add_directories(const std::vector<std::string> &dirnames) {
        directories.insert(directories.end(), dirnames.begin(), dirnames.end());
    }

    const std::vector<std::string>& get_directories() const {
        return directories;
    }

    virtual std::string find_so_file(const std::string &libname) const;



    /*========================================================================================================================
     * The main interface.
     *======================================================================================================================== */
public:
    static void load(SgBinaryComposite* composite, bool read_executable_file_format_only=false);

    virtual void load(SgAsmInterpretation*);

    virtual void link(SgAsmInterpretation *interp);
    
    virtual void remap(SgAsmInterpretation *interp);

    typedef std::vector<Exception> FixupErrors;

    virtual void fixup(SgAsmInterpretation *interp, FixupErrors *errors=NULL);

    /*========================================================================================================================
     * Supporting types and functions
     *======================================================================================================================== */
public:
    virtual bool is_linked(SgBinaryComposite *composite, const std::string &filename);
    virtual bool is_linked(SgAsmInterpretation *interp, const std::string &filename);

    static SgAsmGenericFile *createAsmAST(SgBinaryComposite *composite, std::string filePath);

    virtual std::vector<std::string> dependencies(SgAsmGenericHeader*);

    virtual void remap(Rose::BinaryAnalysis::MemoryMap::Ptr&/*in,out*/, SgAsmGenericHeader*);

    virtual SgAsmGenericSectionPtrList get_remap_sections(SgAsmGenericHeader *header) {
        return header->get_mapped_sections();
    }

    virtual rose_addr_t rebase(const MemoryMap::Ptr&/*in,out*/, SgAsmGenericHeader *header, const SgAsmGenericSectionPtrList&) {
        return header->get_base_va();
    }

    static int64_t gcd(int64_t a, int64_t b, int64_t *x=NULL/*out*/, int64_t *y=NULL/*out*/);

    rose_addr_t bialign(rose_addr_t val1, rose_addr_t align1,
                        rose_addr_t val2, rose_addr_t align2);

    virtual MappingContribution align_values(SgAsmGenericSection*, const MemoryMap::Ptr&,
                                             rose_addr_t *malign_lo, rose_addr_t *malign_hi,
                                             rose_addr_t *va, rose_addr_t *mem_size,
                                             rose_addr_t *offset, rose_addr_t *file_size, bool *map_private,
                                             rose_addr_t *va_offset, bool *anon_lo, bool *anon_hi,
                                             ConflictResolution *resolve);
    

    virtual void addSectionsForRemap(SgAsmGenericHeader* header, SgAsmGenericSectionPtrList &allSections);

    static SgAsmGenericHeaderPtrList findSimilarHeaders(SgAsmGenericHeader *matchHeader,
                                                        SgAsmGenericHeaderPtrList &candidateHeaders);

    static bool isHeaderSimilar(SgAsmGenericHeader*, SgAsmGenericHeader*);



    /*========================================================================================================================
     * Data members
     *======================================================================================================================== */
public:
    static Sawyer::Message::Facility mlog;              
private: 
    void init();                                        
    static std::vector<BinaryLoader*> loaders;          
    std::vector<std::string> preloads;                  
    std::vector<std::string> directories;               
    bool p_perform_dynamic_linking;
    bool p_perform_remap;
    bool p_perform_relocations;
};

} // namespace
} // namespace

#endif /* ROSE_BINARYLOADER_H */