/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

* 

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef ELFSYMBOLTABLEMANAGER_H_

#define ELFSYMBOLTABLEMANAGER_H_

#include <vector>

#include <cassert>

#include "filefragment.h"

#include "elfstringtable.h"

#include "outputfile.h"

#include "elfheader.h"

#include "e32romimage.h"

#include "elfsection.h"

#include "elfsectionmanager.h"

#include "defs.h" // String

class ElfSymbolTableManager;

class SectionNumberMapping {

public:

	SectionNumberMapping(size_t aOld, size_t aNew):

		iOld(aOld), iNew(aNew)

		{}

	SectionNumberMapping & operator=(const SectionNumberMapping & aSectionNumberMapping){

		iOld = aSectionNumberMapping.iOld;

		iNew = aSectionNumberMapping.iNew;

		return *this;

	}

	SectionNumberMapping(const SectionNumberMapping & aSectionNumberMapping){

		*this = aSectionNumberMapping;

	}

	size_t iOld;

	size_t iNew;

};

typedef std::vector< SectionNumberMapping > SectionNumberMap;

class SectionVaddrAddendMapping {

public:

	SectionVaddrAddendMapping(size_t aSectionNumber, signed int aAddend):

		iSectionNumber(aSectionNumber), iAddend(aAddend)

		{}

	SectionVaddrAddendMapping & operator=(const SectionVaddrAddendMapping & aSectionVaddrAddendMapping){

		iSectionNumber = aSectionVaddrAddendMapping.iSectionNumber;

		iAddend = aSectionVaddrAddendMapping.iAddend;

		return *this;

	}

	SectionVaddrAddendMapping(const SectionVaddrAddendMapping & SectionVaddrAddendMapping){

		*this = SectionVaddrAddendMapping;

	}

	size_t iSectionNumber;

	signed int iAddend;

};

typedef std::vector< SectionVaddrAddendMapping > SectionVaddrAddendMap;

class ElfFileSymbolFragments {

public:

	ElfFileSymbolFragments(ElfSymbolTableManager * aElfSymbolTableManager):

		iPath(""), 

		iSymbolTableOffset(0), iSymbolTableSize(0),

		iFirstGlobal(0),

		iStringTableOffset(0), iStringTableSize(0),

		iElfSymbolTableManager(aElfSymbolTableManager)

		{

		iSectionNumberMap.clear();

		iSectionVaddrAddendMap.clear();

		}

	ElfFileSymbolFragments & operator=(const ElfFileSymbolFragments & aElfFileSymbolFragments){

		iPath = aElfFileSymbolFragments.iPath;

		iSymbolTableOffset = aElfFileSymbolFragments.iSymbolTableOffset;

		iSymbolTableSize = aElfFileSymbolFragments.iSymbolTableSize;

		iFirstGlobal = aElfFileSymbolFragments.iFirstGlobal;

		iStringTableOffset = aElfFileSymbolFragments.iStringTableOffset;

		iStringTableSize = aElfFileSymbolFragments.iStringTableSize;

		iSectionNumberMap = aElfFileSymbolFragments.iSectionNumberMap;

		iSectionVaddrAddendMap = aElfFileSymbolFragments.iSectionVaddrAddendMap;

		iElfSymbolTableManager = aElfFileSymbolFragments.iElfSymbolTableManager;

		return *this;

	}

	ElfFileSymbolFragments(const ElfFileSymbolFragments & aElfFileSymbolFragments){

		*this = aElfFileSymbolFragments;

	}

	void AddSymbolTable(String & aPath, size_t aOffset, size_t aSize, size_t aFirstGlobal);

	void AddStringTable(String & aPath, size_t aOffset, size_t aSize);

	String & GetPath() { return iPath; }

	size_t GetSymbolTableOffset() { return iSymbolTableOffset; }

	size_t GetSymbolTableSize() { return iSymbolTableSize; }

	size_t GetFirstGlobal() { return iFirstGlobal; }

	size_t GetStringTableOffset() { return iStringTableOffset; }

	size_t GetStringTableSize() { return iStringTableSize; }

