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