haiku.git

//------------------------------------------------------------------------------
//	Copyright (c) 2003, Ingo Weinhold
//
//	Permission is hereby granted, free of charge, to any person obtaining a
//	copy of this software and associated documentation files (the "Software"),
//	to deal in the Software without restriction, including without limitation
//	the rights to use, copy, modify, merge, publish, distribute, sublicense,
//	and/or sell copies of the Software, and to permit persons to whom the
//	Software is furnished to do so, subject to the following conditions:
//
//	The above copyright notice and this permission notice shall be included in
//	all copies or substantial portions of the Software.
//
//	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
//	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
//	DEALINGS IN THE SOFTWARE.
//
//	File Name:		ElfFile.h
//	Author:			Ingo Weinhold (bonefish@users.sf.net)
//	Description:	Interface declarations of classes for accessing ELF file,
//					or more precisely for iterating through their relocation
//					sections.
//------------------------------------------------------------------------------

#ifndef ELF_FILE_H
#define ELF_FILE_H

#include <File.h>
#include <image.h>

#include "Elf.h"


namespace SymbolPatcher {

class ElfFile;
class ElfSection;

// ElfSymbol
class ElfSymbol {
public:
								ElfSymbol(ElfSection* section = NULL,
										  int32 index = -1);
								~ElfSymbol();

			void				SetTo(ElfSection* section, int32 index);
			void				Unset();

			const Elf_Sym*	GetSymbolStruct();
			const char*			GetName();
			uint32				GetBinding();
			uint32				GetType();
			uint32				GetTargetSectionIndex();

private:
			ElfSection*			fSection;
			int32				fIndex;
			Elf_Sym*			fSymbol;
};

// ElfRelocation
class ElfRelocation {
public:
								ElfRelocation(ElfSection* section = NULL,
											  int32 index = -1);
								~ElfRelocation();

			void				SetTo(ElfSection* section, int32 index);
			void				Unset();

			Elf_Rel*			GetRelocationStruct();
			uint32				GetType();
			uint32				GetSymbolIndex();
			Elf_Addr			GetOffset();
			status_t			GetSymbol(ElfSymbol* symbol);

private:
			ElfSection*			fSection;
			int32				fIndex;
			Elf_Rel*			fRelocation;
};

// ElfRelocationIterator
class ElfRelocationIterator {
public:
								ElfRelocationIterator(ElfFile* file);
								~ElfRelocationIterator();

			bool				GetNext(ElfRelocation* relocation);

private:
			ElfSection*			_FindNextSection();

private:
			ElfFile*			fFile;
			int32				fSectionIndex;
			int32				fEntryIndex;
};

// ElfFile
class ElfFile {
public:
								ElfFile();
								~ElfFile();
			status_t			SetTo(const char *filename);
			void				Unset();
			void				Unload();

			BFile*				GetFile()	{ return &fFile; }

			const char*			GetSectionHeaderStrings(size_t* size);
			const char*			GetStringSectionStrings(int32 index,
														size_t* size);

			int32				CountSections() const { return fSectionCount; }
			ElfSection*			SectionAt(int32 index, bool load = false);

			void				Dump();

private:
			status_t			_SetTo(const char *filename);

			Elf_Shdr*			_SectionHeaderAt(int32 index);

			status_t			_LoadSection(int32 index);

private:
			BFile				fFile;
			Elf_Ehdr			fHeader;
			uint8*				fSectionHeaders;
			ElfSection*			fSections;
			int32				fSectionCount;
			size_t				fSectionHeaderSize;
};

} // namespace SymbolPatcher

using namespace SymbolPatcher;


#endif	// ELF_FILE_H