// Copyright (c) 2004-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 <e32def.h>

#include <e32def_private.h>

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <u32std.h>

#include <kernel/kernel.h>

#include <kernel/kern_priv.h>

#include <nk_trace.h>

#include <arm.h>

#include <kernel/cache.h>

#include <platform.h>

#include <nkern.h>

#include <u32hal.h>

#include <rm_debug_api.h>

#include <sm_debug_api.h>

#include "d_rmd_breakpoints.h"

#include "d_process_tracker.h"

#include "d_rmd_stepping.h"

#include "rm_debug_kerneldriver.h"	// needed to access DRM_DebugChannel

#include "rm_debug_driver.h"

#include "debug_utils.h"

#include "debug_logging.h"

using namespace Debug;

/* @internalTechnology

 *

 * Checks whether aAddress is correctly aligned for placing a breakpoint of

 * cpu architecture aMode.

 *

 * @param aAddress - Virtual memory address to check

 * @param aMode - The CPU architecture mode of the breakpoint to be placed at aAddress

 * @return ETrue if aAddress is suitably aligned, EFalse otherwise.

 */

TBool D_RMD_Breakpoints::Aligned(TUint32 aAddress, Debug::TArchitectureMode aMode)

	{

	switch(aMode)

		{

		case Debug::EArmMode:

			// ARM breakpoints must be 32-bit aligned (lower two bits must be zero)

			if (aAddress & 0x3)

			{

				// Not 32-bit aligned.

				return EFalse;

			}

			break;

		case Debug::EThumbMode:

			// Thumb breakpoints must be 16-bit aligned (low bit must be zero)

			if (aAddress & 0x1)

			{

				// Not 16-bit aligned

				return EFalse;

			}

			break;

		case Debug::EThumb2EEMode:

			// Thumb-EE instructions are half-word aligned. See ARM ARM DDI0406A, section A3.2 Alignment Support

			// Note that some instructions need to be word-aligned, but this function does not know which ones.

			// It may also depend on the System Control register U bit.

			if (aAddress & 0x1)

			{

				// Not 16-bit aligned

				return EFalse;

			}

			break;

		default:

			{

			// No idea

			return EFalse;

			}

		}

	// Must be OK

	return ETrue;

	};

/* @internalTechnology

 *

 * Returns the size of a breakpoint of architecture aMode in bytes

 * 

 * @param aMode - The architure of the breakpoint

 * @return The size of the breakpoints in bytes. 0 if un-recognised architecture.

 */

TInt D_RMD_Breakpoints::BreakSize(Debug::TArchitectureMode aMode)

	{

	switch(aMode)

		{

		case Debug::EArmMode:

			{

				return 4;

			}

		case Debug::EThumbMode:

			{

				return 2;

			}

		case Debug::EThumb2EEMode:

			{

			// Only needs to be two bytes in size.

			return 2;

			}

		default:

			{

				// No idea

				return 0;

			}

		}

	};

/* @internalTechnology

 *

 * Checks whether two TBreakEntrys overlap

 *

 * @param aFirst - A TBreakEntry with valid iAddress and iMode fields.

 * @param aSecond  - A TBreakEntry with valid iAddress and iMode fields.

 * @return ETrue if the aFirst and aSecond overlap or the overlap cannot be determined

 *         , EFalse otherwise

 */

TBool D_RMD_Breakpoints::BreakpointsOverlap(TBreakEntry& aFirst, TBreakEntry& aSecond)

	{

	TInt firstSize = BreakSize(aFirst.iMode);

	TInt secondSize = BreakSize(aSecond.iMode);

	// Do we know the size of each breakpoint?

	if ((firstSize <= 0) || (secondSize <= 0))

		{

		// We don't know the size of the breakpoint, so assume they overlap

		return ETrue;

		}

	TInt firstStartAddress = aFirst.iAddress;

	TInt secondStartAddress = aSecond.iAddress;

	TInt firstEndAddress = firstStartAddress + firstSize - 1;

	TInt secondEndAddress = secondStartAddress + secondSize - 1;

	// If second breakpoint is past the end of the first then we're ok

	if(firstEndAddress < secondStartAddress)

		{

		return EFalse;

		}

	// If first breakpoint is past the end of the second then we're ok

	if(secondEndAddress < firstStartAddress)

		{

		return EFalse;

		}

	// The breakpoints overlap

	return ETrue;

	}

