BinaryLoaderElf.h

Go to the documentation of this file.

#ifndef ROSE_BINARYLOADERELF_H
#define ROSE_BINARYLOADERELF_H

#include "BinaryLoader.h"

class BinaryLoaderElf: public BinaryLoader {
public:
    BinaryLoaderElf() {}

    BinaryLoaderElf(const BinaryLoaderElf &other)
        : BinaryLoader(other)
        {}

    virtual ~BinaryLoaderElf() {}

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

    virtual bool can_load(SgAsmGenericHeader*) const;

    void add_lib_defaults(SgAsmGenericHeader *header=NULL);

    static void get_dynamic_vars(SgAsmGenericHeader*, std::string &rpath/*out*/, std::string &runpath/*out*/);

    // documented in superclass
    virtual void fixup(SgAsmInterpretation *interp, FixupErrors *errors=NULL) /*override*/;

    /* FIXME: These should probably be in SgAsmElfSymver* classes instead. [RPM 2010-09-14] */
    enum {
        VER_FLG_BASE=0x1,
        VER_FLG_WEAK=0x2,
        VERSYM_HIDDEN=0x8000
    };

    class VersionedSymbol {
    private:
        SgAsmElfSymbol* p_symbol;
        SgAsmElfSymverEntry* p_version_entry;
        SgAsmElfSymverDefinedEntry* p_version_def;
        SgAsmElfSymverNeededAux* p_version_need;
    public:
        explicit VersionedSymbol(SgAsmElfSymbol* symbol)
            : p_symbol(symbol), p_version_entry(NULL), p_version_def(NULL), p_version_need(NULL)
            {}

        bool is_local() const;

        bool is_hidden() const;

        bool is_reference() const;
        
        bool is_base_definition() const;

        void set_symbol(SgAsmElfSymbol *symbol) {
            p_symbol = symbol;
        }
        
        SgAsmElfSymbol *get_symbol() const {
            return p_symbol;
        }

        SgAsmElfSymbolSection *get_section() const {
            SgAsmElfSymbolSection *retval = SageInterface::getEnclosingNode<SgAsmElfSymbolSection>(p_symbol);
            ROSE_ASSERT(retval!=NULL);
            return retval;
        }
        
        std::string get_version() const;
        
        std::string get_name() const {
            return p_symbol->get_name()->get_string();
        }
        
        std::string get_versioned_name() const;
        
        void set_version_entry(SgAsmElfSymverEntry *entry) {
            p_version_entry = entry;
        }

        void set_version_def(SgAsmElfSymverDefinedEntry* def) {
            ROSE_ASSERT(def->get_flags() == 0 || def->get_flags() == VER_FLG_BASE);
            p_version_def = def;
        }

        void set_version_need(SgAsmElfSymverNeededAux* need) {
            ROSE_ASSERT(need->get_flags() == 0 || need->get_flags() == VER_FLG_WEAK);
            p_version_need = need;
        }

        SgAsmElfSymverNeededAux* get_version_need() const {
            return p_version_need;
        }

        SgAsmElfSymverDefinedEntry* get_version_def() const {
            return p_version_def;
        }

        void print(std::ostream&) const;

        void dump(FILE*, const char *prefix, ssize_t idx) const;
    };

    struct SymbolMapEntry {
    private:
        /* Base version will be at the front if we have one; other entries are unsorted. */
        std::vector<VersionedSymbol> p_versions;
    public:
        const VersionedSymbol &get_vsymbol() const {
            return get_base_version();
        }

        SgAsmElfSymbol *get_symbol() const {
            return get_vsymbol().get_symbol();
        }

        VersionedSymbol get_vsymbol(const VersionedSymbol &version) const;

        SgAsmElfSymbolSection *get_section() const {
            return get_vsymbol().get_section();
        }

        void addVersion(const VersionedSymbol &vsymbol);

        void merge(const SymbolMapEntry&);

        void dump(FILE*, const char *prefix) const ;

    private:
        const VersionedSymbol& get_base_version() const {
            ROSE_ASSERT(!p_versions.empty());
            return p_versions.front();
        }
    };

