/*
* 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 <iostream>
#include <iomanip>

#include "dwarfmanager.h"
#include "inputfile.h"
#include "outputfile.h"
#include "filefragment.h"

void DwarfSectionManager::AddSection(XIPFileDetails & aXIPFileDetails, Elf32_Shdr * aShdr){
	if (iRomDetails->iTrace){
		cout << "    " << GetSectionName() << " - DWARF\n";
	}

	FileShdrPair aFileShdrPair(aXIPFileDetails, aShdr);
	iFileShdrList.push_back(aFileShdrPair);
}

void DwarfSectionManager::SetupSection(){
	if (!iFileShdrList.empty()){
		ElfSectionElfData * aDwarfSectionData = new ElfSectionElfData(*this);
		Elf32_Shdr aDwarfShdr;
		aDwarfShdr.sh_name = 0; // for now.
		aDwarfShdr.sh_type = SHT_PROGBITS;
		aDwarfShdr.sh_flags = 0;
		aDwarfShdr.sh_addr = 0;
		aDwarfShdr.sh_offset = 0; // for now
		aDwarfShdr.sh_size = 0; // for now.
		aDwarfShdr.sh_link = 0;
		aDwarfShdr.sh_info = 0;
		aDwarfShdr.sh_addralign = 4;
		aDwarfShdr.sh_entsize = sizeof(Elf32_Sym);
		
		ElfSection aDwarfSection(aDwarfSectionData, GetSectionName().c_str(), aDwarfShdr);
		iElfSectionManager.AddSection(aDwarfSection);
	}
}

Dwarf_Unsigned DwarfSectionManager::DecodeUnsignedLeb128(Dwarf_Byte_Ptr leb128, size_t & leb128_length){
	Dwarf_Ubyte byte;
    Dwarf_Word word_number;
    Dwarf_Unsigned number;
    Dwarf_Sword shift;
    Dwarf_Sword byte_length;

    /* The following unrolls-the-loop for the first few bytes and
       unpacks into 32 bits to make this as fast as possible.
       word_number is assumed big enough that the shift has a defined
       result. */
    if ((*leb128 & 0x80) == 0) {
    	leb128_length = 1;
    	return *leb128;
    } else if ((*(leb128 + 1) & 0x80) == 0) {
    	leb128_length = 2;

    	word_number = *leb128 & 0x7f;
    	word_number |= (*(leb128 + 1) & 0x7f) << 7;
    	return word_number;
    } else if ((*(leb128 + 2) & 0x80) == 0) {
    	leb128_length = 3;

    	word_number = *leb128 & 0x7f;
    	word_number |= (*(leb128 + 1) & 0x7f) << 7;
    	word_number |= (*(leb128 + 2) & 0x7f) << 14;
    	return word_number;
    } else if ((*(leb128 + 3) & 0x80) == 0) {
    	leb128_length = 4;

    	word_number = *leb128 & 0x7f;
    	word_number |= (*(leb128 + 1) & 0x7f) << 7;
    	word_number |= (*(leb128 + 2) & 0x7f) << 14;
    	word_number |= (*(leb128 + 3) & 0x7f) << 21;
    	return word_number;
    }

    /* The rest handles long numbers Because the 'number' may be larger 
       than the default int/unsigned, we must cast the 'byte' before
       the shift for the shift to have a defined result. */
    number = 0;
    shift = 0;
    byte_length = 1;
    byte = *(leb128);
    for (;;) {
    	number |= ((Dwarf_Unsigned) (byte & 0x7f)) << shift;

    	if ((byte & 0x80) == 0) {
    		leb128_length = byte_length;
    		return number;
    	}
    	shift += 7;

    	byte_length++;
    	++leb128;
    	byte = *leb128;
    }
}

#define BITSINBYTE 8
Dwarf_Signed DwarfSectionManager::DecodeSignedLeb128(Dwarf_Byte_Ptr leb128, size_t & leb128_length){
    Dwarf_Signed number = 0;
    Dwarf_Bool sign = 0;
    Dwarf_Word shift = 0;
    Dwarf_Ubyte byte = *leb128;
    Dwarf_Word byte_length = 1;

    /* byte_length being the number of bytes of data absorbed so far in 
       turning the leb into a Dwarf_Signed. */

    for (;;) {
    	sign = byte & 0x40;
    	number |= ((Dwarf_Signed) ((byte & 0x7f))) << shift;
    	shift += 7;

    	if ((byte & 0x80) == 0) {
    		break;
    	}
    	++leb128;
    	byte = *leb128;
    	byte_length++;
    }

    if ((shift < sizeof(Dwarf_Signed) * BITSINBYTE) && sign) {
    	number |= -((Dwarf_Signed) 1 << shift);
    }

    leb128_length = byte_length;
    return number;
}

