BinaryLoader.h

#ifndef ROSE_BinaryAnalysis_BinaryLoader_H
#define ROSE_BinaryAnalysis_BinaryLoader_H

#include <RoseException.h>
#include <Sawyer/Message.h>
#include <Sawyer/SharedObject.h>
#include <Sawyer/SharedPointer.h>

namespace Rose {
namespace BinaryAnalysis {

typedef Sawyer::SharedPointer<class BinaryLoader> BinaryLoaderPtr;

class BinaryLoader: public Sawyer::SharedObject {
    // Types
public:
    typedef Sawyer::SharedPointer<BinaryLoader> Ptr;

    enum MappingContribution
        {
        CONTRIBUTE_NONE,                
        CONTRIBUTE_ADD,                 
        CONTRIBUTE_SUB                  
    };

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

    class Exception: public Rose::Exception {
    public:
        explicit Exception(const std::string &reason): Rose::Exception(reason) {}

        void print(std::ostream&) const;

        friend std::ostream& operator<<(std::ostream&, const Exception&);
    };

    // Data members
public:
    static Sawyer::Message::Facility mlog;              
private:
    static std::vector<Ptr> loaders_;                   // List of loader subclasses.
    std::vector<std::string> preloads_;                 // Libraries that should be pre-loaded.
    std::vector<std::string> directories_;              // Directories to search for libraries with relative names.
    bool performingDynamicLinking_;
    bool performingRemap_;
    bool performingRelocations_;

    // Constructors, etc.
protected:
    BinaryLoader()
        : performingDynamicLinking_(false), performingRemap_(true), performingRelocations_(false)
        { init(); }

    BinaryLoader(const BinaryLoader &other)
        : performingDynamicLinking_(other.performingDynamicLinking_),
          performingRemap_(other.performingRemap_), performingRelocations_(other.performingRelocations_) {
        preloads_ = other.preloads_;
        directories_ = other.directories_;
    }

public:
    virtual ~BinaryLoader(){}

    static Ptr instance() {
        return Ptr(new BinaryLoader);
    }

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

    static void initDiagnostics();

private:
    static void initclass();



    // Registration and lookup methods
public:
    static void registerSubclass(const Ptr&);

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

    static Ptr lookup(SgAsmGenericHeader*);

    static Ptr lookup(SgAsmInterpretation*);



    // Properties
public:
    bool performingDynamicLinking() const { return performingDynamicLinking_; }
    void performingDynamicLinking(bool b) { performingDynamicLinking_ = b; }
    bool performingRemap() const { return performingRemap_; }
    void performingRemap(bool b) { performingRemap_ = b; }
    bool performingRelocations() const { return performingRelocations_; }
    void performingRelocations(bool b) { performingRelocations_ = b; }
    // Searching for shared objects
public:
    const std::vector<std::string>& preloads() const { return preloads_; }
    std::vector<std::string>& preloads() { return preloads_; }
    void preloads(const std::vector<std::string> &v) { preloads_ = v; }
    const std::vector<std::string>& directories() const { return directories_; }
    std::vector<std::string>& directories() { return directories_; }
    void directories(const std::vector<std::string> &v) { directories_ = v; }
    void appendDirectories(const std::vector<std::string> &dirnames) {
        directories_.insert(directories_.end(), dirnames.begin(), dirnames.end());
    }

    virtual std::string findSoFile(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 isLinked(SgBinaryComposite *composite, const std::string &filename);
    virtual bool isLinked(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 getRemapSections(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 alignValues(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*);

    virtual unsigned mappingPermissions(SgAsmGenericSection*) const;


    // Supporting functions.
private:
    void init();                                        // Further initializations in a *.C file.


    // Deprecated members.
public:    
    // [Robb Matzke 2019-01-30]: deprecated
    static void register_subclass(const Ptr &loader) ROSE_DEPRECATED("use registerSubclass") {
        return registerSubclass(loader);
    }
    void set_perform_dynamic_linking(bool b) ROSE_DEPRECATED("use performingDynamicLinking") {
        performingDynamicLinking(b);
    }
    bool get_perform_dynamic_linking() const ROSE_DEPRECATED("use performingDynamicLinking") {
        return performingDynamicLinking();
    }
    void set_perform_remap(bool b) ROSE_DEPRECATED("use performingRemap") {
        performingRemap(b);
    }
    bool get_perform_remap() const ROSE_DEPRECATED("use performingRemap") {
        return performingRemap();
    }
    void set_perform_relocations(bool b) ROSE_DEPRECATED("use performingRelocations") {
        performingRelocations(b);
    }
    bool get_perform_relocations() const ROSE_DEPRECATED("use performingRelocations") {
        return performingRelocations();
    }
    void add_preload(const std::string &libname) ROSE_DEPRECATED("use preloads") {
        preloads().push_back(libname);
    }
    const std::vector<std::string>& get_preloads() const ROSE_DEPRECATED("use preloads") {
        return preloads();
    }
    void add_directory(const std::string &dirname) ROSE_DEPRECATED("use directories") {
        directories().push_back(dirname);
    }
    void add_directories(const std::vector<std::string> &dirnames) ROSE_DEPRECATED("use appendDirectories") {
        appendDirectories(dirnames);
    }
    const std::vector<std::string>& get_directories() const ROSE_DEPRECATED("use directories") {
        return directories();
    }
};

} // namespace
} // namespace

#endif