BinaryLoaderElf.h

#ifndef ROSE_BinaryAnalysis_BinaryLoaderElf_H
#define ROSE_BinaryAnalysis_BinaryLoaderElf_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/BinaryLoader.h>
 
namespace Rose {
namespace BinaryAnalysis {
 
class BinaryLoaderElf: public BinaryLoader {
public:
    using Ptr = BinaryLoaderElfPtr;
 
public:
    /* 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* symbol_;
        SgAsmElfSymverEntry* versionEntry_;
        SgAsmElfSymverDefinedEntry* versionDef_;
        SgAsmElfSymverNeededAux* versionNeed_;
    public:
        explicit VersionedSymbol(SgAsmElfSymbol* symbol)
            : symbol_(symbol), versionEntry_(NULL), versionDef_(NULL), versionNeed_(NULL)
            {}
 
        bool isLocal() const;
 
        bool isHidden() const;
 
        bool isReference() const;
 
        bool isBaseDefinition() const;
 
        void symbol(SgAsmElfSymbol *symbol) { symbol_ = symbol; }
        SgAsmElfSymbol* symbol() const { return symbol_; }
        SgAsmElfSymbolSection* getSection() const;
 
        std::string getVersion() const;
 
        std::string getName() const;
 
        std::string getVersionedName() const;
 
        void versionEntry(SgAsmElfSymverEntry*);
 
        SgAsmElfSymverDefinedEntry* versionDef() const;
        void versionDef(SgAsmElfSymverDefinedEntry*);
        SgAsmElfSymverNeededAux* versionNeed() const;
        void versionNeed(SgAsmElfSymverNeededAux*);
        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> versions_;
    public:
        const VersionedSymbol &getVSymbol() const;
 
        SgAsmElfSymbol *getSymbol() const;
 
        VersionedSymbol getVSymbol(const VersionedSymbol &version) const;
 
        SgAsmElfSymbolSection *getSection() const;
 
        void addVersion(const VersionedSymbol &vsymbol);
 
        void merge(const SymbolMapEntry&);
 
        void dump(FILE*, const char *prefix) const ;
 
    private:
        const VersionedSymbol& getBaseVersion() const;
    };
 
    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:
        typedef std::map<SgAsmElfSymbol*, VersionedSymbol*> VersionedSymbolMap;
        typedef std::map<uint16_t, SgAsmElfSymverDefinedEntry*> SymbolVersionDefinitionMap;
        typedef std::map<uint16_t, SgAsmElfSymverNeededAux*> SymbolVersionNeededMap;
 
    private:
        // Map from each ELF Symbol Version Definition Table entry's get_index() to the entry itself.
        SymbolVersionDefinitionMap symbolVersionDefMap_;
 
        // Map from each auxiliary's get_other() to the auxiliary itself. The auxiliaries come from the GNU Symbol Version
        // Requirements Table, each entry of which points to a list of auxiliaries.  The parent of each auxiliary is the table
        // entry that contained the auxiliary, thus this mapping also maps get_other() to GNU Symbol Version Requirements Table
        // entries.
        SymbolVersionNeededMap symbolVersionNeedMap_;
 
        // Map from an SgAsmElfSymbol to a VersionedSymbol.
        VersionedSymbolMap versionedSymbolMap_;
    public:
        SymverResolver(SgAsmGenericHeader *header) {
            ctor(header);
        }
 
        VersionedSymbol getVersionedSymbol(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*);
    };
 
protected:
    SymbolMap symbols_;
 
protected:
    BinaryLoaderElf() {}
 
    BinaryLoaderElf(const BinaryLoaderElf &other)
        : BinaryLoader(other)
        {}
 
public:
    static Ptr instance() {
        return Ptr(new BinaryLoaderElf);
    }
 
    virtual ~BinaryLoaderElf() {}
 
    virtual BinaryLoaderPtr clone() const override {
        return BinaryLoaderPtr(new BinaryLoaderElf(*this));
    }
 
    virtual bool canLoad(SgAsmGenericHeader*) const override;
 
    void addLibDefaults(SgAsmGenericHeader *header=NULL);
 
    static void getDynamicVars(SgAsmGenericHeader*, std::string &rpath/*out*/, std::string &runpath/*out*/);
 
    // documented in superclass
    virtual void fixup(SgAsmInterpretation *interp, FixupErrors *errors=NULL) override;
 
    virtual SgAsmGenericSection *findSectionByPreferredVa(SgAsmGenericHeader*, rose_addr_t va);
 
protected:
    virtual SgAsmGenericSectionPtrList getRemapSections(SgAsmGenericHeader*) override;
 
public:
    virtual rose_addr_t rebase(const MemoryMap::Ptr&, SgAsmGenericHeader*, const SgAsmGenericSectionPtrList&) override;
 
protected:
    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) override;
 
    void buildMasterSymbolTable(SgAsmInterpretation*);
 
    /*========================================================================================================================
     * Methods returning prerequisite information for fixups.  These names all begin with "fixup_info_".
     *======================================================================================================================== */
protected:
 
    SgAsmElfSymbol *fixupInfoRelocSymbol(SgAsmElfRelocEntry*, const SymverResolver&);
 
    rose_addr_t fixupInfoTargetVa(SgAsmElfRelocEntry*, SgAsmGenericSection **section_p=NULL, rose_addr_t *adj_p=NULL);
 
    rose_addr_t fixupInfoSymbolVa(SgAsmElfSymbol*, SgAsmGenericSection **section_p=NULL, rose_addr_t *adj_p=NULL);
 
    rose_addr_t fixupInfoAddend(SgAsmElfRelocEntry*, rose_addr_t target_va, const MemoryMap::Ptr&, size_t nbytes=0);
 
    rose_addr_t fixupInfoExpr(const std::string &expression, SgAsmElfRelocEntry *reloc, const SymverResolver &resolver,
                              const MemoryMap::Ptr &memmap, rose_addr_t *target_va_p=NULL);
 
 
 
    /*========================================================================================================================
     * Methods that apply a relocation fixup.  These names all begin with "fixup_apply_".
     *======================================================================================================================== */
protected:
    void fixupApply(rose_addr_t value, SgAsmElfRelocEntry*, const MemoryMap::Ptr&, rose_addr_t target_va=0, size_t nbytes=0);
 
    void fixupApplySymbolCopy(SgAsmElfRelocEntry*, const SymverResolver&, const MemoryMap::Ptr&);
 
    /*========================================================================================================================
     * Functions moved here from the BinaryLoader_ElfSupport name space.
     *======================================================================================================================== */
protected:
    void performRelocation(SgAsmElfRelocEntry*, const SymverResolver&, const MemoryMap::Ptr&);
    void performRelocations(SgAsmElfFileHeader*, const MemoryMap::Ptr&);
};
 
std::ostream& operator<<(std::ostream&, const BinaryLoaderElf::VersionedSymbol&);
 
} // namespace
} // namespace
 
#endif
#endif