Dwarf_Byte_Ptr DwarfSectionManager::GetSectionData(FileShdrPair & aPair){

	InputFile in(aPair.iXIPFileDetails.iElfFile);
	in.SetOffset(aPair.iShdr.sh_offset);
	return (Dwarf_Byte_Ptr)in.GetData(aPair.iShdr.sh_size);
}

void DwarfConcatenatedSectionManager::GetFileFragmentData(FileFragmentData & aFileFragmentData ){
	ConcatenateData();
	if (iRomDetails->iTrace){
		cout << "\nGenerating DWARF section " << GetSectionName() << " size = "
		<< dec << Size() << " bytes\n";
	} 
	FileShdrList::iterator e = iFileShdrList.end();
	for (FileShdrList::iterator i = iFileShdrList.begin(); i < e; i++){
		if (iRomDetails->iTrace){
			cout << "    " << i->iXIPFileDetails.iElfFile << " " << dec << i->iShdr.sh_size << " bytes\n" << flush;
		}
		ProcessSection(*i);
	}	
	SetFileFragmentData(aFileFragmentData, iSize, reinterpret_cast<char *>(iData));
}

void DwarfConcatenatedSectionManager::ConcatenateData(){
	if (iData == NULL) {
		size_t sectionSize = Size();
		iData = new Dwarf_Ubyte[sectionSize];
		Dwarf_Byte_Ptr p = iData;
		FileShdrList::iterator e = iFileShdrList.end();
		for (FileShdrList::iterator i = iFileShdrList.begin(); i < e; i++){
			size_t off = p - iData;
			size_t soff = GetSectionOffset(i->iXIPFileDetails.iElfFile);
			if (off >= sectionSize)
				assert(off < sectionSize);
			if (off != soff)
				assert(off == soff);
			size_t n = i->iShdr.sh_size;
			Dwarf_Byte_Ptr contrib = GetSectionData(*i);
			memcpy(p, contrib, n);
			p += n;
			delete [] contrib;
		}
	}
}

size_t DwarfConcatenatedSectionManager::Size(){
	if (iSizeValid)
		return iSize;
	//cerr << "Size for " << GetSectionName() << "\n";
	size_t offset = 0;
	FileShdrList::iterator e = iFileShdrList.end();
	for (FileShdrList::iterator i = iFileShdrList.begin(); i != e; i++){
		//cerr << "offset = 0x" << offset << "\t";
		SetSectionOffset(i->iXIPFileDetails.iElfFile, offset);
		size_t size = i->iShdr.sh_size;
		//cerr << "section size for " << i->iXIPFileDetails.iElfFile << " 0x" << size << "\n";
		SetSectionSize(i->iXIPFileDetails.iElfFile, size);
		size_t newOffset = offset + size;
		if (newOffset < offset){
			cerr << "Error: The combined section " << GetSectionName() 
				<< " requires translation from 32 to 64 bit Dwarf which is not currently supported.\n"
				<< "Exclude the following files (or their equivalent in terms of their contribution to Dwarf):\n";
			for (; i != e; i++){
				cerr << i->iXIPFileDetails.iE32File << "\n";
			}
			exit(EXIT_FAILURE);
		}
		offset = newOffset;
	}
	//cerr << "Size = 0x" << offset << "\n";
	iSizeValid = true;
	return iSize = offset;
}

void DwarfConcatenatedSectionManager::ProcessSection(FileShdrPair & aPair){
	Dwarf_Byte_Ptr start = GetSection(aPair.iXIPFileDetails.iElfFile);
	Dwarf_Byte_Ptr end = start + aPair.iShdr.sh_size;
	ProcessSection(aPair, start, end);
}

void DwarfConcatenatedSectionManager::SetSectionOffset(PathName & aPathName, size_t aOffset) {
	iPathNameSectionOffsetMap[aPathName] = aOffset;
}

void DwarfConcatenatedSectionManager::InitOffsetMap(){ 
	Size();  // forces the map to be set up if it hasn't been already
}

