diff options
Diffstat (limited to 'core/elffile.h')
| -rw-r--r-- | core/elffile.h | 722 |
1 files changed, 722 insertions, 0 deletions
diff --git a/core/elffile.h b/core/elffile.h new file mode 100644 index 0000000..d9809ce --- /dev/null +++ b/core/elffile.h @@ -0,0 +1,722 @@ +#ifndef ELFFILE_H +#define ELFFILE_H + +class ELFFile; +class ELFArchitecture; +class ELFSegmentList; +class ELFDirectoryList; +class ELFImport; +class ELFImportList; +class ELFFixupList; +class ELFSymbolList; +class ELFExportList; +class ELFSymbol; +class ELFStringTable; +class ELFRelocationList; +class ELFSectionList; +class ELFVerneedList; +class ELFVerneed; +class ELFVerdefList; +class ELFVerdef; +class ELFRuntimeFunctionList; +class CommonInformationEntry; +class CommonInformationEntryList; + +class ELFSegment : public BaseSection +{ +public: + explicit ELFSegment(ELFSegmentList *owner); + explicit ELFSegment(ELFSegmentList *owner, uint64_t address, uint64_t size, uint32_t physical_offset, + uint32_t physical_size, uint32_t flags, uint32_t type, uint64_t alignment); + explicit ELFSegment(ELFSegmentList *owner, const ELFSegment &src); + virtual ELFSegment *Clone(ISectionList *owner) const; + void ReadFromFile(ELFArchitecture &file); + size_t WriteToFile(ELFArchitecture &file); + virtual uint32_t type() const { return type_; } + virtual void set_type(uint32_t type) { type_ = type; } + virtual uint64_t address() const { return address_; } + virtual uint64_t size() const { return size_; } + virtual uint32_t physical_offset() const { return physical_offset_; } + virtual uint32_t physical_size() const { return physical_size_; } + virtual std::string name() const; + virtual uint32_t memory_type() const; + virtual void update_type(uint32_t mt); + void set_size(uint64_t size) { size_ = size; } + void set_physical_offset(uint32_t offset) { physical_offset_ = offset; } + void set_physical_size(uint32_t size) { physical_size_ = size; } + virtual uint32_t flags() const { return flags_; } + virtual void Rebase(uint64_t delta_base); + uint64_t alignment() const { return alignment_; } + uint32_t prot() const; +private: + uint32_t type_; + uint64_t address_; + uint64_t size_; + uint32_t physical_offset_; + uint32_t physical_size_; + uint32_t flags_; + uint64_t alignment_; +}; + +class ELFSegmentList : public BaseSectionList +{ +public: + explicit ELFSegmentList(ELFArchitecture *owner); + explicit ELFSegmentList(ELFArchitecture *owner, const ELFSegmentList &src); + virtual ELFSegmentList *Clone(ELFArchitecture *owner) const; + virtual ELFSegment *GetSectionByAddress(uint64_t address) const; + virtual ELFSegment *GetSectionByOffset(uint64_t offset) const; + ELFSegment *GetSectionByType(uint32_t type) const; + void ReadFromFile(ELFArchitecture &file, size_t count); + size_t WriteToFile(ELFArchitecture &file); + ELFSegment *item(size_t index) const; + ELFSegment *last() const; + ELFSegment *Add(uint64_t address, uint64_t size, uint32_t physical_offset, uint32_t physical_size, uint32_t flags, + uint32_t type, uint64_t alignment); +private: + ELFSegment *Add(); +}; + +class ELFSection : public BaseSection +{ +public: + explicit ELFSection(ELFSectionList *owner); + explicit ELFSection(ELFSectionList *owner, uint64_t address, uint32_t size, uint32_t physical_offset, uint32_t flags, uint32_t type, const std::string &name); + explicit ELFSection(ELFSectionList *owner, const ELFSection &src); + virtual ELFSection *Clone(ISectionList *owner) const; + void ReadFromFile(ELFArchitecture &file); + void WriteToFile(ELFArchitecture &file); + void ReadName(ELFStringTable &string_table); + void WriteName(ELFStringTable &string_table); + virtual uint64_t address() const { return address_; } + virtual uint64_t size() const { return size_; } + virtual uint32_t physical_offset() const { return physical_offset_; } + virtual uint32_t physical_size() const { return size_; } + virtual std::string name() const { return name_; } + void set_name(const std::string &name) { name_ = name; } + virtual uint32_t memory_type() const { return parent_->memory_type(); } + virtual ELFSegment *parent() const { return parent_; } + virtual uint32_t flags() const { return static_cast<uint32_t>(flags_); } + virtual void Rebase(uint64_t delta_base); + virtual void update_type(uint32_t mt) { } + uint32_t type() const { return type_; } + uint32_t link() const { return link_; } + uint64_t entry_size() const { return entry_size_; } + void set_physical_offset(uint32_t physical_offset) { physical_offset_ = physical_offset; } + void set_size(uint32_t size) { size_ = size; } + uint32_t alignment() const { return addralign_; } + uint32_t info() const { return info_; } + void set_info(uint32_t info) { info_ = info; } + void set_link(uint32_t link) { link_ = link; } + void set_entry_size(uint64_t entry_size) { entry_size_ = entry_size; } + void RemapLinks(const std::map<size_t, size_t> &index_map); +private: + ELFSegment *parent_; + uint64_t address_; + uint32_t size_; + uint32_t type_; + uint32_t physical_offset_; + uint32_t name_idx_; + std::string name_; + uint32_t link_; + uint32_t info_; + uint32_t addralign_; + uint64_t flags_; + uint64_t entry_size_; +}; + +class ELFStringTable +{ +public: + ELFStringTable *Clone(); + std::string GetString(uint32_t pos) const; + uint32_t AddString(const std::string &str); + void clear(); + void ReadFromFile(ELFArchitecture &file); + void ReadFromFile(ELFArchitecture &file, const ELFSection §ion); + size_t WriteToFile(ELFArchitecture &file); + size_t size() const { return data_.size(); } +private: + std::vector<char> data_; + std::map<std::string, uint32_t> map_; +}; + +class ELFSectionList : public BaseSectionList +{ +public: + explicit ELFSectionList(ELFArchitecture *owner); + explicit ELFSectionList(ELFArchitecture *owner, const ELFSectionList &src); + ELFSection *item(size_t index) const; + virtual ELFSectionList *Clone(ELFArchitecture *owner) const; + void ReadFromFile(ELFArchitecture &file, size_t count); + uint64_t WriteToFile(ELFArchitecture &file); + ELFSection *GetSectionByType(uint32_t type) const; + ELFSection *GetSectionByAddress(uint64_t address) const; + ELFSection *GetSectionByName(const std::string &name) const; + ELFSection *Add(uint64_t address, uint32_t size, uint32_t physical_offset, uint32_t flags, uint32_t type, const std::string &name); + ELFStringTable *string_table() { return &string_table_; } + void RemapLinks(const std::map<size_t, size_t> &index_map); +private: + ELFSection *Add(); + + ELFStringTable string_table_; +}; + +class ELFImportFunction : public BaseImportFunction +{ +public: + explicit ELFImportFunction(ELFImport *owner, uint64_t address, const std::string &name, ELFSymbol *symbol); + explicit ELFImportFunction(ELFImport *owner, uint64_t address, APIType type, MapFunction *map_function); + explicit ELFImportFunction(ELFImport *owner, const ELFImportFunction &src); + virtual ELFImportFunction *Clone(IImport *owner) const; + virtual uint64_t address() const { return address_; } + virtual std::string name() const { return name_; } + virtual std::string display_name(bool show_ret = true) const; + virtual void Rebase(uint64_t delta_base); + void set_address(uint64_t address) { address_ = address; } + ELFSymbol *symbol() const { return symbol_; } + void set_symbol(ELFSymbol *symbol) { symbol_ = symbol; } +private: + uint64_t address_; + std::string name_; + ELFSymbol *symbol_; +}; + +class ELFImport : public BaseImport +{ +public: + explicit ELFImport(ELFImportList *owner, bool is_sdk = false); + explicit ELFImport(ELFImportList *owner, const std::string &name); + explicit ELFImport(ELFImportList *owner, const ELFImport &src); + ELFImportFunction *item(size_t index) const; + ELFImportFunction *GetFunctionBySymbol(ELFSymbol *symbol) const; + virtual ELFImport *Clone(IImportList *owner) const; + virtual std::string name() const { return name_; } + void set_name(const std::string &name) { name_ = name; } + virtual bool is_sdk() const { return is_sdk_; } + void set_is_sdk(bool is_sdk) { is_sdk_ = is_sdk; } + ELFImportFunction *Add(uint64_t address, const std::string &name, ELFSymbol *symbol); +protected: + virtual IImportFunction *Add(uint64_t address, APIType type, MapFunction *map_function); +private: + std::string name_; + bool is_sdk_; +}; + +class ELFImportList : public BaseImportList +{ +public: + explicit ELFImportList(ELFArchitecture *owner); + explicit ELFImportList(ELFArchitecture *owner, const ELFImportList &src); + virtual ELFImportList *Clone(ELFArchitecture *owner) const; + ELFImport *item(size_t index) const; + virtual ELFImportFunction *GetFunctionByAddress(uint64_t address) const; + virtual ELFImport *GetImportByName(const std::string &name) const; + void ReadFromFile(ELFArchitecture &file); + void Pack(); + void WriteToFile(ELFArchitecture &file); +protected: + virtual ELFImport *AddSDK(); +private: + ELFImport *Add(const std::string &name); +}; + +class ELFFixup : public BaseFixup +{ +public: + explicit ELFFixup(ELFFixupList *owner, uint64_t address, OperandSize size); + explicit ELFFixup(ELFFixupList *owner, const ELFFixup &src); + virtual ELFFixup *Clone(IFixupList *owner) const; + virtual uint64_t address() const { return address_; } + virtual FixupType type() const { return ftHighLow; } + virtual OperandSize size() const { return size_; } + virtual void set_address(uint64_t address) { address_ = address; } + virtual void Rebase(IArchitecture &file, uint64_t delta_base); +private: + uint64_t address_; + OperandSize size_; +}; + +class ELFFixupList : public BaseFixupList +{ +public: + explicit ELFFixupList(); + explicit ELFFixupList(const ELFFixupList &src); + virtual ELFFixupList *Clone() const; + ELFFixup *item(size_t index) const; + virtual IFixup *AddDefault(OperandSize cpu_address_size, bool is_code); + ELFFixup *Add(uint64_t address, OperandSize size); + void WriteToData(Data &data, uint64_t image_base); +}; + +class ELFExport : public BaseExport +{ +public: + explicit ELFExport(IExportList *parent, uint64_t address); + explicit ELFExport(IExportList *parent, ELFSymbol *symbol); + explicit ELFExport(IExportList *parent, const ELFExport &src); + ~ELFExport(); + virtual ELFExport *Clone(IExportList *parent) const; + virtual uint64_t address() const { return address_; } + virtual std::string name() const { return name_; } + virtual std::string forwarded_name() const { return std::string(); } + virtual std::string display_name(bool show_ret = true) const; + virtual APIType type() const { return type_; } + virtual void set_type(APIType type) { type_ = type; } + ELFSymbol *symbol() const { return symbol_; } + void set_symbol(ELFSymbol *symbol) { symbol_ = symbol; } + virtual void Rebase(uint64_t delta_base); + void set_address(uint64_t value) { address_ = value; } +private: + ELFSymbol *symbol_; + uint64_t address_; + std::string name_; + APIType type_; +}; + +class ELFExportList : public BaseExportList +{ +public: + explicit ELFExportList(ELFArchitecture *owner); + explicit ELFExportList(ELFArchitecture *owner, const ELFExportList &src); + virtual ELFExportList *Clone(ELFArchitecture *owner) const; + ELFExport *item(size_t index) const; + virtual std::string name() const { return std::string(); } + void ReadFromFile(ELFArchitecture &file); + virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file); + ELFExport *GetExportByAddress(uint64_t address) const; +protected: + virtual IExport *Add(uint64_t address); +private: + ELFExport *Add(ELFSymbol *symbol); +}; + +class ELFSymbol : public ISymbol +{ +public: + explicit ELFSymbol(ELFSymbolList *owner); + explicit ELFSymbol(ELFSymbolList *owner, const ELFSymbol &src); + ~ELFSymbol(); + virtual ELFSymbol *Clone(ELFSymbolList *owner) const; + void ReadFromFile(ELFArchitecture &file, const ELFStringTable &strtab); + size_t WriteToFile(ELFArchitecture &file, ELFStringTable &string_table); + void Rebase(uint64_t delta_base); + uint8_t type() const { return (info_ & 0x0f); } + uint8_t bind() const { return (info_ >> 4); } + void set_bind(uint8_t bind) { info_ = (bind << 4) | (info_ & 0x0f); } + uint64_t address() const { return address_; } + uint64_t value() const { return value_; } + std::string name() const { return name_; } + uint16_t section_idx() const { return section_idx_; } + uint32_t name_idx() const { return name_idx_; } + bool is_deleted() const { return is_deleted_; } + void set_deleted(bool value) { is_deleted_ = value; } + ELFSymbolList *owner() const { return owner_; } + uint16_t version() const { return version_; } + void set_version(uint16_t version) { version_ = version; } + bool need_hash() const { return (type() == STT_TLS) || (value_ && section_idx_); } + size_t size() const { return static_cast<size_t>(size_); } + virtual std::string display_name(bool show_ret = true) const; +private: + ELFSymbolList *owner_; + uint64_t address_; + std::string name_; + uint8_t info_; + uint8_t other_; + uint16_t section_idx_; + uint32_t name_idx_; + uint64_t value_; + uint64_t size_; + bool is_deleted_; + uint16_t version_; +}; + +class ELFSymbolList : public ObjectList<ELFSymbol> +{ +public: + explicit ELFSymbolList(bool is_dynamic); + explicit ELFSymbolList(const ELFSymbolList &src); + virtual ELFSymbolList *Clone() const; + void ReadFromFile(ELFArchitecture &file); + void WriteToFile(ELFArchitecture &file); + void Pack(); + void Rebase(uint64_t delta_base); + ELFStringTable *string_table() { return &string_table_; } +private: + ELFSymbol *Add(); + size_t WriteHash(ELFArchitecture &file); + template <typename T> + size_t WriteGNUHash(ELFArchitecture &file); + size_t WriteVersym(ELFArchitecture &file); + + bool is_dynamic_; + ELFStringTable string_table_; + + // no assignment op + ELFSymbolList &operator =(const ELFSymbolList &); +}; + +class ELFVernaux : public IObject +{ +public: + ELFVernaux(ELFVerneed *owner); + ELFVernaux(ELFVerneed *owner, const ELFVernaux &src); + ~ELFVernaux(); + ELFVernaux *Clone(ELFVerneed *owner) const; + void ReadFromFile(ELFArchitecture &file); + size_t WriteToFile(ELFArchitecture &file); + void WriteStrings(ELFStringTable &string_table); + uint32_t next() const { return next_; } + uint32_t hash() const { return hash_; } + uint16_t other() const { return other_; } + void set_other(uint16_t other) { other_ = other; } +private: + ELFVerneed *owner_; + uint32_t hash_; + uint16_t flags_; + uint16_t other_; + uint32_t name_pos_; + uint32_t next_; + std::string name_; +}; + +class ELFVerneed : public ObjectList<ELFVernaux> +{ +public: + ELFVerneed(ELFVerneedList *owner); + ELFVerneed(ELFVerneedList *owner, const ELFVerneed &src); + ~ELFVerneed(); + ELFVerneed *Clone(ELFVerneedList *owner) const; + void ReadFromFile(ELFArchitecture &file); + size_t WriteToFile(ELFArchitecture &file); + void WriteStrings(ELFStringTable &string_table); + ELFVernaux *GetVernaux(uint32_t hash) const; + uint32_t next() const { return next_; } + std::string file() const { return file_; } +private: + ELFVernaux *Add(); + + ELFVerneedList *owner_; + uint16_t version_; + uint32_t file_pos_; + uint32_t next_; + std::string file_; +}; + +class ELFVerneedList : public ObjectList<ELFVerneed> +{ +public: + explicit ELFVerneedList(); + explicit ELFVerneedList(const ELFVerneedList &src); + ELFVerneedList *Clone() const; + void ReadFromFile(ELFArchitecture &file); + void WriteToFile(ELFArchitecture &file); + void WriteStrings(ELFStringTable &string_table); + ELFVerneed *GetVerneed(const std::string &name) const; +private: + ELFVerneed *Add(); +}; + +class ELFVerdaux : public IObject +{ +public: + ELFVerdaux(ELFVerdef *owner); + ELFVerdaux(ELFVerdef *owner, const ELFVerdaux &src); + ~ELFVerdaux(); + ELFVerdaux *Clone(ELFVerdef *owner) const; + void ReadFromFile(ELFArchitecture &file); + size_t WriteToFile(ELFArchitecture &file); + void WriteStrings(ELFStringTable &string_table); + uint32_t next() const { return next_; } +private: + ELFVerdef *owner_; + uint32_t name_pos_; + uint32_t next_; + std::string name_; +}; + +class ELFVerdef : public ObjectList<ELFVerdaux> +{ +public: + ELFVerdef(ELFVerdefList *owner); + ELFVerdef(ELFVerdefList *owner, const ELFVerdef &src); + ~ELFVerdef(); + ELFVerdef *Clone(ELFVerdefList *owner) const; + void ReadFromFile(ELFArchitecture &file); + size_t WriteToFile(ELFArchitecture &file); + void WriteStrings(ELFStringTable &string_table); + uint32_t next() const { return next_; } +private: + ELFVerdaux *Add(); + + ELFVerdefList *owner_; + uint16_t version_; + uint16_t flags_; + uint16_t ndx_; + uint32_t hash_; + uint32_t next_; +}; + +class ELFVerdefList : public ObjectList<ELFVerdef> +{ +public: + explicit ELFVerdefList(); + explicit ELFVerdefList(const ELFVerdefList &src); + ELFVerdefList *Clone() const; + void ReadFromFile(ELFArchitecture &file); + void WriteToFile(ELFArchitecture &file); + void WriteStrings(ELFStringTable &string_table); +private: + ELFVerdef *Add(); +}; + +class ELFRelocation : public BaseRelocation +{ +public: + explicit ELFRelocation(ELFRelocationList *owner, bool is_rela, uint64_t address, OperandSize size, uint32_t type, ELFSymbol *symbol, uint64_t addend); + explicit ELFRelocation(ELFRelocationList *owner, const ELFRelocation &src); + ELFRelocation *Clone(IRelocationList *owner) const; + size_t WriteToFile(ELFArchitecture &file); + virtual void Rebase(IArchitecture &file, uint64_t delta_base); + ELFSymbol *symbol() const { return symbol_; } + void set_symbol(ELFSymbol *symbol) { symbol_ = symbol; } + bool is_rela() const { return is_rela_; } + uint32_t type() const { return type_; } + void set_type(uint32_t type) { type_ = type; } + uint64_t addend() const { return addend_; } + uint64_t value() const { return value_; } + void set_value(uint64_t value) { value_ = value; } +private: + bool is_rela_; + uint32_t type_; + uint64_t addend_; + ELFSymbol *symbol_; + uint64_t value_; +}; + +class ELFRelocationList : public BaseRelocationList +{ +public: + explicit ELFRelocationList(); + explicit ELFRelocationList(const ELFRelocationList &src); + virtual ELFRelocationList *Clone() const; + ELFRelocation *item(size_t index) const; + ELFRelocation *GetRelocationByAddress(uint64_t address) const; + void ReadFromFile(ELFArchitecture &file); + void WriteToFile(ELFArchitecture &file); + void Pack(); +private: + ELFRelocation *Add(bool is_rela, uint64_t address, OperandSize size, uint32_t type, ELFSymbol *symbol, uint64_t addend); + + // no assignment op + ELFRelocationList &operator =(const ELFRelocationList &); +}; + +class ELFDirectory : public BaseLoadCommand +{ +public: + explicit ELFDirectory(ELFDirectoryList *owner); + explicit ELFDirectory(ELFDirectoryList *owner, size_t type); + explicit ELFDirectory(ELFDirectoryList *owner, const ELFDirectory &src); + virtual ELFDirectory *Clone(ILoadCommandList *owner) const; + virtual uint64_t address() const { return value_; } + virtual uint32_t size() const { return 0; } + virtual uint32_t type() const { return static_cast<uint32_t>(type_); } + virtual std::string name() const; + uint64_t value() const { return value_; } + void set_value(uint64_t value) { value_ = value; } + std::string str_value() const { return str_value_; } + void set_str_value(const std::string &str_value) { str_value_ = str_value; } + void ReadFromFile(ELFArchitecture &file); + size_t WriteToFile(ELFArchitecture &file); + void ReadStrings(ELFStringTable &string_table); + void WriteStrings(ELFStringTable &string_table); + virtual void Rebase(uint64_t delta_base); +private: + uint64_t type_; + uint64_t value_; + std::string str_value_; +}; + +class ELFDirectoryList : public BaseCommandList +{ +public: + explicit ELFDirectoryList(ELFArchitecture *owner); + explicit ELFDirectoryList(ELFArchitecture *owner, const ELFDirectoryList &src); + ELFDirectory *item(size_t index) const; + virtual ELFDirectoryList *Clone(ELFArchitecture *owner) const; + void ReadFromFile(ELFArchitecture &file); + void WriteToFile(ELFArchitecture &file); + ELFDirectory *Add(size_t type); + ELFDirectory *GetCommandByType(uint32_t type) const; + void ReadStrings(ELFStringTable &string_table); + void WriteStrings(ELFStringTable &string_table); +private: + ELFDirectory *Add(); + + // no assignment op + ELFRelocationList &operator =(const ELFRelocationList &); +}; + +class ELFRuntimeFunction : public BaseRuntimeFunction +{ +public: + explicit ELFRuntimeFunction(ELFRuntimeFunctionList *owner, uint64_t address, uint64_t begin, uint64_t end, uint64_t unwind_address, CommonInformationEntry *cie, + const std::vector<uint8_t> &call_frame_instructions); + explicit ELFRuntimeFunction(ELFRuntimeFunctionList *owner, const ELFRuntimeFunction &src); + virtual ELFRuntimeFunction *Clone(IRuntimeFunctionList *owner) const; + virtual uint64_t address() const { return address_; } + virtual uint64_t begin() const { return begin_; } + virtual uint64_t end() const { return end_; } + virtual uint64_t unwind_address() const { return unwind_address_; } + virtual void set_begin(uint64_t begin) { begin_ = begin; } + virtual void set_end(uint64_t end) { end_ = end; } + virtual void set_unwind_address(uint64_t unwind_address) { unwind_address_ = unwind_address; } + void set_address(uint64_t address) { address_ = address; } + CommonInformationEntry *cie() const { return cie_; } + void set_cie(CommonInformationEntry *cie) { cie_ = cie; } + std::vector<uint8_t> call_frame_instructions() const { return call_frame_instructions_; } + virtual void Parse(IArchitecture &file, IFunction &dest); + void Rebase(uint64_t delta_base); +private: + uint64_t address_; + uint64_t begin_; + uint64_t end_; + uint64_t unwind_address_; + CommonInformationEntry *cie_; + std::vector<uint8_t> call_frame_instructions_; +}; + +class ELFRuntimeFunctionList : public BaseRuntimeFunctionList +{ +public: + explicit ELFRuntimeFunctionList(); + explicit ELFRuntimeFunctionList(const ELFRuntimeFunctionList &src); + ~ELFRuntimeFunctionList(); + virtual void clear(); + ELFRuntimeFunctionList *Clone() const; + ELFRuntimeFunction *item(size_t index) const; + void ReadFromFile(ELFArchitecture &file); + void WriteToFile(ELFArchitecture &file); + void Rebase(uint64_t delta_base); + virtual ELFRuntimeFunction *Add(uint64_t address, uint64_t begin, uint64_t end, uint64_t unwind_address, IRuntimeFunction *source, const std::vector<uint8_t> &call_frame_instructions); + virtual ELFRuntimeFunction *GetFunctionByAddress(uint64_t address) const; + CommonInformationEntryList *cie_list() const { return cie_list_; } +private: + ELFRuntimeFunction *Add(uint64_t address, uint64_t begin, uint64_t end, uint64_t unwind_address, CommonInformationEntry *cie, const std::vector<uint8_t> &call_frame_instructions); + + CommonInformationEntryList *cie_list_; + uint8_t version_; + uint8_t eh_frame_encoding_; + uint8_t fde_count_encoding_; + uint8_t fde_table_encoding_; + + // no assignment op + ELFRuntimeFunctionList &operator =(const ELFRuntimeFunctionList &); +}; + +class ELFArchitecture : public BaseArchitecture +{ +public: + explicit ELFArchitecture(ELFFile *owner, uint64_t offset, uint64_t size); + explicit ELFArchitecture(ELFFile *owner, const ELFArchitecture &src); + virtual ~ELFArchitecture(); + virtual std::string name() const; + virtual uint32_t type() const { return cpu_; } + virtual OperandSize cpu_address_size() const { return cpu_address_size_; } + virtual uint64_t entry_point() const { return entry_point_; } + virtual uint64_t image_base() const { return image_base_; } + uint16_t file_type() const { return file_type_; } + uint32_t segment_alignment() const { return segment_alignment_; } + uint32_t file_alignment() const { return file_alignment_; } + virtual ELFDirectoryList *command_list() const { return directory_list_; } + virtual ELFSegmentList *segment_list() const { return segment_list_; } + virtual ELFImportList *import_list() const { return import_list_; } + virtual ELFExportList *export_list() const { return export_list_; } + virtual ELFFixupList *fixup_list() const { return fixup_list_; } + virtual ELFRelocationList *relocation_list() const { return relocation_list_; } + virtual IResourceList *resource_list() const { return NULL; } + virtual ISEHandlerList *seh_handler_list() const { return NULL; } + virtual ELFRuntimeFunctionList *runtime_function_list() const { return runtime_function_list_; } + virtual IFunctionList *function_list() const { return function_list_; } + virtual IVirtualMachineList *virtual_machine_list() const { return virtual_machine_list_; } + virtual ELFSectionList *section_list() const { return section_list_; } + OpenStatus ReadFromFile(uint32_t mode); + virtual bool WriteToFile(); + virtual IArchitecture *Clone(IFile *file) const; + virtual ELFArchitecture *Clone(ELFFile *file) const; + virtual void Save(CompileContext &ctx); + virtual bool is_executable() const; + size_t shstrndx() { return shstrndx_; } + virtual CallingConvention calling_convention() const { return cpu_address_size() == osDWord ? ccCdecl : ccABIx64; } + void Rebase(uint64_t delta_base); + ELFSymbolList *dynsymbol_list() const { return dynsymbol_list_; } + ELFSymbolList *symbol_list() const { return symbol_list_; } + ELFVerneedList *verneed_list() const { return verneed_list_; } + ELFVerdefList *verdef_list() const { return verdef_list_; } + ELFSegment *header_segment() const { return header_segment_; } + uint32_t max_header_size() const { return header_size_ + resize_header_; } +protected: + virtual bool Prepare(CompileContext &ctx); +private: + ELFDirectoryList *directory_list_; + ELFSegmentList *segment_list_; + ELFSectionList *section_list_; + ELFImportList *import_list_; + ELFExportList *export_list_; + ELFFixupList *fixup_list_; + ELFRelocationList *relocation_list_; + ELFRuntimeFunctionList *runtime_function_list_; + IFunctionList *function_list_; + IVirtualMachineList *virtual_machine_list_; + + uint16_t cpu_; + uint16_t file_type_; + OperandSize cpu_address_size_; + uint64_t image_base_; + uint64_t entry_point_; + uint32_t segment_alignment_; + uint32_t file_alignment_; + uint16_t shstrndx_; + uint64_t shoff_; + uint32_t header_offset_; + uint32_t header_size_; + uint32_t resize_header_; + ELFSymbolList *dynsymbol_list_; + ELFSymbolList *symbol_list_; + ELFVerneedList *verneed_list_; + ELFVerdefList *verdef_list_; + ELFSegment *header_segment_; + uint64_t overlay_offset_; + + // no copy ctr or assignment op + ELFArchitecture(const ELFArchitecture &); + ELFArchitecture &operator =(const ELFArchitecture &); +}; + +class ELFFile : public IFile +{ +public: + explicit ELFFile(ILog *log); + explicit ELFFile(const ELFFile &src, const char *file_name); + virtual ~ELFFile(); + virtual std::string format_name() const; + ELFArchitecture *item(size_t index) const; + ELFFile *Clone(const char *file_name) const; + virtual bool Compile(CompileOptions &options); + virtual bool is_executable() const; + virtual uint32_t disable_options() const; +protected: + virtual OpenStatus ReadHeader(uint32_t open_mode); + virtual IFile *runtime() const { return runtime_; } +private: + ELFArchitecture *Add(uint64_t offset, uint64_t size); + + ELFFile *runtime_; + + // no copy ctr or assignment op + ELFFile(const ELFFile &); + ELFFile &operator =(const ELFFile &); +}; + +#endif
\ No newline at end of file |