haiku.git

/*
 * Copyright 2009-2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef ELF_FILE_H
#define ELF_FILE_H

#include <sys/types.h>

#include <ByteOrder.h>
#include <SupportDefs.h>
#include <ObjectList.h>

#include <elf_private.h>
#include <util/DoublyLinkedList.h>

#include "Types.h"


class ElfSymbolLookup;
class ElfSymbolLookupSource;


class ElfSection {
public:
								ElfSection(const char* name, uint32 type,
									int fd, uint64 offset, uint64 size,
									target_addr_t loadAddress, uint32 flags,
									uint32 linkIndex);
								~ElfSection();

			const char*			Name() const	{ return fName; }
			uint32				Type() const	{ return fType; }
			uint64				Offset() const	{ return fOffset; }
			uint64				Size() const	{ return fSize; }
			const void*			Data() const	{ return fData; }
			target_addr_t		LoadAddress() const
									{ return fLoadAddress; }
			bool				IsWritable() const
									{ return (fFlags & SHF_WRITE) != 0; }

			status_t			Load();
			void				Unload();
			bool				IsLoaded() const	{ return fLoadCount > 0; }
			uint32				LinkIndex() const	{ return fLinkIndex; }

private:
			const char*			fName;
			uint32				fType;
			int					fFD;
			uint64				fOffset;
			uint64				fSize;
			void*				fData;
			target_addr_t		fLoadAddress;
			uint32				fFlags;
			int32				fLoadCount;
			uint32				fLinkIndex;
};


class ElfSegment {
public:
								ElfSegment(uint32 type, uint64 fileOffset,
									uint64 fileSize, target_addr_t loadAddress,
									target_size_t loadSize, uint32 flags);
								~ElfSegment();

			uint32				Type()				{ return fType; }
			uint64				FileOffset() const	{ return fFileOffset; }
			uint64				FileSize() const	{ return fFileSize; }
			target_addr_t		LoadAddress() const	{ return fLoadAddress; }
			target_size_t		LoadSize() const	{ return fLoadSize; }
			uint32				Flags() const		{ return fFlags; }
			bool				IsWritable() const
									{ return (fFlags & PF_WRITE) != 0; }

private:
			uint64				fFileOffset;
			uint64				fFileSize;
			target_addr_t		fLoadAddress;
			target_size_t		fLoadSize;
			uint32				fType;
			uint32				fFlags;
};


struct ElfClass32 {
	typedef uint32					Address;
	typedef uint32					Size;
	typedef Elf32_Ehdr				Ehdr;
	typedef Elf32_Phdr				Phdr;
	typedef Elf32_Shdr				Shdr;
	typedef Elf32_Sym				Sym;
	typedef Elf32_Nhdr				Nhdr;
	typedef Elf32_Note_Team			NoteTeam;
	typedef Elf32_Note_Area_Entry	NoteAreaEntry;
	typedef Elf32_Note_Image_Entry	NoteImageEntry;
	typedef Elf32_Note_Thread_Entry	NoteThreadEntry;
};


struct ElfClass64 {
	typedef uint64					Address;
	typedef uint64					Size;
	typedef Elf64_Ehdr				Ehdr;
	typedef Elf64_Phdr				Phdr;
	typedef Elf64_Shdr				Shdr;
	typedef Elf64_Sym				Sym;
	typedef Elf64_Nhdr				Nhdr;
	typedef Elf64_Note_Team			NoteTeam;
	typedef Elf64_Note_Area_Entry	NoteAreaEntry;
	typedef Elf64_Note_Image_Entry	NoteImageEntry;
	typedef Elf64_Note_Thread_Entry	NoteThreadEntry;
};


class ElfFile {
public:
								ElfFile();
								~ElfFile();

			status_t			Init(const char* fileName);

			int					FD() const	{ return fFD; }

			bool				Is64Bit() const	{ return f64Bit; }
			bool				IsByteOrderSwapped() const
									{ return fSwappedByteOrder; }
			uint16				Type() const	{ return fType; }
			uint16				Machine() const	{ return fMachine; }

			int32				CountSection() const
									{ return fSections.CountItems(); }
			ElfSection*			SectionAt(int32 index) const
									{ return fSections.ItemAt(index); }
			ElfSection*			GetSection(const char* name);
			void				PutSection(ElfSection* section);
			ElfSection*			FindSection(const char* name) const;
			ElfSection*			FindSection(uint32 type) const;

			int32				CountSegments() const
									{ return fSegments.CountItems(); }
			ElfSegment*			SegmentAt(int32 index) const
									{ return fSegments.ItemAt(index); }

			ElfSegment*			TextSegment() const;
			ElfSegment*			DataSegment() const;

			ElfSymbolLookupSource* CreateSymbolLookupSource(uint64 fileOffset,
									uint64 fileLength,
									uint64 memoryAddress) const;
			status_t			CreateSymbolLookup(uint64 textDelta,
									ElfSymbolLookup*& _lookup) const;

			template<typename Value>
			Value				Get(const Value& value) const
									{ return StaticGet(value,
										fSwappedByteOrder); }

	template<typename Value>
	static	Value				StaticGet(const Value& value,
									bool swappedByteOrder);

private:
			struct SymbolLookupSource;

			typedef BObjectList<ElfSection, true> SectionList;
			typedef BObjectList<ElfSegment, true> SegmentList;

private:
			template<typename ElfClass>
			status_t			_LoadFile(const char* fileName);

			bool				_FindSymbolSections(ElfSection*& _symbolSection,
									ElfSection*& _stringSection,
									uint32 type) const;

			bool				_CheckRange(uint64 offset, uint64 size) const;

			template<typename ElfClass>
			bool				_CheckElfHeader(
									typename ElfClass::Ehdr& elfHeader);

	static	uint8				_Swap(const uint8& value)
									{ return value; }
	static	uint16				_Swap(const uint16& value)
									{ return (uint16)B_SWAP_INT16(value); }
	static	int32				_Swap(const int32& value)
									{ return B_SWAP_INT32(value); }
	static	uint32				_Swap(const uint32& value)
									{ return (uint32)B_SWAP_INT32(value); }
	static	int64				_Swap(const int64& value)
									{ return B_SWAP_INT64(value); }
	static	uint64				_Swap(const uint64& value)
									{ return (uint64)B_SWAP_INT64(value); }

private:
			uint64				fFileSize;
			int					fFD;
			uint16				fType;
			uint16				fMachine;
			bool				f64Bit;
			bool				fSwappedByteOrder;
			SectionList			fSections;
			SegmentList			fSegments;
};


template<typename Value>
/*static*/ inline Value
ElfFile::StaticGet(const Value& value, bool swappedByteOrder)
{
	if (!swappedByteOrder)
		return value;
	return _Swap(value);
}


#endif	// ELF_FILE_H