size_t DwarfConcatenatedSectionManager::GetSectionOffset(PathName & aPathName){
	if (!iSizeValid) // if the size is valid then so must be the offsets.
		InitOffsetMap(); 
	return iPathNameSectionOffsetMap[aPathName];
}

void DwarfConcatenatedSectionManager::SetSectionSize(PathName & aPathName, size_t aSize) {
		iPathNameSectionSizeMap[aPathName] = aSize;
}

size_t DwarfConcatenatedSectionManager::GetSectionSize(PathName & aPathName){
	if (!iSizeValid) // if the size is valid then so must be the offsets.
		InitOffsetMap(); 
	return iPathNameSectionSizeMap[aPathName];
}

Dwarf_Byte_Ptr DwarfConcatenatedSectionManager::GetSection(PathName & aPathName){
	ConcatenateData();
	size_t offset = GetSectionOffset(aPathName);
	return iData + offset;
}

class ElfSectionFragmentedDwarfData : public ElfSectionElfData {
public:
	ElfSectionFragmentedDwarfData(FileFragmentOwner & aSource) :
		ElfSectionElfData(aSource)
	{}
	
	ElfSectionFragmentedDwarfData(const ElfSectionElfData & aData) :
		ElfSectionElfData(aData)
	{}	
	
	// ElfSection protocol
	virtual ElfSectionFragmentedDwarfData * Clone(){
		return new ElfSectionFragmentedDwarfData(*this);
	}
	
	virtual void AddData(OutputFile & aOutputFile){
		return;
	}
};

class DwarfSectionFragment : public FileFragmentOwner {
public:
	DwarfSectionFragment(DwarfFragmentedSectionManager & aSource,
						 FileShdrPair & aPair):
		iSource(aSource),
		iPair(aPair),
		iData(NULL)
		{}
	
	// Bitwise copy is OK so don't need to write our own copy ctor etc.
	
	// The FileFragmentOwner protocol
	virtual void GetFileFragmentData(FileFragmentData & aFileFragmentData );
	virtual size_t Size();
	virtual void DeleteFileFragmentData();
	
private:
	DwarfSectionFragment();
	
private:
	DwarfFragmentedSectionManager & iSource;
	FileShdrPair & iPair;
	Dwarf_Byte_Ptr iData;
};

void DwarfSectionFragment::GetFileFragmentData(FileFragmentData & aFileFragmentData ){
	iSource.ProcessSection(iPair, iData);	
	SetFileFragmentData(aFileFragmentData, Size(), reinterpret_cast<char *>(iData));	
}

size_t DwarfSectionFragment::Size(){
	return iPair.iShdr.sh_size;
}

void DwarfSectionFragment::DeleteFileFragmentData(){
	delete [] iData;
	// 
	delete this;
}

void DwarfFragmentedSectionManager::SetupSection(){
	if (!iFileShdrList.empty()){
		ElfSectionFragmentedDwarfData * aDwarfSectionData = new ElfSectionFragmentedDwarfData(*this);
		Elf32_Shdr aDwarfShdr;
		aDwarfShdr.sh_name = 0; // for now.
		aDwarfShdr.sh_type = SHT_PROGBITS;
		aDwarfShdr.sh_flags = 0;
		aDwarfShdr.sh_addr = 0;
		aDwarfShdr.sh_offset = 0; // for now
		aDwarfShdr.sh_size = 0; // for now.
		aDwarfShdr.sh_link = 0;
		aDwarfShdr.sh_info = 0;
		aDwarfShdr.sh_addralign = 4;
		aDwarfShdr.sh_entsize = sizeof(Elf32_Sym);
		
		// aDwarfSectionData will ask the secton manager (i.e. its source) for the offset of the section.
		// So we better record it here. We assume that it is the current size of the output file.
		// As long as we are single threaded and all the fragments get added consecutively as below
		// this is a safe assumption.
		SetOffset(iDwarfManager.GetOutputFile().Size());
		
		ElfSection aDwarfSection(aDwarfSectionData, GetSectionName().c_str(), aDwarfShdr);
		iElfSectionManager.AddSection(aDwarfSection);
		
		for (FileShdrList::iterator i = iFileShdrList.begin(); i < iFileShdrList.end(); i++ ){
			DwarfSectionFragment * aFrag = new DwarfSectionFragment(*this, *i);
			aFrag->AddData(iDwarfManager.GetOutputFile());
		}
	}
}