/* @internalTechnology

 * 

 * Returns the breakpoint bitpattern to use for each architecture type

 *

 * @param aMode - the cpu architecture type

 * @return The bit-pattern to use for the specified architecture, or 0 if unsupported.

 */

TUint32 D_RMD_Breakpoints::BreakInst(Debug::TArchitectureMode aMode)

	{

	switch(aMode)

		{

		case Debug::EArmMode:

			{

				return KArmBreakPoint;

			}

		case Debug::EThumbMode:

			{

				return KThumbBreakPoint;

			}

		case Debug::EThumb2EEMode:

			{

			return KT2EEBreakPoint;

			}

		default:

			{

				// No idea what the breakpoint should be

				return 0;

			}

		}

	};

/**

Constructor. Initialises its internal list of empty breakpoints.

*/

D_RMD_Breakpoints::D_RMD_Breakpoints(DRM_DebugChannel* aChannel)

: iBreakPointList(NUMBER_OF_TEMP_BREAKPOINTS, 0),

  iNextBreakId(NUMBER_OF_TEMP_BREAKPOINTS),

  iChannel(aChannel),

  iInitialised(EFalse)

	{

	iBreakPointList.Reset();	

	TBreakEntry emptyTempBreak;

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

		{

		emptyTempBreak.iBreakId = i;

		if (KErrNone != iBreakPointList.Append(emptyTempBreak))

			{

			LOG_MSG("D_RMD_Breakpoints::D_RMD_Breakpoints() - Error appending blank temp break entry");

			}

		}

	}

/**

Destructor. Clears all the breakpoints in the system, deletes its internal list of breakpoints,

and closes the exclusivity semaphore.

*/

D_RMD_Breakpoints::~D_RMD_Breakpoints()

	{

	ClearAllBreakPoints();

	// close the breakpoint list and free the memory associated with it

	iBreakPointList.Close();

	if (iLock)

		iLock->Close(NULL);

	}

/**

Initialises the breakpoint list exclusion semaphore. This should be called once immediately after

the constructor.

@return KErrNone if successful, one of the other system wide error codes otherwise.

*/

TInt D_RMD_Breakpoints::Init()

	{

	TInt err = KErrNone;

	// Only create a semaphore if we are not initialised

	if(!iInitialised)

		{

		// Initialise the semaphore ensuring exclusive access to the breakpoint list

		err = Kern::SemaphoreCreate(iLock, _L("RM_DebugBreakpointLock"), 1 /* Initial count */);

		if (err == KErrNone)

			{

			iInitialised = ETrue;

			}

		}

	else

		{

		err = KErrNone;

		}

	return err;

	}

