BinaryLoader.h

#ifndef ROSE_BinaryAnalysis_BinaryLoader_H
#define ROSE_BinaryAnalysis_BinaryLoader_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/Exception.h>
 
#include <SgAsmGenericHeader.h>
 
#include <Sawyer/Message.h>
#include <Sawyer/SharedObject.h>
#include <Sawyer/SharedPointer.h>
 
namespace Rose {
namespace BinaryAnalysis {
 
class BinaryLoader: public Sawyer::SharedObject {
    // Types
public:
    using Ptr = BinaryLoaderPtr;
 
    enum MappingContribution
        {
        CONTRIBUTE_NONE,                
        CONTRIBUTE_ADD,                 
        CONTRIBUTE_SUB                  
    };
    enum MappingContribution {…};
 
    enum ConflictResolution
        {
        RESOLVE_THROW,                  
        RESOLVE_OVERMAP,                
        RESOLVE_REMAP,                  
        RESOLVE_REMAP_ABOVE,            
    };
    enum ConflictResolution {…};
 
    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&);
    };
    class Exception: public Rose::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)
        : Sawyer::SharedObject(other), performingDynamicLinking_(other.performingDynamicLinking_),
          performingRemap_(other.performingRemap_), performingRelocations_(other.performingRelocations_) {
        preloads_ = other.preloads_;
        directories_ = other.directories_;
    }
    BinaryLoader(const BinaryLoader &other) {…}
 
public:
    virtual ~BinaryLoader(){}
 
    static Ptr instance() {
        return Ptr(new BinaryLoader);
    }
    static Ptr instance() {…}
 
    virtual Ptr clone() const {
        return Ptr(new BinaryLoader(*this));
    }
    virtual Ptr clone() const  {…}
 
    static void initDiagnostics();
 
private:
    static void initclass();
 
 
 
    // Registration and lookup methods
public:
    static void registerSubclass(const Ptr&);
 
    virtual bool canLoad(SgAsmGenericHeader*) const {
        return true;
    }
    virtual bool canLoad(SgAsmGenericHeader*) const  {…}
 
    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());
    }
    void appendDirectories(const std::vector<std::string> &dirnames) {…}
 
    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_mappedSections();
    }
    virtual SgAsmGenericSectionPtrList getRemapSections(SgAsmGenericHeader *header) {…}
 
    virtual Address rebase(const MemoryMap::Ptr&/*in,out*/, SgAsmGenericHeader *header, const SgAsmGenericSectionPtrList&) {
        return header->get_baseVa();
    }
    virtual Address rebase(const MemoryMap::Ptr&/*in,out*/, SgAsmGenericHeader *header, const SgAsmGenericSectionPtrList&) {…}
 
    static int64_t gcd(int64_t a, int64_t b, int64_t *x=NULL/*out*/, int64_t *y=NULL/*out*/);
 
    Address bialign(Address val1, Address align1,
                        Address val2, Address align2);
 
    virtual MappingContribution alignValues(SgAsmGenericSection*, const MemoryMap::Ptr&,
                                            Address *malign_lo, Address *malign_hi,
                                            Address *va, Address *mem_size,
                                            Address *offset, Address *file_size, bool *map_private,
                                            Address *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.
};
class BinaryLoader: public Sawyer::SharedObject {…};
 
} // namespace
} // namespace
 
#endif
#endif