/*

* 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 DWARFMANAGER_H_

#define DWARFMANAGER_H_

#include <vector>

#include <map>

#include <string>

#include <libelf.h>

#include "dwarfdefs.h"

#include "dwarf.h"

#include "defs.h"

#include "filefragment.h"

#include "romdetails.h"

#include "elfsectionmanager.h"

using namespace std;

class FileShdrPair {

public:

	FileShdrPair(XIPFileDetails & aXIPFileDetails, Elf32_Shdr * aShdr):

		iXIPFileDetails(aXIPFileDetails),

		iShdr(*aShdr)

	{}

	FileShdrPair & FileShdrPair::operator=(const FileShdrPair & aFileShdrPair) {

		iXIPFileDetails = aFileShdrPair.iXIPFileDetails;

		iShdr = aFileShdrPair.iShdr;

		return *this;

	}

	FileShdrPair::FileShdrPair(const FileShdrPair &aFileShdrPair):

		iXIPFileDetails(aFileShdrPair.iXIPFileDetails),

		iShdr(aFileShdrPair.iShdr)

	{}

	XIPFileDetails & iXIPFileDetails;

	Elf32_Shdr iShdr;

};

typedef std::vector<FileShdrPair> FileShdrList;

void EditLocationExpression (Dwarf_Byte_Ptr data, 

							 unsigned int pointer_size, 

							 unsigned long length, 

							 FileShdrPair & aPair);

class DwarfManager;

class DwarfSectionManager : public FileFragmentOwner {

public:

	DwarfSectionManager(ElfSectionManager & aElfSectionManager, 

						DwarfManager & aDwarfManager, 

						const string & aName, 

						RomDetails * aRomDetails):

		iElfSectionManager(aElfSectionManager),

		iDwarfManager(aDwarfManager),

		iSectionName(aName),

		iSizeValid(false),

		iSize(0),

		iData(NULL),

		iRomDetails(aRomDetails)

	{}

	virtual ~DwarfSectionManager() {

		iFileShdrList.clear();

	}

	// The FileFragmentOwner protocol

	virtual void DeleteFileFragmentData(){

		if (iData) {

			Dwarf_Byte_Ptr d = iData;

			iData = NULL;

			delete [] d;

		}

	}

	virtual void AddSection(XIPFileDetails & aXIPFileDetails, Elf32_Shdr * aShdr);

	virtual void SetupSection();

	const string & GetSectionName() { return iSectionName; }

	virtual Dwarf_Byte_Ptr GetSectionData(FileShdrPair & aPair);

	// LEB decoding

	// Leb128 decoding used by all Dwarf section managers (potentially)

	// TODO could get rid of LEB macros and define as inline functions.

#define DECODE_ULEB128(v,p,n) \

		Dwarf_Word v = DwarfSectionManager::DecodeUnsignedLeb128(p, n);\

		p += n;

#define ULEB128(p,n) \

		DwarfSectionManager::DecodeUnsignedLeb128(p, n);\

		p += n;

	static Dwarf_Unsigned DecodeUnsignedLeb128(Dwarf_Byte_Ptr leb128, size_t & leb128_length);

#define DECODE_SLEB128(v,p,n) \

		Dwarf_Word v = DwarfSectionManager::DecodeSignedLeb128(p, n);\

		p += n;

#define SLEB128(p,n) \

		DwarfSectionManager::DecodeSignedLeb128(p, n);\

		p += n;

	static Dwarf_Signed DecodeSignedLeb128(Dwarf_Byte_Ptr leb128, size_t & leb128_length);

private:

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

	DwarfSectionManager(const DwarfSectionManager & aDwarfSectionManager);

	DwarfSectionManager & operator=(const DwarfSectionManager & aDwarfSectionManager);

protected:

	virtual Dwarf_Byte_Ptr GetData(){ return iData; }

	virtual void SetData(Dwarf_Byte_Ptr data) { iData = data; }

	size_t CheckNewOffset(size_t base, size_t offset){

		const Dwarf_Off limit = 0xfffffff0ul;

		Dwarf_Off newOffset = base + offset;

		if (newOffset >= limit) {

			cerr << "Error: cannot support transition from 32 to 64 bit offsets\n";

			exit(EXIT_FAILURE);

		}

		return (size_t)newOffset;

	}

protected:

	ElfSectionManager & iElfSectionManager;

	DwarfManager & iDwarfManager;

	FileShdrList iFileShdrList;

	const string iSectionName;

	bool iSizeValid;

	size_t iSize;

	Dwarf_Byte_Ptr iData;

	RomDetails * iRomDetails;

};

class DwarfConcatenatedSectionManager : public DwarfSectionManager {

public:

	DwarfConcatenatedSectionManager(ElfSectionManager & aElfSectionManager, 

									DwarfManager & aDwarfManager, 

									const string & aName, 

									RomDetails * aRomDetails):

		DwarfSectionManager(aElfSectionManager, 

							aDwarfManager, 

							aName, 

							aRomDetails)

	{}

	// The FileFragmentOwner protocol

	virtual void GetFileFragmentData(FileFragmentData & aFileFragmentData );

	virtual size_t Size();

	virtual void ConcatenateData();

	virtual void ProcessSection(FileShdrPair & aPair);

	virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end){};

	// Concatenated section protocol

	virtual void SetSectionOffset(PathName & aPathName, size_t aOffset);

	virtual void InitOffsetMap();

	virtual size_t GetSectionOffset(PathName & aPathName);

	virtual void SetSectionSize(PathName & aPathName, size_t aSize);

	virtual size_t GetSectionSize(PathName & aPathName);

	Dwarf_Byte_Ptr GetSection(PathName & aPathName);

protected:

	typedef std::map<PathName, size_t> PathNameSectionOffsetMap;

	PathNameSectionOffsetMap iPathNameSectionOffsetMap;

	PathNameSectionOffsetMap iPathNameSectionSizeMap;

};

class DwarfFragmentedSectionManager : public DwarfConcatenatedSectionManager {

public:

	DwarfFragmentedSectionManager(ElfSectionManager & aElfSectionManager, 

									DwarfManager & aDwarfManager, 

									const string & aName, 

									RomDetails * aRomDetails):

		DwarfConcatenatedSectionManager(aElfSectionManager, 

										aDwarfManager, 

										aName, 

										aRomDetails),

		iInitialTraceMessage(true)

	{}

	// Override the method of setting up the section

	virtual void SetupSection();

	// The FileFragmentOwner protocol

	virtual void GetFileFragmentData(FileFragmentData & aFileFragmentData );

	//virtual size_t Size();

	virtual void ConcatenateData();

	void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr & aData);

	virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end) = 0;

private:

	bool iInitialTraceMessage;

};

class DebugAbbrevAttrForm {

public:

	DebugAbbrevAttrForm():

			iAttr(0),

			iForm(0)

		{}

	DebugAbbrevAttrForm(Dwarf_Half a, Dwarf_Half f):

		iAttr(a),

		iForm(f)

	{}

	Dwarf_Half iAttr;

	Dwarf_Half iForm;

};

class DebugAbbrev {

public:

	DebugAbbrev():

		iCode(0),

		iTag(0),

		iCount(0),

		iRaw(NULL),

		iParsed(NULL)

		{}

	DebugAbbrev(Dwarf_Unsigned c, Dwarf_Unsigned t, size_t n, Dwarf_Byte_Ptr r, DebugAbbrevAttrForm * p):

			iCode(c),

			iTag(t),

			iCount(n),

			iRaw(r),

			iParsed(p)

			{}

	DebugAbbrev & operator=(const DebugAbbrev & aDebugAbbrev){

		iCode = aDebugAbbrev.iCode;

		iTag = aDebugAbbrev.iTag;

		iCount = aDebugAbbrev.iCount;

		iRaw = aDebugAbbrev.iRaw;

		iParsed = aDebugAbbrev.iParsed;

		return *this;

	}

	DebugAbbrev(const DebugAbbrev & aDebugAbbrev){

		*this = aDebugAbbrev;

	}

	void Destroy(){

		if (iParsed){

			DebugAbbrevAttrForm * d = iParsed;

			iParsed = NULL;

			delete [] d;

		}

	}

#if 0

	// can't have default dtor do anything until and unless we prevent iParsed getting deleted

	// whenever the class is copied in STL containers.

	~DebugAbbrev(){

		if (iParsed){

			DebugAbbrevAttrForm * d = iParsed;

			iParsed = NULL;

			delete [] d;

		}

	}

#endif

	Dwarf_Unsigned iCode;

	Dwarf_Unsigned iTag;

	size_t iCount;

	Dwarf_Byte_Ptr iRaw;

	DebugAbbrevAttrForm * iParsed;

};

class InfoContext {

private:

	typedef std::map<Dwarf_Word, DebugAbbrev> AbbrevMap;

	class AbbrevMapEntry {

	public:

		AbbrevMapEntry():

					iCursor(NULL),

					iMap(NULL)

				{}

		AbbrevMapEntry(Dwarf_Byte_Ptr c, AbbrevMap * m):

			iCursor(c),

			iMap(m)

		{}

		Dwarf_Byte_Ptr iCursor;

		AbbrevMap * iMap;

	};

	typedef std::map<Uint32, AbbrevMapEntry> AbbrevOffsetMap;

public:

	InfoContext():

		iContextValid(false),

		iSectionStart(NULL),

		iSectionEnd(NULL),

		iSectionOffset(0),

		// this is an invalid offset for 32 bit dwarf

		// and will trigger the right behaviour in SetAbbrevOffset

		// when called from Init

		iAbbrevOffset(0xffffffff), 

		iAbbrevMapEntry(NULL, NULL)

	{

		//ClearMap();

	}

	~InfoContext(){

		Reset();

	}

	void Init(Dwarf_Byte_Ptr s, Dwarf_Byte_Ptr e, size_t o){

		iSectionStart = s;

		iSectionEnd = e;

		iSectionOffset = o;

		//ClearMap();

		iContextValid = true;

		SetAbbrevOffset(0);

	}

	void Reset(){

		iContextValid = false;

		iSectionStart = iSectionEnd = NULL;

		iSectionOffset = 0;

		iAbbrevOffset = 0xffffffff;

		ClearMap();

	}

	void ClearMap() {

		for (AbbrevOffsetMap::iterator i = iMap.begin(); i != iMap.end(); i++){

			AbbrevMap::iterator e = i->second.iMap->end();

			for (AbbrevMap::iterator b = i->second.iMap->begin(); b != e; b++){

				b->second.Destroy();

			}

			i->second.iMap->clear();

		}

		iMap.clear();

	}

	size_t GetSectionOffset(){ return iSectionOffset; }

	void SetAbbrevOffset(size_t offset);

	DebugAbbrev & GetAbbrev(Dwarf_Word aCode);

	DebugAbbrev & FindAbbrev(Dwarf_Word aCode);

	bool iContextValid;

	Dwarf_Byte_Ptr iSectionStart;

	Dwarf_Byte_Ptr iSectionEnd;

	size_t iSectionOffset;

	size_t iAbbrevOffset;

	AbbrevMapEntry iAbbrevMapEntry;

	AbbrevOffsetMap iMap;

};

class DwarfAbbrevManager : public DwarfConcatenatedSectionManager {

public:

	DwarfAbbrevManager(ElfSectionManager & aElfSectionManager, 

					   DwarfManager & aDwarfManager, 

					   RomDetails * aRomDetails):

		DwarfConcatenatedSectionManager(aElfSectionManager, 

										aDwarfManager, 

										iAbbrevSectionName, 

										aRomDetails)

	{}

	// we might need to hang onto this after its been written to file

	virtual void DeleteFileFragmentData(){}

	void StartContext(PathName & aName);

	void EndContext();

	void SetContextAbbrevOffset(Uint32 offset);

	size_t GetContextSectionOffset();

	DebugAbbrev & GetAbbrev(Dwarf_Word aCode);

private:

	static const string iAbbrevSectionName;

	InfoContext iInfoContext;

};

class DwarfMacinfoManager : public DwarfFragmentedSectionManager {

public:

	DwarfMacinfoManager(ElfSectionManager & aElfSectionManager, 

						DwarfManager & aDwarfManager, 

						RomDetails * aRomDetails):

		DwarfFragmentedSectionManager(aElfSectionManager, 

									  aDwarfManager, 

									  iMacinfoSectionName, 

									  aRomDetails)

	{}

	virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end){};

private:

	static const string iMacinfoSectionName;	

};

//class DwarfInfoManager : public DwarfConcatenatedSectionManager {

class DwarfInfoManager : public DwarfFragmentedSectionManager {

public:

	DwarfInfoManager(ElfSectionManager & aElfSectionManager, 

					 DwarfManager & aDwarfManager, 

					 DwarfAbbrevManager & aDwarfAbbrevManager, 

					 DwarfMacinfoManager & aDwarfMacinfoManager, 

					 RomDetails * aRomDetails):

		DwarfFragmentedSectionManager(aElfSectionManager, 

										aDwarfManager, 

										iInfoSectionName, 

										aRomDetails),

		iDwarfAbbrevManager(aDwarfAbbrevManager),

		iDwarfMacinfoManager(aDwarfMacinfoManager),

		iAddressSize(4),

		iLocalLength(0)

	{}

	virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end);

	size_t GetPointerSize() { return iAddressSize; }

private:

	Dwarf_Byte_Ptr ProcessCU(FileShdrPair & aPair, Dwarf_Byte_Ptr s, Dwarf_Byte_Ptr e);

	Dwarf_Byte_Ptr ProcessDIE(FileShdrPair & aPair, Dwarf_Byte_Ptr s, Dwarf_Byte_Ptr e);

	typedef Dwarf_Byte_Ptr (*InfoEditFn)(DwarfInfoManager&, Dwarf_Byte_Ptr, Dwarf_Half,FileShdrPair & aPair);

#define DECLARE_INFO_EDIT_FN(name)static Dwarf_Byte_Ptr name(DwarfInfoManager& aManager, \

													Dwarf_Byte_Ptr aPtr, \

													Dwarf_Half aForm, \

													FileShdrPair & aPair)

	DECLARE_INFO_EDIT_FN(DefaultInfoEditFn);

	DECLARE_INFO_EDIT_FN(ErrorInfoEditFn);

	DECLARE_INFO_EDIT_FN(InfoEditAddress);

	DECLARE_INFO_EDIT_FN(InfoEditLinePtr);

	DECLARE_INFO_EDIT_FN(InfoEditLocListPtr);

	DECLARE_INFO_EDIT_FN(InfoEditLocExpr);

	DECLARE_INFO_EDIT_FN(InfoEditMacInfoPtr);

	DECLARE_INFO_EDIT_FN(InfoEditRangeListPtr);

	DECLARE_INFO_EDIT_FN(InfoEditString);

	DECLARE_INFO_EDIT_FN(InfoEditReference);

	DECLARE_INFO_EDIT_FN(InfoEditTrampoline);

	size_t SizeOfDieValue(Dwarf_Half aForm, Dwarf_Byte_Ptr aPtr);	

private:

	static const string iInfoSectionName;

	DwarfAbbrevManager & iDwarfAbbrevManager;

	DwarfMacinfoManager & iDwarfMacinfoManager;

	static InfoEditFn iInfoEditFn[];

	size_t iAddressSize;

	size_t iLocalLength;

};

class DwarfFrameManager : public DwarfFragmentedSectionManager {

public:

	DwarfFrameManager(ElfSectionManager & aElfSectionManager, 

					  DwarfManager & aDwarfManager, 

					  RomDetails * aRomDetails):

		DwarfFragmentedSectionManager(aElfSectionManager, 

									  aDwarfManager, 

									  iFrameSectionName, 

									  aRomDetails)

	{}

	virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end);

private:

	typedef std::map<Dwarf_Byte_Ptr, Dwarf_Ubyte> CiePtrEncodingMap;

	typedef std::map<Dwarf_Byte_Ptr, size_t> CieAugmentationMap;

	static const string iFrameSectionName;	

};

class DwarfLineManager : public DwarfFragmentedSectionManager {

public:

	DwarfLineManager(ElfSectionManager & aElfSectionManager, 

					 DwarfManager & aDwarfManager, 

					 DwarfInfoManager & aDwarfInfoManager, 

					 RomDetails * aRomDetails):

		DwarfFragmentedSectionManager(aElfSectionManager, 

									  aDwarfManager, 

									  iLineSectionName, 

									  aRomDetails),

		iDwarfInfoManager(aDwarfInfoManager)

	{}

	virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end);

private:

	DwarfInfoManager & iDwarfInfoManager;

	static const string iLineSectionName;	

};

class DwarfLocManager : public DwarfFragmentedSectionManager {

public:

	DwarfLocManager(ElfSectionManager & aElfSectionManager, 

					DwarfManager & aDwarfManager, 

					DwarfInfoManager & aDwarfInfoManager, 

					RomDetails * aRomDetails):

		DwarfFragmentedSectionManager(aElfSectionManager, 

									  aDwarfManager, 

									  iLocSectionName,

									  aRomDetails),

		iDwarfInfoManager(aDwarfInfoManager)

	{}

	virtual void ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end);

private:

	DwarfInfoManager & iDwarfInfoManager;

	static const string iLocSectionName;

};

class DwarfNameManager : public DwarfFragmentedSectionManager {

public:

	DwarfNameManager(ElfSectionManager & aElfSectionManager, 

					 DwarfManager & aDwarfManager, 

					 const string & aName, 

					 DwarfInfoManager & aDwarfInfoManager, 

					 RomDetails * aRomDetails):