/** 

Public member function which sets a thread-specific breakpoint in the specified thread

and returns an opaque handle to the caller.

Note 1:

This function ensures exclusive access to the breakpoint data structures

by using a semaphore to serialise access.

@see priv_DoSetBreak

Note 2:

As implied by Note 1, the caller must have previously called Init() or this

function will return KErrNotReady;

@param aBreakId - Reference to a TUint32 into which the function will return a unique breakpoint Id.

@param aThreadId - The thread Id in which to place the breakpoint

@param aAddress - Address to place the breakpoint

@param aMode - The cpu instruction set architecture type breakpoint (e.g. EArmMode or EThumbMode)

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt D_RMD_Breakpoints::DoSetBreak(TInt32 &aBreakId, const TUint64 aId, const TBool aThreadSpecific, const TUint32 aAddress, const TArchitectureMode aMode)

	{

	// Ensure we have a valid semaphore

	if (!iInitialised || !iLock)

		{

		return KErrNotReady;

		}

	// Acquire the lock

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	// Really do the work

	TInt err = priv_DoSetBreak(aBreakId, aId, aThreadSpecific, aAddress,aMode);

	// Release the lock

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

	return err;

	}

/**

Private member function which sets a thread-specific breakpoint in the specified thread

and returns an opaque handle to the caller.

@see DoSetBreak

@param aBreakId - Reference to a TUint32 into which the function will return a unique breakpoint Id.

@param aThreadId - The thread Id in which to place the breakpoint

@param aAddress - Address to place the breakpoint

@param aMode - The cpu instruction set architecture type breakpoint (e.g. EArmMode or EThumbMode)

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt D_RMD_Breakpoints::priv_DoSetBreak(TInt32 &aBreakId, const TUint64 aId, const TBool aThreadSpecific, const TUint32 aAddress, const TArchitectureMode aMode)

	{

	LOG_MSG4("D_RMD_Breakpoints::priv_DoSetBreak(aThreadId = 0x%016lx, aAddress = 0x%08x, aMode = %d)",aId,aAddress,aMode);

	// EThumb2EEMode breakpoints are not supported

	if (EThumb2EEMode == aMode)

		{

		LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - EThumb2EEMode breakpoints are not supported");

		return KErrNotSupported;

		}

	// Check how many breakpoints we have in existence

	if ((iBreakPointList.Count()+1) >= NUMBER_OF_MAX_BREAKPOINTS)

		{

		// Too many breakpoints are set!

		LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - Too many breakpoints set");

		return KErrOverflow;

		}

	// check the alignment of the breakpoint

	if (!Aligned(aAddress,aMode))

		{

		LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - Unaligned address");

		return KErrArgument;

		}

	// make sure there is not already a breakpoint at this address

	for (TInt i = NUMBER_OF_TEMP_BREAKPOINTS; i < iBreakPointList.Count(); i++)

		{

		/* We need to check if the breakpoint overlaps the address at all,

		 * and this depends upon the size of the two breakpoints as well as 

		 * their address.

		 */

		// newInstSize = size in bytes of new breakpoint

		TInt newInstSize = BreakSize(aMode);

		if (newInstSize == 0)

			{

			LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - Unknown architecture type for new breakpoint");

			return KErrNotSupported;

			}

		// oldInstSize = size in bytes of the existing breakpoint

		TInt oldInstSize = BreakSize(iBreakPointList[i].iMode);

		if (oldInstSize == 0)

			{

			LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - : Unknown architecture type of existing breakpoint");

			return KErrNotSupported;

			}

		// Overlap checking - temp is used as the new breakpoint description for checking purposes only

		TBreakEntry temp;

		temp.iAddress = aAddress;

		temp.iMode = aMode;

		// do they overlap?

		if ( BreakpointsOverlap(temp,iBreakPointList[i]) )

			{

			// Yes

			if(iBreakPointList[i].iThreadSpecific && aThreadSpecific)

				{

				if(aId == iBreakPointList[i].iId)

					{

					LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - New thread specific breakpoint overlaps an existing thread specific breakpoint");

					return KErrAlreadyExists;

					}

				}

			else if(!iBreakPointList[i].iThreadSpecific && aThreadSpecific)

				{

				DThread* thread = DebugUtils::OpenThreadHandle(aId);

				if(!thread)

					{

					return KErrNotFound;

					}

				if(thread->iOwningProcess->iId == iBreakPointList[i].iId)

					{

					LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - New thread specific breakpoint overlaps an existing breakpoint");

					thread->Close(NULL);

					return KErrAlreadyExists;

					}

				thread->Close(NULL);

				}

			else if(iBreakPointList[i].iThreadSpecific && !aThreadSpecific)

				{

				DThread* thread = DebugUtils::OpenThreadHandle(iBreakPointList[i].iId);

				if(!thread)

					{

					return KErrNotFound;

					}

				if(thread->iOwningProcess->iId == aId)

					{

					LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - New breakpoint overlaps an existing thread specific breakpoint");

					thread->Close(NULL);

					return KErrAlreadyExists;

					}

				thread->Close(NULL);

				}

			else // !iBreakPointList[i].iThreadSpecific && !aThreadSpecific

				{

				if(iBreakPointList[i].iId == aId)

					{

					LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - New breakpoint overlaps an existing breakpoint");

					return KErrAlreadyExists;

					}

				}

			}

		}

	// increment the break id

	aBreakId = iNextBreakId++;	

	// create the new breakpoint entry

	TBreakEntry breakEntry(aBreakId, aId, aThreadSpecific, aAddress, aMode);

	TInt err = priv_DoEnableBreak(breakEntry, ETrue);

	if (KErrNone != err)

		{

		LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - Could not enable the breakpoint");

		return err;

		}

	err = iBreakPointList.Append(breakEntry);

	if (err != KErrNone)

		{

		LOG_MSG("D_RMD_Breakpoints::priv_DoSetBreak() - Failed to append breakpoint");

		}

	LOG_MSG2("D_RMD_Breakpoints::priv_DoSetBreak(breakId = 0x%08x) done",aBreakId);

	return err;

	}

