/*
* 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/>.
*/

#include <libelf.h>
#include <map>

#include "elfsymboltablemanager.h"

void ElfFileSymbolFragments::AddSymbolTable(String & aPath, size_t aOffset, size_t aSize, size_t aFirstGlobal){
	iPath = aPath;
	// drop the inital 'undefined' symbol
	iSymbolTableOffset = aOffset + sizeof(Elf32_Sym);
	iSymbolTableSize = aSize - sizeof(Elf32_Sym);
	iFirstGlobal = aFirstGlobal - 1;
}

void ElfFileSymbolFragments::AddStringTable(String & aPath, size_t aOffset, size_t aSize){
	iPath = aPath;
	// drop the inital "\0"
	iStringTableOffset = aOffset + 1;
	iStringTableSize = aSize - 1;
}

size_t ElfFileSymbolFragments::LookupSection(size_t ndx){
	SectionNumberMap::iterator aMapping = iSectionNumberMap.begin();
	SectionNumberMap::iterator end = iSectionNumberMap.end();
	while (aMapping != end) {
		if (aMapping->iOld == ndx) 
			return aMapping->iNew;
		aMapping++;
	}
	return ndx;
}

int ElfFileSymbolFragments::LookupVaddrAddend(size_t ndx){
	SectionVaddrAddendMap::iterator aMapping = iSectionVaddrAddendMap.begin();
	SectionVaddrAddendMap::iterator end = iSectionVaddrAddendMap.end();
	while (aMapping != end) {
		if (aMapping->iSectionNumber == ndx) 
			return aMapping->iAddend;
		aMapping++;
	}
	return 0;
}

size_t ElfSymTabStringTable::Size(){
	return iElfSymbolTableManager.GetSymTabStringsSectionSize();
}

void ElfSymbolTableManager::Finalize(SectionNumberMap & aSectionNumberMap, SectionVaddrAddendMap & aSectionVaddrAddendMap ){
	iCurrentFragment.SetSectionNumberMap(aSectionNumberMap);
	iCurrentFragment.SetSectionVaddrAddendMap(aSectionVaddrAddendMap);
	iCurrentFragment.Validate();
	iSymbolFragments.push_back(iCurrentFragment);
	iCurrentFragment.Reset();
}

// TODO: This could be done more efficiently and with out the use of the ElfStringTable object.
void ElfSymbolTableManager::GetFileFragmentData(FileFragmentData & aFileFragmentData ){
	size_t symTabSize = GetSymTabSectionSize(); 
	iData = new char[symTabSize];
	Elf32_Sym * syms = (Elf32_Sym *)iData;

	
	// set up UNDEF symbol
	syms[0].st_info = 0;
	syms[0].st_name = 0;
	syms[0].st_other = 0;
	syms[0].st_shndx = 0;
	syms[0].st_size = 0;
	syms[0].st_value = 0;

	// set up 'cursors' into final symbol table so we put locals first 
	// and globals at the end
	Elf32_Sym * lsym = &syms[1];
	size_t firstGlobal = GetFirstNonLocalIndex();
	Elf32_Sym * gsym = &syms[firstGlobal];
	Elf32_Sym * lsymLim = gsym;
	iStringTable.AllocateInitialNullString();
	
	SymbolFragmentList::iterator aFrag = iSymbolFragments.begin();
	SymbolFragmentList::iterator end = iSymbolFragments.end();
	while (aFrag != end) {
		//InputFile aFile((char *)(aFrag->GetPath().c_str()));
		InputFile aFile(aFrag->GetPath());
		aFile.SetOffset(aFrag->GetSymbolTableOffset());
		size_t symSize = aFrag->GetSymbolTableSize();
		size_t limit = symSize / sizeof(Elf32_Sym);
		char * symtabData = aFile.GetData(symSize);
		Elf32_Sym * symtab = (Elf32_Sym *)symtabData;
		aFile.SetOffset(aFrag->GetStringTableOffset());
		char * strtabx = aFile.GetData(aFrag->GetStringTableSize());
		// set strtab back one to 'add' "\0" back in so indexs works with addition.
		char * strtab = strtabx - 1;
		size_t firstNonLocal = aFrag->GetFirstGlobal();
		
		typedef std::map<size_t, size_t> SymbolNdxMap;
		SymbolNdxMap symNdxMap;
		
		for (size_t i = 0; i < limit; i++){
			size_t strndx = symtab[i].st_name;
			
			if (strndx != 0) {
				// see if we've already seen this index
				SymbolNdxMap::iterator res = symNdxMap.find(strndx);
				size_t newndx;
				if (res != symNdxMap.end()){
					newndx = res->second;
					symtab[i].st_name = newndx;	
				} else {
					char * name = &strtab[strndx];
					newndx = iStringTable.AddString(name);
					symNdxMap[strndx] = symtab[i].st_name = newndx;
				}
			}
			
			if (!(symtab[i].st_value || symtab[i].st_size)){
				symtab[i].st_shndx = SHN_UNDEF;
			} else {
				size_t oldNdx = symtab[i].st_shndx;
				
				// retrieve new section index
				size_t newscnndx = aFrag->LookupSection(oldNdx);
				// retrieve the vaddr adjustment to add to the symbol's value
				int addend = aFrag->LookupVaddrAddend(oldNdx);
				symtab[i].st_shndx = newscnndx;
				symtab[i].st_value += addend;
			}
			if (i < firstNonLocal){
				assert(lsym < lsymLim);
				*(lsym++) = symtab[i];
			} else {
				*(gsym++) = symtab[i];
			}
		}
		
		delete [] symtabData;
		delete strtabx;
		
		aFrag++;
	}
	SetFileFragmentData(aFileFragmentData, symTabSize, reinterpret_cast<char *>(iData));
}


