// mapfile.cpp

// 

// Copyright (c) 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

// 

// Initial Contributors:

// Accenture - Initial contribution

//

#include <fshell/bsym.h>

#include <fshell/ltkutils.h>

#include "bsymtree.h"

#include <fshell/descriptorutils.h>

#include <fshell/iocli.h>

using namespace LtkUtils;

using namespace IoUtils;

const TInt KSymbolGranularity = 256; // I have no idea...

struct SSymbol

	{

	TUint iAddress;

	TUint iLength;

	HBufC8* iName;

	};

NONSHARABLE_CLASS(CMapFileImpl) : public CMapFile

	{

public:

	CMapFileImpl();

	~CMapFileImpl();

	void ConstructL(RFs& aFs, const TDesC& aFileName);

	void DoLookup(TUint32 aOffsetInCodeSeg, TDes& aResult);

	RNode* DoCreateCompletionTreeL();

private:

	RArray<SSymbol> iSymbols;

	};

EXPORT_C CMapFile* CMapFile::NewL(RFs& aFs, const TDesC& aFileName)

	{

	CMapFileImpl* result = new (ELeave) CMapFileImpl;

	CleanupStack::PushL(result);

	//CleanupStack::PushL((CBase*)1); //DEBUG

	result->ConstructL(aFs, aFileName);

	//CleanupStack::Pop(); //DEBUG

	CleanupStack::Pop(result);

	return result;

	}

CMapFile::CMapFile()

	{

	}

CMapFileImpl::CMapFileImpl()

	: iSymbols(KSymbolGranularity, _FOFF(SSymbol, iAddress))

	{

	}

CMapFileImpl::~CMapFileImpl()

	{

	const TInt count = iSymbols.Count();

	for (TInt i = 0; i < count; i++)

		{

		delete iSymbols[i].iName;

		}

	iSymbols.Close();

	}

EXPORT_C CMapFile::~CMapFile()

	{

	iReadBuf.Close();

	delete iFileName;

	}

#undef LeaveIfErr

#define LeaveIfErr(args...) StaticLeaveIfErr(args)

void CMapFileImpl::ConstructL(RFs& aFs, const TDesC& aFileName)

	{

	iFileName = aFileName.AllocL();

	iReadBuf.CreateL(4096);

	LeaveIfErr(iFile.Open(aFs, aFileName, EFileShareReadersOnly), _L("Couldn't open file %S"), &aFileName);

	TPtrC8 line;

	TBool rvct = EFalse;

	_LIT8(KRvct, "ARM Linker, RVCT");

	if (GetNextLine(line) && HasPrefix(line, KRvct)) rvct = ETrue;

	TBool foundOffset = EFalse;

	TInt linenum = 0; // for debugging

	if (rvct)

		{

		TInt local = ETrue;

		while (GetNextLine(line))

			{

			linenum++;

			if (line.Length() == 0) continue;

			_LIT8(KRVCTOffsetLine, "    Image$$ER_RO$$Base                       ");

			if (!foundOffset)

				{

				if (HasPrefix(line, KRVCTOffsetLine))

					{

					TLex8 lex(line.Mid(KRVCTOffsetLine().Length()));

					iTextOffset = HexLexL(lex);

					foundOffset = ETrue;

					// No go through any symbols we found before this, and correct their offsets

					for (TInt i = 0; i < iSymbols.Count(); i++)

						{

						iSymbols[i].iAddress -= iTextOffset;

						}

					continue;

					}

				}

			_LIT8(KGlobalSection, "    Global Symbols");

			if (HasPrefix(line, KGlobalSection)) local = EFalse; // We've reached the global section, don't have to ignore so much stuff

			SSymbol symbol;

			// This is rather awkward, because there's no proper delimiting between symbol name and the next stuff

			_LIT8(KSpaces, "   ");

			if (line.Length() < 55) continue;

			TInt foundSpaces = line.Mid(55).Find(KSpaces);

			if (foundSpaces == KErrNotFound) continue;

			TInt spp = 55 + foundSpaces - 10;

			symbol.iName = line.Left(spp).AllocLC();

			symbol.iName->Des().Trim();

			TLex8 lex(line);

			lex.Inc(spp);

			symbol.iAddress = HexLexL(lex) - iTextOffset;

			lex.SkipSpace();

			if (local)

				{

				// In local symbols section we have to worry about non-code stuff

				_LIT8(KArm,   "ARM Code  ");

				_LIT8(KThumb, "Thumb Code");

				TPtrC8 type = lex.Remainder().Left(KThumb().Length());

				if (type != KArm && type != KThumb)

					{

					CleanupStack::PopAndDestroy(symbol.iName);

					continue;

					}

				}

			lex.Inc(10); // Far enough to get over "ARM Code" or "Thumb Code"

			lex.SkipSpace();

			User::LeaveIfError(lex.Val(symbol.iLength));

			if (symbol.iLength == 0)

				{

				CleanupStack::PopAndDestroy(symbol.iName);

				continue; // todo thunks lie about their size...

				}

			User::LeaveIfError(iSymbols.Append(symbol));

			CleanupStack::Pop(symbol.iName);

			}

		}

	else

		{

		while (GetNextLine(line))

			{

			linenum++;

			_LIT8(KGccTextOffsetLine, "Address of section .text set to ");

			if (HasPrefix(line, KGccTextOffsetLine))

				{

				// GCCE style

				TLex8 lex(line.Mid(KGccTextOffsetLine().Length()));

				iTextOffset = HexLexL(lex);

				continue;

				}

			_LIT8(KFin, ".fini");

			if (line == KFin) break;

			if (line.Length() < 16) continue;

			TLex8 lex(line);

			lex.Inc(16);

			SSymbol symbol;

			symbol.iLength = 4; // unless otherwise updated by the next symbol addr

			TInt err = HexLex(lex, symbol.iAddress);

			if (err) continue;

			symbol.iAddress -= iTextOffset;

			lex.SkipSpace();

			if (lex.Offset() < 42) continue; // Code symbols have space up to column 42

			symbol.iName = lex.Remainder().AllocLC();

			User::LeaveIfError(iSymbols.Append(symbol));

			CleanupStack::Pop(symbol.iName);

			}

		// GCCE doesn't even sort the symbols in its map file. Unbelievable! Or possibly even inconceivable!

		iSymbols.SortUnsigned();

		for (TInt i = 1; i < iSymbols.Count(); i++)

			{

			SSymbol& prevSymbol = iSymbols[i - 1];

			prevSymbol.iLength = iSymbols[i].iAddress - prevSymbol.iAddress;

			}

		}

	iFile.Close();

	iReadBuf.Close();

	}