	void SetSectionNumberMap(SectionNumberMap & aSectionNumberMap){

		iSectionNumberMap = aSectionNumberMap;

	}

	size_t LookupSection(size_t ndx);

	void SetSectionVaddrAddendMap(SectionVaddrAddendMap & aSectionVaddrAddendMap){

		iSectionVaddrAddendMap = aSectionVaddrAddendMap;

	}

	int LookupVaddrAddend(size_t ndx);

	void Validate() {

		assert(iPath.size() != 0);

		assert(iSymbolTableOffset != 0);

		assert(iSymbolTableSize != 0);

		assert(iStringTableOffset != 0);

		assert(iStringTableSize != 0);

		assert(!iSectionNumberMap.empty());

		assert(!iSectionVaddrAddendMap.empty());

	}

	void Reset(){

		new (this) ElfFileSymbolFragments(iElfSymbolTableManager);

	}

private:

	String iPath;

	size_t iSymbolTableOffset;

	size_t iSymbolTableSize;

	size_t iFirstGlobal;

	size_t iStringTableOffset;

	size_t iStringTableSize;

	SectionNumberMap iSectionNumberMap;

	SectionVaddrAddendMap iSectionVaddrAddendMap;

	ElfSymbolTableManager * iElfSymbolTableManager;

};

class ElfSymTabStringTable : public ElfStringTable {

public:

	ElfSymTabStringTable(ElfSymbolTableManager & aElfSymbolTableManager):

		iElfSymbolTableManager(aElfSymbolTableManager)

		{}

	virtual size_t Size();

private:

	ElfSymbolTableManager & iElfSymbolTableManager;

};

class ElfSymbolTableManager : public FileFragmentOwner {

public:

	ElfSymbolTableManager(Elf32Header & aElf32Header, E32RomImage & aRomImage, 

					      OutputFile & aOutputFile, ElfSectionManager & aElfSectionManager) :

		iElf32Header(aElf32Header), iRomImage(aRomImage), 

		iOutputFile(aOutputFile), iElfSectionManager(aElfSectionManager),

		iData(NULL),

		iSymbolStringTableSizeValid(false),

		iSymbolStringTableSize(0),

		iCurrentFragment(this),

		iStringTable(*this)

		{}

	// The FileFragmentOwner protocol

	virtual void GetFileFragmentData(FileFragmentData & aFileFragmentData );

	virtual size_t Size();

	virtual void DeleteFileFragmentData();

	virtual void AddData(OutputFile & aOutputFile);

	void AddSymbolTable(String & aPath, size_t aOffset, size_t aSize, size_t aFirstGlobal){

		iCurrentFragment.AddSymbolTable(aPath, aOffset, aSize, aFirstGlobal);

	}

	void AddStringTable(String & aPath, size_t aOffset, size_t aSize){

		iCurrentFragment.AddStringTable(aPath, aOffset, aSize);

	}

	virtual void AddSymbolFragment(){

		iSymbolFragments.push_back(iCurrentFragment);

	}

	virtual void AddSymbolTable();

	size_t GetSymTabStringsSectionSize();

	virtual void Finalize(SectionNumberMap & aSectionNumberMap, SectionVaddrAddendMap & aSectionVaddrAddendMap);

private:

	// Don't want one of these to be copied

	ElfSymbolTableManager(const ElfSymbolTableManager & aElfSymbolTableManager);

	ElfSymbolTableManager & operator=(const ElfSymbolTableManager & aElfSymbolTableManager);

	size_t GetSymTabSectionSize();

	size_t GetFirstNonLocalIndex();

private:

	typedef std::vector<ElfFileSymbolFragments> SymbolFragmentList;

private:

	Elf32Header & iElf32Header;

	E32RomImage & iRomImage;

	OutputFile & iOutputFile;

	ElfSectionManager & iElfSectionManager;

	char * iData;

	bool iSymbolStringTableSizeValid;

	size_t iSymbolStringTableSize;

	ElfFileSymbolFragments iCurrentFragment;

	SymbolFragmentList iSymbolFragments;

	ElfSymTabStringTable iStringTable;

};

#endif /*ELFSYMBOLTABLEMANAGER_H_*/