// Copyright (c) 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:

// Stop-mode debug interface implementation as defined in sm_debug_api.h

//

/**

 * @file

 * @internalComponent

 * @prototype

*/

#ifdef __LAUNCH_AS_EXTENSION__

#include <rm_debug_api.h>

#include <sm_debug_api.h>

#include "d_rmd_breakpoints.h"

using namespace Debug;

/**

 * Stop Mode routine to retrieve the code seg list and place it in the response buffer

 * @param aItem List item describing the list

 * @return One of the system wide error codes

 */

TInt StopModeDebug::GetCodeSegList(const TListItem* aItem, bool aCheckConsistent)

	{

	if(aCheckConsistent)

		{

		DMutex* codeMutex = Kern::CodeSegLock();

		if(!codeMutex || codeMutex->iHoldCount)

			{

			return ExitPoint(KErrNotReady);

			}

		}

	TUint8* bufferInitial = (TUint8*)aItem->iBufferAddress;

	TUint8* buffer = (TUint8*)aItem->iBufferAddress + 12;

	TUint32 bufferSize = aItem->iBufferSize;

	TUint32* buffer32 = (TUint32*)aItem->iBufferAddress;

	*buffer32 = (TUint32)aItem;

	TUint32* size = buffer32+1;

	*size = 12;

	TUint32* nextElementSize = buffer32+2;

	*nextElementSize = 0;

	TUint32 start = aItem->iStartElement;

	while(1)

		{

		DEpocCodeSeg* codeSeg = GetNextCodeSeg(start, aItem->iListScope, aItem->iScopeData);

		if(!codeSeg)

			{

			*size = buffer-bufferInitial;

			return KErrNone; // we're done

			}

		start = (TUint32)codeSeg + 1;

		TInt ret = ProcessCodeSeg(buffer, bufferSize, codeSeg);

		if(KErrNone != ret)

			{

			if(ret > 0)

				{

				Kern::Printf("Next element is %d bytes big\n", ret);

				*nextElementSize = ret;

				ret = KErrTooBig;

				}

			*size = buffer-bufferInitial;

			return ret;

			}

		}

	}

DEpocCodeSeg* StopModeDebug::GetNextCodeSeg(const TUint32 aStart, const TListScope aListScope, const TUint64 aScopeData)

	{

	switch(aListScope)

		{

		case EScopeGlobal:

			return GetNextGlobalCodeSeg(aStart);

		case EScopeThreadSpecific:

			return GetNextThreadSpecificCodeSeg(aStart, aScopeData);

		default:

			return NULL;

		}

	}

DEpocCodeSeg* StopModeDebug::GetNextThreadSpecificCodeSeg(const TUint32 aStart, const TUint64 aThreadId)

	{

	return NULL;

	}

DEpocCodeSeg* StopModeDebug::GetNextGlobalCodeSeg(const TUint32 aStart)

	{

	//get global code seg list

	SDblQue* codeSegList = Kern::CodeSegList();

	DEpocCodeSeg* codeSeg = NULL;

	for (SDblQueLink* codeSegPtr= codeSegList->First(); codeSegPtr!=(SDblQueLink*) (codeSegList); codeSegPtr=codeSegPtr->iNext)

		{

		DEpocCodeSeg* tempCodeSeg = (DEpocCodeSeg*)_LOFF(codeSegPtr,DCodeSeg, iLink);

		if((TUint32)tempCodeSeg >= aStart)

			{

			if(!codeSeg || tempCodeSeg < codeSeg)

				{

				codeSeg = tempCodeSeg;

				}

			}

		}

	return codeSeg;

	}

TInt StopModeDebug::ProcessCodeSeg(TUint8*& aBuffer, TUint32& aBufferSize, DEpocCodeSeg* aCodeSeg)

	{

	//create a memory info object for use in the loop

	TModuleMemoryInfo memoryInfo;

	//get the memory info

	TInt err = aCodeSeg->GetMemoryInfo(memoryInfo, NULL);

	if(err != KErrNone)

		{

		//there's been an error so return it

		return err;

		}

	//calculate data values

	TFileName fileName(aCodeSeg->iFileName->Ptr());

	TBool isXip = (aCodeSeg->iXIP) ? ETrue : EFalse;

	//get the code seg type

	TCodeSegType type =

		aCodeSeg->IsExe() ? EExeCodeSegType :

		aCodeSeg->IsDll() ? EDllCodeSegType :

		EUnknownCodeSegType;

	//append data to buffer

	return AppendCodeSegData(aBuffer, aBufferSize, memoryInfo, isXip, type, fileName, aCodeSeg);

	}

TInt StopModeDebug::AppendCodeSegData(TUint8*& aBuffer, TUint32& aBufferSize, const TModuleMemoryInfo& aMemoryInfo, const TBool aIsXip, const TCodeSegType aCodeSegType, const TDesC8& aFileName, DEpocCodeSeg* aCodeSeg)

	{

	//get some data elements to put in buffer

	TUint16 fileNameLength = aFileName.Length();

	//calculate the resultant size

	TUint dataSize = Align4(sizeof(TCodeSegListEntry) + (2*fileNameLength) - sizeof(TUint16));

	if(dataSize > aBufferSize)

		{

		// data won't fit in the buffer so quit

		return dataSize;

		}

	//Create a TCodeSegListEntry which references the buffer.

	TCodeSegListEntry& entry = *(TCodeSegListEntry*)aBuffer;

	entry.iCodeBase = aMemoryInfo.iCodeBase;

	entry.iCodeSize = aMemoryInfo.iCodeSize;

	entry.iConstDataSize = aMemoryInfo.iConstDataSize;

	entry.iInitialisedDataBase = aMemoryInfo.iInitialisedDataBase;

	entry.iInitialisedDataSize = aMemoryInfo.iInitialisedDataSize;

	entry.iUninitialisedDataSize = aMemoryInfo.iUninitialisedDataSize;

	entry.iIsXip = aIsXip;

	entry.iCodeSegType = aCodeSegType;

	entry.iNameLength = fileNameLength;

	//entry.iSpare1 = (TUint32)aCodeSeg;

	//have to convert the stored name to 16 bit Unicode

	TPtr name = TPtr((TUint8*)&(entry.iName[0]), fileNameLength*2, fileNameLength*2);

	TInt err = CopyAndExpandDes(aFileName, name);

	if(err != KErrNone)

		{

		return KErrGeneral;

		}

	//increase length         

	aBufferSize-=dataSize;

	aBuffer+=dataSize;

	return KErrNone;

	}

#endif