size_t ElfSymbolTableManager::Size(){
	return GetSymTabSectionSize();
}

void ElfSymbolTableManager::DeleteFileFragmentData(){
	char * d = iData;
	iData = NULL;
	delete [] d;
}

void ElfSymbolTableManager::AddData(OutputFile & aOutputFile){
	const FileFragment & aSectionFrag = iOutputFile.GetFileFragment(this);	
	SetOffset(aSectionFrag.GetOffset());
}

void ElfSymbolTableManager::AddSymbolTable(){
	// The sym table section needs to record the index of its associated
	// string table in its link field and record the index of the first non-local
	// symbol in its info field
	int symTabSize = GetSymTabSectionSize(); 
	size_t firstNonLocal = GetFirstNonLocalIndex();
	size_t nextSectionIndex = iElfSectionManager.NumSections();
	
	ElfSectionElfData * aSymTabSectionData = new ElfSectionElfData(*this);
	Elf32_Shdr symTabShdr;
	symTabShdr.sh_name = 0; // for now.
	symTabShdr.sh_type = SHT_SYMTAB;
	symTabShdr.sh_flags = 0;
	symTabShdr.sh_addr = 0;
	symTabShdr.sh_offset = 0; // for now
	symTabShdr.sh_size = symTabSize; // for now.
	// symTabShdr will be @ index nextSectionIndex so the .strtab will 
	// be @ nextSectionIndex +1
	symTabShdr.sh_link = nextSectionIndex + 1;
	symTabShdr.sh_info = firstNonLocal;
	symTabShdr.sh_addralign = 4;
	symTabShdr.sh_entsize = sizeof(Elf32_Sym);
	
	ElfSection aSymTabSection(aSymTabSectionData, ".symtab", symTabShdr);
	iElfSectionManager.AddSection(aSymTabSection);


	ElfSectionElfData * aStringTableSectionData = new ElfSectionElfData(iStringTable);
	Elf32_Shdr shdr;
	shdr.sh_name = 0; // for now.
	shdr.sh_type = SHT_STRTAB;
	shdr.sh_flags = 0;
	shdr.sh_addr = 0;
	shdr.sh_offset = 0; // for now
	shdr.sh_size = GetSymTabStringsSectionSize();
	shdr.sh_link = 0;
	shdr.sh_info = 0;
	shdr.sh_addralign = 0;
	shdr.sh_entsize = 0;
	ElfSection aStringTableSection(aStringTableSectionData, ".strtab", shdr);
	iElfSectionManager.AddSection(aStringTableSection);

}

size_t ElfSymbolTableManager::GetSymTabSectionSize(){
	int symTabSize = sizeof(Elf32_Sym); // add the 'undefined' symbols
	
	SymbolFragmentList::iterator aFrag = iSymbolFragments.begin();
	SymbolFragmentList::iterator end = iSymbolFragments.end();
	while (aFrag != end) {
		symTabSize += aFrag->GetSymbolTableSize();
		aFrag++;
	}
	return symTabSize;
}

size_t ElfSymbolTableManager::GetSymTabStringsSectionSize(){
	
	if (iSymbolStringTableSizeValid)
		return iSymbolStringTableSize;
	
	int stringsSize = 1; // add the leading "\0"
	
	SymbolFragmentList::iterator aFrag = iSymbolFragments.begin();
	SymbolFragmentList::iterator end = iSymbolFragments.end();
	while (aFrag != end) {
		stringsSize += aFrag->GetStringTableSize();
		aFrag++;
	}
	iSymbolStringTableSizeValid = true;
	return iSymbolStringTableSize = stringsSize;
}

size_t ElfSymbolTableManager::GetFirstNonLocalIndex(){
	int ndx = 1; // add the 'undefined' symbols
	
	SymbolFragmentList::iterator aFrag = iSymbolFragments.begin();
	SymbolFragmentList::iterator end = iSymbolFragments.end();
	while (aFrag != end) {
		ndx += aFrag->GetFirstGlobal();
		aFrag++;
	}
	return ndx;
}