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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <crtdbg.h>

#include "analyse.h"

#include "codespace.h"

#ifdef __MSVCDOTNET__

#pragma warning(push, 3)	// cannot compile MSVC's STL at warning level 4

#pragma warning(disable: 4786 4710 4530)

#include <strstream>

#include <iomanip>

#else //!__MSVCDOTNET__

#include <strstrea.h>

#include <iomanip.h>

#endif //__MSVCDOTNET__

#include <algorithm>

// class CodeSpace

int CodeSpace::Size() const

	{

	return 1;

	}

int CodeSpace::Bucket(PC) const

	{

	return KOtherBucket;

	}

const char* CodeSpace::Name(int) const

	{

	return "<other>";

	}

CodeSpace::TOrder CodeSpace::Ordering() const

	{

	return ERandom;

	}

// class AddressCodeSpace

AddressCodeSpace::AddressCodeSpace(PC aBase, PC aLimit, unsigned aBucketSize, TType aType)

	:iBase(aBase), iType(aType)

	{

	if (aBucketSize < 1)

		aBucketSize = 1;

	unsigned shift;

	for (shift = 0; (aBucketSize >> shift) != 1; ++shift)

		;

	iBucketShift = shift;

	iBuckets = (aLimit - aBase + (1u << shift) - 1) >> shift;

	}

int AddressCodeSpace::Size() const

	{

	return iBuckets + 1;

	}

int AddressCodeSpace::Bucket(PC aPc) const

	{

	if (aPc >= iBase)

		{

		unsigned bucket = (aPc - iBase) >> iBucketShift;

		if (bucket < iBuckets)

			return bucket + 1;

		}

	return KOtherBucket;

	}

const char* AddressCodeSpace::Name(int aBucket) const

	{

	if (aBucket == KOtherBucket)

		return CodeSpace::Name(aBucket);

	unsigned offset = ((aBucket - 1) << iBucketShift);

	strstream s(iBuffer, sizeof(iBuffer), ios::out);

	s << hex << setfill('0');

	if (iType == EAbsolute)

		s << setw(8) << iBase + offset;

	else

		s << "+ " << setw(4) << offset;

	s << setfill(' ') << '\0';

	return iBuffer;

	}

CodeSpace::TOrder AddressCodeSpace::Ordering() const

	{

	return (iType == EAbsolute) ? EOrdered : ELinear;

	}

// class MappedCodeSpace

MappedCodeSpace::MappedCodeSpace(const SymbolFile& aSymbols, MappedCodeSpace::Partition& aPartition)

	{

	aPartition.iCodeSpace = this;

	aSymbols.Parse(aPartition);

	}

MappedCodeSpace::MappedCodeSpace() 

	{}

const MappedCodeSpace::Element* MappedCodeSpace::Find(PC aPc) const

//

// Find and return the element which contains this PC value

// If not mapped return 0

//

	{

	Map::const_iterator e = iMap.upper_bound(aPc);

	// ignore deleted segments

	for(;e != iMap.end() && aPc >= e->second.iBase;e++)

		if (!e->second.iUnloaded)

			return &e->second;

	return 0;

	}

std::pair<const char*,unsigned> MappedCodeSpace::Lookup(PC aPc) const

	{

	const Element* e = Find(aPc);

	if (e == 0)

		return std::pair<const char*,unsigned>(0, aPc);

	return std::pair<const char*,unsigned>(e->iName, aPc - e->iBase);

	}

int MappedCodeSpace::Size() const

	{

	return iMap.size() + 1;

	}

int MappedCodeSpace::Bucket(PC aPc) const

	{

	const Element* e = Find(aPc);

	return (e == 0) ? KOtherBucket : e->iBucket + 1;

	}

const char* MappedCodeSpace::Name(int aBucket) const

	{

	return (aBucket == KOtherBucket) ? CodeSpace::Name(aBucket) : iNames[aBucket - 1];

	}

void MappedCodeSpace::Add(PC aBase, PC aLimit, const char* aName)

	{

	// insert

	iMap.insert(Map::value_type(aLimit, Element(aBase, aLimit, aName)));

	}

void MappedCodeSpace::Done(PC aFirstPc, PC aLastPc, int aModuleId)

	{

	if (!aFirstPc)

		{

		iNames.clear();

		for (Map::iterator p = iMap.begin(), e = iMap.end(); p != e; ++p)

			{

			p->second.iBucket = iNames.size();

			iNames.push_back(p->second.iName);

			}

		}

	else

		{

		Map::iterator p = iMap.find(aFirstPc);

		_ASSERT(p != iMap.end());

		for (Map::iterator e = iMap.end(); p != e && p->first <= aLastPc; ++p)

			{

			if (p->second.iUnloaded) 

				continue;

			bool bFound = false;

			NamesMap::iterator pMap = iNamesMap.find(p->second.iName);

			if (pMap != iNamesMap.end())

				for(;!strcmp(p->second.iName, pMap->first);pMap++)

					if (pMap->second.iId == aModuleId)

						{

						bFound = true;

						break;

						}

			if (bFound)

				p->second.iBucket = pMap->second.iIndex;

			else

				{

				p->second.iBucket = iNames.size();

				iNames.push_back(p->second.iName);

				iNamesMap.insert(NamesMap::value_type(p->second.iName, IdNames(aModuleId, p->second.iBucket)));

				}

			}

		}

	}