// NB the section itself doesn't write any data
// The FileFragmentOwner protocol

void DwarfFragmentedSectionManager::GetFileFragmentData(FileFragmentData & aFileFragmentData ){	
	SetFileFragmentData(aFileFragmentData, 0, reinterpret_cast<char *>(NULL));
}

// This should never get called
void DwarfFragmentedSectionManager::ConcatenateData(){
	assert(1 == 0);
	return;
}

void DwarfFragmentedSectionManager::ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr & aData){
	if (iInitialTraceMessage & iRomDetails->iTrace){
		cout << "\nGenerating DWARF section " << GetSectionName() << " size = "
			<< dec << Size() << " bytes\n";
		iInitialTraceMessage = false;
	}
	if (iRomDetails->iTrace){
		cout << "    " << aPair.iXIPFileDetails.iElfFile << " size = " 
		<< dec << aPair.iShdr.sh_size << "\n" << flush; 
	}
	Dwarf_Byte_Ptr start = GetSectionData(aPair);
	aData = start;
	Dwarf_Byte_Ptr end = start + aPair.iShdr.sh_size;
	ProcessSection(aPair, start, end);
}

#if 0
// This should never get called
void DwarfFragmentedSectionManager::ProcessSection(FileShdrPair & aPair, Dwarf_Byte_Ptr start, Dwarf_Byte_Ptr end){
	assert(1 == 0);
	return;
}
#endif

const string DwarfMacinfoManager::iMacinfoSectionName(".debug_macinfo");
const string DwarfStrManager::iStrSectionName(".debug_str");


void DwarfManager::AddSection(XIPFileDetails & aXIPFileDetails, string aSectionName, Elf32_Shdr * aShdr){
	if (iDwarfAbbrevManager.GetSectionName() == aSectionName)
		iDwarfAbbrevManager.AddSection(aXIPFileDetails, aShdr);
	else if (iDwarfArangesManager.GetSectionName() == aSectionName)
		iDwarfArangesManager.AddSection(aXIPFileDetails, aShdr);
	else if (iDwarfFrameManager.GetSectionName() == aSectionName)
		iDwarfFrameManager.AddSection(aXIPFileDetails, aShdr);
	else if (iDwarfInfoManager.GetSectionName() == aSectionName)
		iDwarfInfoManager.AddSection(aXIPFileDetails, aShdr);
	else if (iDwarfLineManager.GetSectionName() == aSectionName)
		iDwarfLineManager.AddSection(aXIPFileDetails, aShdr);
	else if (iDwarfLocManager.GetSectionName() == aSectionName)
		iDwarfLocManager.AddSection(aXIPFileDetails, aShdr);
	else if (iDwarfMacinfoManager.GetSectionName() == aSectionName)
		iDwarfMacinfoManager.AddSection(aXIPFileDetails, aShdr);
	else if (iDwarfPubnamesManager.GetSectionName() == aSectionName)
		iDwarfPubnamesManager.AddSection(aXIPFileDetails, aShdr);
	else if (iDwarfPubtypesManager.GetSectionName() == aSectionName)
		iDwarfPubtypesManager.AddSection(aXIPFileDetails, aShdr);
	else if (iDwarfRangesManager.GetSectionName() == aSectionName)
		iDwarfRangesManager.AddSection(aXIPFileDetails, aShdr);
	else if (iDwarfStrManager.GetSectionName() == aSectionName)
		iDwarfStrManager.AddSection(aXIPFileDetails, aShdr);
#if 0
	else
		cerr << "Warning: unrecognised debug section name " << aSectionName << " ignored\n";
#endif
}

void DwarfManager::SetupSections(){
	// The order here is important for fix up
	// first the purely concatenated 'leaf' sections
	// See the diagram on p.182 of the Dwarf 3 spec
	// to understand the 'dependenices'
	iDwarfAbbrevManager.SetupSection();
	iDwarfFrameManager.SetupSection();
	iDwarfPubnamesManager.SetupSection();
	iDwarfPubtypesManager.SetupSection();
	iDwarfArangesManager.SetupSection();	
	iDwarfMacinfoManager.SetupSection();
	
	iDwarfInfoManager.SetupSection();
	iDwarfLineManager.SetupSection();
	iDwarfLocManager.SetupSection();

	iDwarfRangesManager.SetupSection();
	iDwarfStrManager.SetupSection();
}