TBool CMapFile::GetNextLine(TPtrC8& aPtr)

	{

	_LIT8(KNewline, "\r\n");

	iReadBuf.Delete(0, aPtr.Length());

	if (HasPrefix(iReadBuf, KNewline)) iReadBuf.Delete(0, KNewline().Length());

	TInt newline = iReadBuf.Find(KNewline);

	if (newline != KErrNotFound)

		{

		aPtr.Set(iReadBuf.Left(newline));

		return ETrue;

		}

	// Otherwise need to try reading some more from file

	TPtr8 restOfDesc((TUint8*)iReadBuf.Ptr() + iReadBuf.Size(), 0, iReadBuf.MaxSize() - iReadBuf.Size());

	TInt err = iFile.Read(restOfDesc);

	if (err) restOfDesc.Zero();

	iReadBuf.SetLength(iReadBuf.Length() + restOfDesc.Length());

	// Now re-try looking for newline

	newline = iReadBuf.Find(KNewline);

	if (newline != KErrNotFound)

		{

		aPtr.Set(iReadBuf.Left(newline + KNewline().Length()));

		return ETrue;

		}

	// No more newlines, just return whatever's left in the buffer

	aPtr.Set(iReadBuf);

	return aPtr.Length() != 0; // And return whether it's worth having

	}

EXPORT_C void CMapFile::Lookup(TUint32 aOffsetInCodeSeg, TDes& aResult)

	{

	//TUint32 offset = aOffsetInCodeSeg & 0xFFFFFFFE; // Mask bottom bit as it just indicates thumb mode

	CMapFileImpl* impl = static_cast<CMapFileImpl*>(this); // We know we're actually a CMapFileImpl

	impl->DoLookup(aOffsetInCodeSeg, aResult);

	}

void CMapFileImpl::DoLookup(TUint32 aOffsetInCodeSeg, TDes& aResult)

	{

	TInt pos = 0;

	SSymbol dummy; dummy.iAddress = aOffsetInCodeSeg;

	TBool found = iSymbols.FindInUnsignedKeyOrder(dummy, pos) == KErrNone;

	if (!found && pos != 0) pos--;

	aResult.Zero();

	const SSymbol& symbol = iSymbols[pos];

	if (aOffsetInCodeSeg >= symbol.iAddress && aOffsetInCodeSeg < symbol.iAddress + symbol.iLength)

		{

		aResult.Copy(*symbol.iName);

		aResult.AppendFormat(_L(" + 0x%x"), aOffsetInCodeSeg - symbol.iAddress);

		}

	}

EXPORT_C void CMapFile::GetFileNameL(TDes& aFileName) const

	{

	aFileName.Copy(*iFileName);

	}

RNode* CMapFile::CreateCompletionTreeL()

	{

	CMapFileImpl* impl = static_cast<CMapFileImpl*>(this); // We know we're actually a CMapFileImpl

	return impl->DoCreateCompletionTreeL();

	}

RNode* CMapFileImpl::DoCreateCompletionTreeL()

	{

	RNode* result = RNode::NewL();

	CleanupDeletePushL(result);

	RLtkBuf tempBuf;

	tempBuf.CreateLC(256);

	for (TInt i = 0; i < iSymbols.Count(); i++)

		{

		tempBuf.Zero();

		tempBuf.AppendL(*iSymbols[i].iName);

		tempBuf.ReserveExtraL(1);

		result->InsertStringL(tempBuf.PtrZ(), iSymbols[i].iAddress);

		}

	CleanupStack::PopAndDestroy(&tempBuf);

	CleanupStack::Pop(result);

	return result;

	}