    class SymbolMap: public std::map<std::string/*symbol name*/, SymbolMapEntry> {
    public:
        const SymbolMapEntry *lookup(std::string name) const;

        const SymbolMapEntry *lookup(std::string name, std::string version) const;

        void dump(FILE*, const char *prefix) const;
    };

    class SymverResolver {
    public:
        SymverResolver(SgAsmGenericHeader *header) {
            ctor(header);
        }

        VersionedSymbol get_versioned_symbol(SgAsmElfSymbol *symbol) const;

        void dump(FILE*, const char *prefix, ssize_t idx) const;

    private:
        void ctor(SgAsmGenericHeader*);

        void makeSymbolVersionDefMap(SgAsmElfSymverDefinedSection*);

        void makeSymbolVersionNeedMap(SgAsmElfSymverNeededSection*);

        void makeVersionedSymbolMap(SgAsmElfSymbolSection*, SgAsmElfSymverSection*);

        typedef std::map<SgAsmElfSymbol*, VersionedSymbol*> VersionedSymbolMap;
        typedef std::map<uint16_t, SgAsmElfSymverDefinedEntry*> SymbolVersionDefinitionMap;
        typedef std::map<uint16_t, SgAsmElfSymverNeededAux*> SymbolVersionNeededMap;

        SymbolVersionDefinitionMap p_symbolVersionDefMap;

        SymbolVersionNeededMap p_symbolVersionNeedMap;

        VersionedSymbolMap p_versionedSymbolMap;
    };

    virtual SgAsmGenericSection *find_section_by_preferred_va(SgAsmGenericHeader*, rose_addr_t va);

protected:
    virtual SgAsmGenericSectionPtrList get_remap_sections(SgAsmGenericHeader*);

    virtual rose_addr_t rebase(MemoryMap*, SgAsmGenericHeader*, const SgAsmGenericSectionPtrList&);

    virtual MappingContribution align_values(SgAsmGenericSection*, MemoryMap*,
                                             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);

    void build_master_symbol_table(SgAsmInterpretation*);

    /*========================================================================================================================
     * Methods returning prerequisite information for fixups.  These names all begin with "fixup_info_".
     *======================================================================================================================== */
protected:

    SgAsmElfSymbol *fixup_info_reloc_symbol(SgAsmElfRelocEntry*, const SymverResolver&);

    rose_addr_t fixup_info_target_va(SgAsmElfRelocEntry*, SgAsmGenericSection **section_p=NULL, rose_addr_t *adj_p=NULL);

    rose_addr_t fixup_info_symbol_va(SgAsmElfSymbol*, SgAsmGenericSection **section_p=NULL, rose_addr_t *adj_p=NULL);

    rose_addr_t fixup_info_addend(SgAsmElfRelocEntry*, rose_addr_t target_va, MemoryMap*, size_t nbytes=0);

    rose_addr_t fixup_info_expr(const std::string &expression, SgAsmElfRelocEntry *reloc, const SymverResolver &resolver,
                                MemoryMap *memmap, rose_addr_t *target_va_p=NULL);



    /*========================================================================================================================
     * Methods that apply a relocation fixup.  These names all begin with "fixup_apply_".
     *======================================================================================================================== */
protected:
    void fixup_apply(rose_addr_t value, SgAsmElfRelocEntry*, MemoryMap*, rose_addr_t target_va=0, size_t nbytes=0);

    void fixup_apply_symbol_copy(SgAsmElfRelocEntry*, const SymverResolver&, MemoryMap*);

    /*========================================================================================================================
     * Functions moved here from the BinaryLoader_ElfSupport name space.
     *======================================================================================================================== */
protected:
    void performRelocation(SgAsmElfRelocEntry*, const SymverResolver&, MemoryMap*);
    void performRelocations(SgAsmElfFileHeader*, MemoryMap*);

    /*========================================================================================================================
     * Data members
     *======================================================================================================================== */
protected:

    SymbolMap p_symbols;
};

std::ostream& operator<<(std::ostream&, const BinaryLoaderElf::VersionedSymbol&);

#endif /*ROSE_BINARYLOADERELF_H*/