/**

Public member function which enables a previously set breakpoint.

Note 1:

This function ensures exclusive access to the breakpoint data structures

by using a semaphore to serialise access.

@see priv_DoEnableBreak

Note 2:

As implied by Note 1, the caller must have previously called Init() or this

function will return KErrNotReady;

Note 3

Historically, this function accepted a reference to a TBreakEntry in the class' own

iBreakPointList. It now checks whether the reference is to an element of its own list,

or one invented by the caller.

@param aEntry reference to a TBreakEntry datastructure describing the breakpoint to be re-enabled.

@param aSaveOldInstruction ETrue preserves the instruction at the breakpoint address, EFalse otherwise.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt D_RMD_Breakpoints::DoEnableBreak(TBreakEntry &aEntry, TBool aSaveOldInstruction)

	{

	// Ensure we have a valid semaphore

	if (!iInitialised || !iLock)

		{

		return KErrNotReady;

		}

	// Acquire the lock

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	// Really do the work

	TInt err = priv_DoEnableBreak(aEntry,aSaveOldInstruction);

	// Release the lock

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

	return err;

	}

/**

Private member function which enables a previously set breakpoint, as per DoEnableBreak, but

does not serialise access.

@see DoEnableBreak

@param aEntry reference to a TBreakEntry datastructure describing the breakpoint to be re-enabled.

@param aSaveOldInstruction ETrue preserves the instruction at the breakpoint address, EFalse otherwise.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt D_RMD_Breakpoints::priv_DoEnableBreak(TBreakEntry &aEntry, TBool aSaveOldInstruction)

	{

	LOG_MSG("D_RMD_Breakpoints::DoEnableBreak()");

	TUint32 inst = BreakInst(aEntry.iMode);	

	TInt instSize = BreakSize(aEntry.iMode);

	if (instSize == 0 || inst == 0)

		{

		// not supported

		LOG_MSG("D_RMD_Breakpoints::priv_DoEnableBreak - unsupported breakpoint architecture");

		return KErrNotSupported;

		}

	TInt err = KErrNone;

	// Get thread id

	TUint64 threadId = aEntry.iId + (aEntry.iThreadSpecific ? 0 : 1);

	DThread* threadObj = DebugUtils::OpenThreadHandle(threadId);

	if (!threadObj)

		{

		LOG_MSG("D_RMD_Breakpoints::priv_DoEnableBreak - bad handle. Could not identify a threadObj");

		return KErrBadHandle;

		}

	if (aSaveOldInstruction)

		{

		TUint32 instruction;

		// read the instruction at the address so we can store it in the break entry for when we clear this breakpoint

		// trap exceptions in case the address is invalid

		XTRAPD(r, XT_DEFAULT, err = iChannel->TryToReadMemory(threadObj, (TAny *)aEntry.iAddress, (TAny *)&instruction, instSize));

		//consider the leave as more important than the error code so store the leave if it's not KErrNone

		if(KErrNone != r)

			{

			err = r;

			}

		if(KErrNone != err)

			{

			threadObj->Close(NULL);

			LOG_MSG("D_RMD_Breakpoints::priv_DoEnableBreak() - failed to read memory");

			return err;

			}

		aEntry.iInstruction.Copy((TUint8 *)&instruction, instSize);

		}

	TBool breakpointAlredySet = EFalse;

	for (TInt i = NUMBER_OF_TEMP_BREAKPOINTS; i < iBreakPointList.Count(); i++)

		{

		if(iBreakPointList[i].iAddress == aEntry.iAddress && !iBreakPointList[i].iDisabledForStep )

			{

			breakpointAlredySet = ETrue;

			break;

			}

		}

	if(!breakpointAlredySet)

		{

		XTRAPD(r, XT_DEFAULT, err = DebugSupport::ModifyCode(threadObj, aEntry.iAddress, instSize, inst, DebugSupport::EBreakpointGlobal));

		if(r != DebugSupport::EBreakpointGlobal)

			{

			err = r;

			}

		}

	// Close the thread handle which has been opened by OpenThreadHandle

	threadObj->Close(NULL);

	return err;

	}

/**

Public member function which clears a previously set breakpoint.

Note 1:

This function ensures exclusive access to the breakpoint data structures

by using a semaphore to serialise access.

@see priv_DoClearBreak

Note 2:

As implied by Note 1, the caller must have previously called Init() or this

function will return KErrNotReady;

@param aBreakId A breakpoint Id as previously returned by DoSetBreak.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt D_RMD_Breakpoints::DoClearBreak(const TInt32 aBreakId, TBool aIgnoreTerminatedThreads)

	{

	// Ensure we have a valid semaphore

	if (!iInitialised || !iLock)

		{

		return KErrNotReady;

		}

	// Acquire the lock

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	// Really do the work

	TInt err = priv_DoClearBreak(aBreakId, aIgnoreTerminatedThreads);

	// Release the lock

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

	return err;

	}

/**

Private member function which clears a previously set breakpoint, as per DoClearBreak, but

does not serialise access.

@see DoClearBreak

@param aBreakId A breakpoint Id as previously returned by DoSetBreak.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt D_RMD_Breakpoints::priv_DoClearBreak(const TInt32 aBreakId, TBool aIgnoreTerminatedThreads)

	{

	LOG_MSG2("D_RMD_Breakpoints::priv_DoClearBreak(0x%08x)",aBreakId);

	// find the break entry matching this id.  note that the breakpoints are already sorted in ascending order by id

	TBreakEntry entry;

	entry.iBreakId = aBreakId;

	TInt index = iBreakPointList.FindInSignedKeyOrder(entry);

	TInt err = KErrNone;

	if (index >= 0)

		{

		//only let the agent clear the break if they have previously suspended the thread

		//iThreadSpecific value decides whether the the iBreakPointList.Id has a thread id(TID) or the process id(PID) 

		//the assumption here that TID = PID + 1

		if(!TheDProcessTracker.CheckSuspended((iBreakPointList[index].iId + (iBreakPointList[index].iThreadSpecific ? 0 : 1))))

			{

			LOG_MSG2("D_RMD_Breakpoints::priv_DoClearBreak() - Thread with id 0x%08x not suspended", iBreakPointList[index].iId);

			// should be "return KErrInUse;" but not always possible, e.g. cleaning up threads which die after debugger disconnects

			}

 		// if this breakpoint was set in a library and that library has already been unloaded, don't try to clear it

		if (!iBreakPointList[index].iObsoleteLibraryBreakpoint)

			{

			DThread* threadObj = DebugUtils::OpenThreadHandle(iBreakPointList[index].iId + (iBreakPointList[index].iThreadSpecific ? 0 : 1));

			if (threadObj)

				{

				TBool needToCallCodeModifier = ETrue;

				for (TInt i = NUMBER_OF_TEMP_BREAKPOINTS; i < iBreakPointList.Count(); i++)

					{

					if (i != index)

						{

						if ( BreakpointsOverlap(iBreakPointList[index],iBreakPointList[i]) )

							{

							needToCallCodeModifier = EFalse;

							break;

							}

						}

					}

				if(needToCallCodeModifier)

					{

					XTRAPD(r, XT_DEFAULT, err = DebugSupport::RestoreCode(threadObj, iBreakPointList[index].iAddress));

					if (r != KErrNone)

						{

						LOG_MSG2("D_RMD_Breakpoints::priv_DoClearBreak() - restore code trap harness returned error %d",r);

						}

				if (err != KErrNone)

						{

						LOG_MSG2("D_RMD_Breakpoints::priv_DoClearBreak() - restore code returned error %d",err);

						}

					err = (KErrNone == r) ? err : r;

					}

				// Close the thread handle opened by OpenThreadHandle

				threadObj->Close(NULL);

				}

			else

				{

				err = KErrBadHandle;

				}

			}

		LOG_MSG4("D_RMD_Breakpoints::priv_DoClearBreak() - Clearing breakpoint at address: %x, err: %d, ignore terminated: %d", iBreakPointList[index].iAddress, err, aIgnoreTerminatedThreads?1:0);

		if ((aIgnoreTerminatedThreads && KErrBadHandle == err) || KErrNone == err)

			{

			// if this is a temp breakpoint, just clear out the values, otherwise remove it from the list

			err = KErrNone;

			if (index < NUMBER_OF_TEMP_BREAKPOINTS)

				{

				iBreakPointList[index].Reset();

				}

			else

				{

				LOG_MSG3("D_RMD_Breakpoints::priv_DoClearBreak() - Removing breakpoint 0x%08x as breakid 0x%08x\n",index, entry.iBreakId);

				iBreakPointList.Remove(index);

				}			

			}

		return err;

		}

	LOG_MSG2("D_RMD_Breakpoints::priv_DoClearBreak() - Break Id %d not found", aBreakId);

	return KErrNotFound;

	}

/**

Public member function which modifies a previously set breakpoint.

Note 1:

This function ensures exclusive access to the breakpoint data structures

by using a semaphore to serialise access.

@see priv_DoModifyBreak

Note 2:

As implied by Note 1, the caller must have previously called Init() or this

function will return KErrNotReady;

@param aBreakInfo A TModifyBreakInfo describing the breakpoint properties that are wanted.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt D_RMD_Breakpoints::DoModifyBreak(TModifyBreakInfo* aBreakInfo)

	{

	// Ensure we have a valid semaphore

	if (!iInitialised || !iLock)

		{

		return KErrNotReady;

		}

	// Acquire the lock

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock); 

	// Really do the work

	TInt err = priv_DoModifyBreak(aBreakInfo);

	// Release the lock

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

	return err;

	}

/**

Private member function which modifies a previously set breakpoint, as per DoModifyBreak, but

does not serialise access.

@see DoModifyBreak

@param aBreakInfo A TModifyBreakInfo describing the breakpoint properties that are wanted.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt D_RMD_Breakpoints::priv_DoModifyBreak(TModifyBreakInfo* aBreakInfo)

	{

	LOG_MSG("D_RMD_Breakpoints::priv_DoModifyBreak()");

	// Check arguments

	if (!aBreakInfo)

		{

		LOG_MSG("D_RMD_Breakpoints::priv_DoModifyBreak() was passed a NULL argument");

		return KErrArgument;

		}

	//User side memory is not accessible directly

	TSetBreakInfo info;

	TInt err = Kern::ThreadRawRead(iChannel->iClientThread, aBreakInfo, (TUint8*)&info, sizeof(TSetBreakInfo));

	if (err != KErrNone)

		{

		LOG_MSG("D_RMD_Breakpoints::priv_DoModifyBreak() was passed a bad argument");

		return err;

		}

	// EThumb2EEMode breakpoints are not supported

	if (EThumb2EEMode == info.iMode)

		{

		LOG_MSG("D_RMD_Breakpoints::priv_DoModifyBreak() - EThumb2EEMode breakpoints are not supported");

		return KErrNotSupported;

		}

	// find the break entry matching this id.  note that the breakpoints are already sorted in ascending order by id

	TBreakEntry entry;

	entry.iBreakId = (TUint32)info.iBreakId;

	TInt index = iBreakPointList.FindInSignedKeyOrder(entry);

	if (index < 0)

		{

		// Could not find the breakpoint

		LOG_MSG2("D_RMD_Breakpoints::priv_DoModifyBreak() - Could not find the breakpoint id 0x%08x",(TUint32)info.iBreakId);

		return KErrNotFound;

		}

	//assert that the thread we're moving the break from is suspended

	if(!TheDProcessTracker.CheckSuspended(iBreakPointList[index].iId))

		{

		LOG_MSG2("D_RMD_Breakpoints::priv_DoModifyBreak() - Thread with id 0x%08x not suspended", iBreakPointList[index].iId);

		return KErrInUse;

		}

	//assert that the thread we're moving the break to is suspended

	if(!TheDProcessTracker.CheckSuspended(info.iId))

		{

		LOG_MSG2("D_RMD_Breakpoints::priv_DoModifyBreak() - Thread with id 0x%08x not suspended", info.iId);

		return KErrInUse;

		}

	// first check its not obsolete

	if (!iBreakPointList[index].iObsoleteLibraryBreakpoint)

		{

		// its still a valid breakpoint

		// remove the old breakpoint

		DThread* threadObj = DebugUtils::OpenThreadHandle(iBreakPointList[index].iId);

		if (threadObj)

			{

			LOG_MSG2("D_RMD_Breakpoints::priv_DoModifyBreak - Unsetting breakpoint at address 0x%08x",iBreakPointList[index].iAddress);

			XTRAPD(r, XT_DEFAULT, err = DebugSupport::RestoreCode(threadObj, iBreakPointList[index].iAddress));

			if (r != 0)

				{

				LOG_MSG("Failed to construct trap handler for DebugSupport::RestoreCode");

				}

			// Close the thread handle which has been opened by OpenThreadHandle

			threadObj->Close(NULL);

			}

		else

			{

			// Bad handle

			LOG_MSG("D_RMD_Breakpoints::priv_DoModifyBreak - Could not identify the breakpoint thread id");

			return KErrBadHandle;

			}

		}

	// make sure there is not already a breakpoint at the new address

	for (TInt i = NUMBER_OF_TEMP_BREAKPOINTS; i < iBreakPointList.Count(); i++)

		{

		// Ignore data for the breakpoint entry being modified.

		if (i != index)

			{

			/* We need to check if the breakpoint overlaps the address at all,

			 * and this depends upon the size of the two breakpoints as well as 

			 * their address.

			 */

			// newInstSize = size in bytes of new breakpoint

			TInt newInstSize = BreakSize(info.iMode);

			if (newInstSize == 0)

			{

				LOG_MSG("D_RMD_Breakpoints::priv_DoModifyBreak - Unknown architecture type for new breakpoint");

				return KErrNotSupported;

			}

			// oldInstSize = size in bytes of the existing breakpoint

			TInt oldInstSize = BreakSize(iBreakPointList[i].iMode);

			if (oldInstSize == 0)

			{

				LOG_MSG("D_RMD_Breakpoints::priv_DoModifyBreak - Unknown architecture type of existing breakpoint");

				return KErrNotSupported;

			}

			// Overlap checking - temp is used as the new breakpoint description for checking purposes only

			TBreakEntry temp;

			temp.iAddress = info.iAddress;

			temp.iMode = info.iMode;

			// do they overlap?

			if ( BreakpointsOverlap(temp,iBreakPointList[i]) )

				{

				// Yes

				LOG_MSG("D_RMD_Breakpoints::priv_DoModifyBreak() - New breakpoint overlaps an existing breakpoint");

				return KErrAlreadyExists;

				}

			}

		}

	// Prepare iBreakPointList[index] with the new information, then set the breakpoint

	iBreakPointList[index].iId = info.iId;

	iBreakPointList[index].iAddress = info.iAddress;

	iBreakPointList[index].iMode = info.iMode;

	TBreakEntry& newBreakEntry = iBreakPointList[index];

	// Decide the size of the breakpoint instruction

	TUint32 inst = BreakInst(newBreakEntry.iMode);

	TInt instSize = BreakSize(newBreakEntry.iMode);

	if (inst == 0 || instSize == 0)

		{

		// Unsupported architecture

		LOG_MSG("D_RMD_Breakpoints::priv_DoModifyBreak - unsupported breakpoint architecture");

		return KErrNotSupported;

		}

	//if thread id is 0xFFFFFFFF, then the breakpoint is not thread specific

	if (newBreakEntry.iId != 0xFFFFFFFF)

		{

		newBreakEntry.iThreadSpecific = ETrue;

		}

	// Get thread id from the process that we are debugging

	TProcessInfo * proc = NULL;

	TUint64 threadId = NULL;

	threadId = newBreakEntry.iId;

	DThread* threadObj = DebugUtils::OpenThreadHandle(threadId);

	//if we don't have the right thread id for the address, 

	//then try with the thread id of the process that we are debugging 	

	if (!threadObj && iChannel->iDebugProcessList.Count())

		{

		proc = &iChannel->iDebugProcessList[0];

		if (proc)

			{

			threadId = proc->iId+1;	

			}

		threadObj = DebugUtils::OpenThreadHandle(threadId);

		}

	if(!threadObj)

		{

		LOG_MSG("D_RMD_Breakpoints::priv_DoModifyBreak() - bad handle. Could not identify a threadObj");

		return KErrBadHandle;

		}

	// save the old instruction

	TUint32 instruction;

	// read the instruction at the address so we can store it in the break entry for when we clear this breakpoint

	// trap exceptions in case the address is invalid

	XTRAPD(r, XT_DEFAULT, err = iChannel->TryToReadMemory(threadObj, (TAny *)newBreakEntry.iAddress, (TAny *)&instruction, instSize));

	//consider the leave as more important than the error code so store the leave if it's not KErrNone

	if(KErrNone != r)

		{

		err = r;

		}

	if(KErrNone != err)

		{

		threadObj->Close(NULL);

		return err;

		}

	newBreakEntry.iInstruction.Copy((TUint8 *)&instruction, instSize);

	newBreakEntry.iId = threadId; //set the thread ID here 

	LOG_MSG3("ModifyCode2 instSize:%d, inst: 0x%08x", instSize, inst);

	XTRAPD(s, XT_DEFAULT, err = DebugSupport::ModifyCode(threadObj, newBreakEntry.iAddress, instSize, inst, DebugSupport::EBreakpointGlobal));

	if(s != DebugSupport::EBreakpointGlobal)

		{

		err = s;

		}

	// Close the thread handle which has been opened by OpenThreadHandle

	threadObj->Close(NULL);

	return err;

	}	

//

// D_RMD_Breakpoints::DoModifyProcessBreak

//

TInt D_RMD_Breakpoints::DoModifyProcessBreak(TModifyProcessBreakInfo* aBreakInfo)

	{

	// Ensure we have a valid semaphore

	if (!iInitialised || !iLock)

		{

		return KErrNotReady;

		}

	// Acquire the lock

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock); 

	// Really do the work

	TInt err = priv_DoModifyProcessBreak(aBreakInfo);

	// Release the lock

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

	return err;

	}

TInt D_RMD_Breakpoints::priv_DoModifyProcessBreak(TModifyProcessBreakInfo* aBreakInfo)

	{	

	LOG_MSG("D_RMD_Breakpoints::priv_DoModifyProcessBreak()");

	// Check arguments