1 // Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Tests the functionality of the run mode debug device driver.

    15 //

    16 //

    17 

    18 #include <e32base.h>

    19 #include <e32base_private.h>

    20 #include <e32cons.h>

    21 #include <e32test.h>

    22 #include <e32ldr.h>

    23 #include <e32cmn.h>

    24 #include <e32cmn_private.h>

    25 #include <f32dbg.h>

    26 #include <f32file.h>

    27 #include <hal.h>

    28 #include <u32hal.h>

    29 #include <e32property.h>

    30 

    31 #include "t_rmdebug_dll.h"

    32 

    33 #include <rm_debug_api.h>

    34 #include "d_rmdebugthread2.h"

    35 #include "t_rmdebug2.h"

    36 #include "t_rmdebug_app.h"

    37 

    38 #ifdef __MARM_ARMV4__

    39 #include "d_rmdebug_step_test_armv4.h"

    40 #endif

    41 

    42 #ifdef __MARM_ARMV5__

    43 #include "d_rmdebug_step_test.h"

    44 #include "d_rmdebug_bkpt_test.h"

    45 #endif

    46 

    47 #include "d_demand_paging.h"

    48 

    49 #ifdef KERNEL_OOM_TESTING

    50 	#ifdef USER_OOM_TESTING

    51 		#error "Cannot define both KERNEL_OOM_TESTING and USER_OOM_TESTING"

    52 	#endif

    53 #endif

    54 

    55 #if  defined (NO_DEBUGTOKEN)  || defined (SOMECAPS_DEBUGTOKEN) || defined (FEWCAPS_DEBUGTOKEN)

    56 _LIT8(KCrashDummyData, "This is a sample write");

    57 #endif

    58 

    59 using namespace Debug;

    60 

    61 const TVersion securityServerVersion(0,1,1);

    62 

    63 const TVersion testVersion(2,1,0);

    64 

    65 IMPORT_C TInt StartDebugThread(RThread& aServerThread, const TDesC& aDebugThreadName);

    66  

    67 extern TInt TestData;

    68 extern TTestFunction FunctionChooser;

    69 extern TBuf8<SYMBIAN_RMDBG_MEMORYSIZE> gMemoryAccessBytes;

    70 

    71 IMPORT_C TInt TestFunction();

    72 IMPORT_C void TestPagedCode();

    73 IMPORT_C extern TInt RMDebugDemandPagingTest();

    74 

    75 // Device driver name

    76 _LIT(KDebugDriverFileName,"rm_debug.ldd");

    77 _LIT(KRMDebugAppName, "t_rmdebug_app");

    78 

    79 

    80 #if defined(NO_DEBUGTOKEN)

    81     _LIT(KTestName, "T_RMDEBUG2");

    82 #elif defined(SOMECAPS_DEBUGTOKEN)

    83     _LIT(KTestName, "T_RMDEBUG2_OEM");

    84 #elif defined(FEWCAPS_DEBUGTOKEN)

    85     _LIT(KTestName, "T_RMDEBUG2_OEM2");

    86 #elif defined(ALLCAPS_DEBUGTOKEN)

    87     _LIT(KTestName, "T_RMDEBUG2_ALLCAPS");

    88 #endif

    89 

    90 #define TIMED_WAIT(request, timeoutInMs) CRunModeAgent::TimedWait(request, timeoutInMs, __LINE__)

    91 

    92 LOCAL_D RTest test(KTestName);

    93 

    94 TBool gUseDelay;

    95 

    96 CRunModeAgent::CRunModeAgent()

    97 //

    98 // CRunModeAgent constructor

    99 //

   100 	{

   101 	FillArray();

   102 	RProcess thisProcess;

   103 	iFileName = thisProcess.FileName();

   104 	thisProcess.Close();

   105 	}

   106 

   107 CRunModeAgent* CRunModeAgent::NewL()

   108 //

   109 // CRunModeAgent::NewL

   110 //

   111 	{

   112 	CRunModeAgent* self = new(ELeave) CRunModeAgent();

   113 

   114   	self->ConstructL();

   115 

   116 	return self;

   117 	}

   118 

   119 CRunModeAgent::~CRunModeAgent()

   120 //

   121 // CRunModeAgent destructor

   122 //

   123 	{

   124     iTimer.Close();

   125     iRunCountSubscribe.Close();

   126     

   127 	User::FreeLogicalDevice(KDebugDriverFileName);

   128 	iServSession.Close();

   129 	iDebugThread.Close();

   130 	}

   131 

   132 void CRunModeAgent::ConstructL()

   133 //

   134 // CRunModeAgent::ConstructL

   135 //

   136 	{

   137 	// nothing to do here

   138 	}

   139 

   140 void CRunModeAgent::SetupAndAttachToDSS()

   141 //

   142 // CRunModeAgent::SetupAndAttachToDSS

   143 //

   144 	{

   145 	TInt err = StartDebugThread(iDebugThread, KDebugThreadName);

   146 

   147 	// get the thread id for use in the tests

   148 	iThreadID = iDebugThread.Id();

   149 

   150 	if (err != KErrNone)

   151 		{

   152 		User::Panic(_L("Can't start debug thread"), err);

   153 		}

   154 

   155     err = iRunCountSubscribe.Attach( RProcess().SecureId(), CDebugServThread::ERMDBGRunCountProperty);

   156     if (err != KErrNone)

   157         {

   158         User::Panic(_L("Can't attach to RProperty iRunCountSubscribe"), err);

   159         }

   160 

   161     err = iTimer.CreateLocal(); 

   162     if (err != KErrNone)

   163         {

   164         User::Panic(_L("Can't create RTimer::CreateLocal()"), err);

   165         }

   166     

   167 	err = iServSession.Connect(securityServerVersion);

   168 	if (err != KErrNone)

   169 		{

   170 		User::Panic(_L("Can't open server session"), err);

   171 		}

   172 	}

   173 

   174 CRunModeAgent *RunModeAgent;

   175 

   176 // helper function to check whether the listing of type aListId is supported for a scope of aListScope

   177 TBool CRunModeAgent::ListingSupported(const TListId aListId, const TListScope aListScope)

   178 	{

   179 	TTag tag = GetTag(ETagHeaderList, aListId);

   180 

   181 	return (tag.iValue) & aListScope;

   182 	}

   183 

   184 //---------------------------------------------

   185 //! @SYMTestCaseID KBase-T-RMDEBUG2-0426

   186 //! @SYMTestType

   187 //! @SYMPREQ PREQ1426

   188 //! @SYMTestCaseDesc Test getting the list of XIP libraries

   189 //! @SYMTestActions The XIP library list should be successfully obtained

   190 //! @SYMTestExpectedResults The specified ldd file should be present in the obtained listing

   191 //! @SYMTestPriority High

   192 //! @SYMTestStatus Implemented

   193 //---------------------------------------------

   194 void CRunModeAgent::TestGetXipLibrariesList()

   195 	{

   196 	test.Next(_L("TestGetXipLibrariesList\n"));

   197 

   198 	test(ListingSupported(EXipLibraries, EScopeGlobal));

   199 	test(!ListingSupported(EXipLibraries, EScopeProcessSpecific));

   200 	test(!ListingSupported(EXipLibraries, EScopeThreadSpecific));

   201 

   202 	//allocate a very small buffer so the GetList call initially fails

   203 	RBuf8 buffer;

   204 	test(KErrNone == buffer.Create(1));

   205 	TUint32 size = 0;

   206 

   207 	//get the list data

   208 	DoGetList(EXipLibraries, EScopeGlobal, buffer, size);

   209 

   210 	//search the buffer for entry corresponding to the debug kernel driver

   211 	//which should be in the rom

   212 	_LIT(KRmDebugLddName, "z:\\sys\\bin\\rm_debug.ldd");

   213 

   214 	//iterate through the buffer and set found to ETrue if we find the driver

   215 	TBool found = EFalse;

   216 	TUint8* ptr = (TUint8*)buffer.Ptr();

   217 	const TUint8* ptrEnd = ptr + size;

   218 	while(ptr < ptrEnd)

   219 		{

   220 		TXipLibraryListEntry& xipLibrary = *(TXipLibraryListEntry*)ptr;

   221 

   222 		//get the name of the library

   223 		TPtr name(&xipLibrary.iName[0], xipLibrary.iNameLength, xipLibrary.iNameLength);

   224 		if(name.CompareF(KRmDebugLddName()) == 0)

   225 			{

   226 			//found the library but continue reading the rest of the buffer to

   227 			//check nothing bad happens towards the end

   228 			found = ETrue;

   229 			}

   230 		//move pointer on to next library

   231 		ptr += Align4(xipLibrary.GetSize());

   232 		}

   233 	test(found);

   234 

   235 	//do cleanup

   236 	buffer.Close();

   237 	}

   238 

   239 //---------------------------------------------

   240 //! @SYMTestCaseID KBase-T-RMDEBUG2-0427

   241 //! @SYMTestType

   242 //! @SYMPREQ PREQ1426

   243 //! @SYMTestCaseDesc Test getting the list of executables

   244 //! @SYMTestActions The list of debuggable executable files should be obtained

   245 //! @SYMTestExpectedResults The client exe should appear in the list

   246 //! @SYMTestPriority High

   247 //! @SYMTestStatus Implemented

   248 //---------------------------------------------

   249 void CRunModeAgent::TestGetExecutablesList()

   250 	{

   251 	test.Next(_L("TestGetExecutablesList\n"));

   252 

   253 	test(ListingSupported(EExecutables, EScopeGlobal));

   254 	test(!ListingSupported(EExecutables, EScopeProcessSpecific));

   255 	test(!ListingSupported(EExecutables, EScopeThreadSpecific));

   256 

   257 	//allocate a very small buffer so the GetList call initially fails

   258 	RBuf8 buffer;

   259 	test(KErrNone == buffer.Create(1));

   260 	TUint32 size = 0;

   261 

   262 	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

   263 

   264 	//get the list data

   265 	DoGetList(EExecutables, EScopeGlobal, buffer, size);

   266 

   267 	//get this process' name

   268 	RProcess thisProcess;

   269 	TFileName thisProcessName = thisProcess.FileName();

   270 

   271 	//look through the buffer and check if the target debug thread is there

   272 	TBool found = EFalse;

   273 	TUint8* ptr = (TUint8*)buffer.Ptr();

   274 	const TUint8* ptrEnd = ptr + size;

   275 	while(ptr < ptrEnd)

   276 		{

   277 		TExecutablesListEntry& entry = *(TExecutablesListEntry*)ptr;

   278 		//get name

   279 		TPtr name(&entry.iName[0], entry.iNameLength, entry.iNameLength);

   280 		if( (entry.iIsActivelyDebugged != 0) && (0 == thisProcessName.CompareF(name)) )

   281 			{

   282 			//found this process and asserted it is being actively debugged

   283 			found = ETrue;

   284 			}

   285 		//move pointer on to next entry

   286 		ptr += Align4(entry.GetSize());

   287 		}

   288 	test(found);

   289 

   290 	//clean up

   291 	buffer.Close();

   292 

   293 	test(KErrNone == iServSession.DetachExecutable(iFileName));

   294 	}

   295 

   296 //---------------------------------------------

   297 //! @SYMTestCaseID KBase-T-RMDEBUG2-0428

   298 //! @SYMTestType

   299 //! @SYMPREQ PREQ1426

   300 //! @SYMTestCaseDesc Test error conditions for the GetList calls

   301 //! @SYMTestActions Multiple calls to test calling GetList with bad arguments

   302 //! @SYMTestExpectedResults All tests should fail with the appropriate error codes

   303 //! @SYMTestPriority High

   304 //! @SYMTestStatus Implemented

   305 //---------------------------------------------

   306 void CRunModeAgent::TestGetListInvalidData()

   307 	{

   308 	test.Next(_L("TestGetListInvalidData\n"));

   309 

   310 	//allocate a buffer, the size should not matter as expecting all calls to fail

   311 	RBuf8 buffer;

   312 	test(KErrNone == buffer.Create(1));

   313 	TUint32 size = 0;

   314 

   315 	//test what happens if we ask for an unsupported list type globally

   316 	test(KErrNotSupported == iServSession.GetList((TListId)1234, buffer, size));

   317 

   318 	//test what happens if we ask for an unsupported list type

   319 	test(KErrNotSupported == iServSession.GetList(RThread().Id(), (TListId)1234, buffer, size));

   320 

   321 	//test what happens if we try to get a non-global libraries list

   322 	test(KErrArgument == iServSession.GetList(RThread().Id(), EXipLibraries, buffer, size));

   323 

   324 	//test what happens if we try to get a non-global executables list

   325 	test(KErrArgument == iServSession.GetList(RThread().Id(), EExecutables, buffer, size));

   326 

   327 	//test what happens if we try to get a non-global process list

   328 	test(KErrArgument == iServSession.GetList(RThread().Id(), EProcesses, buffer, size));

   329 

   330 	//check that using a process id fails

   331 	test(KErrArgument == iServSession.GetList(RProcess().Id(), EProcesses, buffer, size));

   332 

   333 	//check that specifying a non-existant thread id fails

   334 	test(KErrArgument == iServSession.GetList((TThreadId)0x12345678, EThreads, buffer, size));

   335 

   336 	//check that specifying a non-existant process id fails

   337 	test(KErrArgument == iServSession.GetList((TProcessId)0x12345678, EThreads, buffer, size));

   338 

   339 	//check that specifying a non-existant thread id fails

   340 	test(KErrArgument == iServSession.GetList((TThreadId)0x12345678, ECodeSegs, buffer, size));

   341 

   342 	//check that specifying a non-existant process id fails

   343 	test(KErrArgument == iServSession.GetList((TProcessId)0x12345678, ECodeSegs, buffer, size));

   344 

   345 	//cleanup

   346 	buffer.Close();

   347 	}

   348 

   349 //---------------------------------------------

   350 //! @SYMTestCaseID KBase-T-RMDEBUG2-0429

   351 //! @SYMTestType

   352 //! @SYMPREQ PREQ1426

   353 //! @SYMTestCaseDesc Test getting the process list

   354 //! @SYMTestActions Get the process listing

   355 //! @SYMTestExpectedResults The process listing should be successfully obtained and the current process should be present in the list

   356 //! @SYMTestPriority High

   357 //! @SYMTestStatus Implemented

   358 //---------------------------------------------

   359 void CRunModeAgent::TestGetProcessList()

   360 	{

   361 	test.Next(_L("TestGetProcessList\n"));

   362 

   363 	test(ListingSupported(EProcesses, EScopeGlobal));

   364 	test(!ListingSupported(EProcesses, EScopeProcessSpecific));

   365 	test(!ListingSupported(EProcesses, EScopeThreadSpecific));

   366 

   367 	//allocate a very small buffer so the GetList call fails

   368 	RBuf8 buffer;

   369 	test(KErrNone == buffer.Create(1));

   370 	TUint32 size = 0;

   371 

   372 	//get the list data

   373 	DoGetList(EProcesses, EScopeGlobal, buffer, size);

   374 

   375 	//initialise data about the target debug thread to compare the kernel's data against

   376 	RProcess thisProcess;

   377 	TFileName thisProcessName = thisProcess.FileName();

   378 	TUint32 processId = thisProcess.Id().Id();

   379 

   380 	//look through the buffer and check if the target debug thread is there

   381 	TBool found = EFalse;

   382 	TUint8* ptr = (TUint8*)buffer.Ptr();

   383 	const TUint8* ptrEnd = ptr + size;

   384 	while(ptr < ptrEnd)

   385 		{

   386 		TProcessListEntry& entry = *(TProcessListEntry*)ptr;

   387 		if( (RProcess().Id().Id() == entry.iProcessId) &&

   388 			(0 == thisProcessName.CompareF(TPtr(&(entry.iNames[0]), entry.iFileNameLength, entry.iFileNameLength))) &&

   389 		 	(0 == thisProcess.FullName().CompareF(TPtr(&(entry.iNames[0]) + entry.iFileNameLength, entry.iDynamicNameLength, entry.iDynamicNameLength))) &&

   390 			0x4321bbbb /* Magic */ == entry.iUid3)

   391 			{

   392 			//if all match then we've found it

   393 			found = ETrue;

   394 			}

   395 		ptr += Align4(entry.GetSize());

   396 		}

   397 

   398 	//check whether the expected result happened

   399 	test(found);

   400 

   401 	//clean up

   402 	buffer.Close();

   403 	}

   404 

   405 //---------------------------------------------

   406 //! @SYMTestCaseID KBase-T-RMDEBUG2-0430

   407 //! @SYMTestType

   408 //! @SYMPREQ PREQ1426

   409 //! @SYMTestCaseDesc Test getting the thread list

   410 //! @SYMTestActions Get the thread listing globally and for a specified thread or process

   411 //! @SYMTestExpectedResults The thread listings should all be successfully obtained and the current thread should be present in all listings

   412 //! @SYMTestPriority High

   413 //! @SYMTestStatus Implemented

   414 //---------------------------------------------

   415 void CRunModeAgent::TestGetThreadList()

   416 	{

   417 	test.Next(_L("TestGetThreadList\n"));

   418 

   419 	test(ListingSupported(EThreads, EScopeGlobal));

   420 	test(ListingSupported(EThreads, EScopeProcessSpecific));

   421 	test(ListingSupported(EThreads, EScopeThreadSpecific));

   422 

   423 	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

   424 	test(KErrNone == iServSession.SuspendThread(iThreadID));

   425 

   426 	TBool found = EFalse;

   427 	

   428 	/* We need these loops because on some system the kernel run mode debugger does not 

   429 	 immediately present the thread in the thread list. 

   430 	 */

   431 	

   432 	for(TInt retryCount = 0; retryCount < 10 && !found; retryCount++ )

   433 		{

   434 		//test getting this process's thread list, ETrue as should find the target debug thread

   435 		User::After(50000);

   436 		found = DoTestGetThreadList(ETrue, EScopeProcessSpecific, RProcess().Id().Id());

   437 		}

   438 	test( found );

   439 	found = EFalse;

   440 

   441 	for(TInt retryCount = 0; retryCount < 10 && !found; retryCount++ )

   442 		{

   443 		//test getting the global list, ETrue as should find the target debug thread

   444 		User::After(50000);

   445 		found = DoTestGetThreadList(ETrue, EScopeGlobal);

   446 		}

   447 	test( found );

   448 

   449 	found = EFalse;

   450 	for(TInt retryCount = 0; retryCount < 10 && !found; retryCount++ )

   451 		{

   452 		//test getting this thread's thread list, ETrue as should find the target debug thread

   453 		User::After(50000);

   454 		found = DoTestGetThreadList(ETrue, EScopeThreadSpecific, RThread().Id().Id());

   455 		}

   456 	test( found );

   457 

   458 	test(KErrNone == iServSession.ResumeThread(iThreadID));

   459 	test(KErrNone == iServSession.DetachExecutable(iFileName));

   460 	}

   461 			

   462 TBool CRunModeAgent::DoTestGetThreadList(const TBool aShouldPass, const TListScope aListScope, const TUint64 aTargetId)

   463 	{

   464 	//create data to pass

   465 	RBuf8 buffer;

   466 	TUint32 size = 0;

   467 

   468 	//perform the call to get the thread list

   469 	DoGetList(EThreads, aListScope, buffer, size, aTargetId);

   470 

   471 	//initialise data about the target debug thread to compare the kernel's data against

   472 	TFileName name = iDebugThread.FullName();

   473 	RProcess thisProcess;

   474 	TUint64 processId = thisProcess.Id();

   475 	TUint64 threadId = iDebugThread.Id();

   476 

   477 	//look through the buffer and check if the target debug thread is there

   478 	TBool found = EFalse;

   479 	TUint8* ptr = (TUint8*)buffer.Ptr();

   480 	const TUint8* ptrEnd = ptr + size;

   481 	while(ptr < ptrEnd)

   482 		{

   483 		TThreadListEntry* entry = (TThreadListEntry*)ptr;

   484 		TPtr entryName(&(entry->iName[0]), entry->iNameLength, entry->iNameLength);

   485 

   486 		if( (threadId == entry->iThreadId) && (processId == entry->iProcessId) && (0 == name.CompareF(entryName)) )

   487 			{

   488 			test(entry->iSupervisorStackBaseValid);

   489 			test(entry->iSupervisorStackSizeValid);

   490 			//if all match then we've found it

   491 			found = ETrue;

   492 			break;

   493 			}

   494 

   495 		ptr += Align4(entry->GetSize());

   496 		}

   497 

   498 	//clean up

   499 	buffer.Close();

   500 	return found;

   501 

   502 	}

   503 

   504 //---------------------------------------------

   505 //! @SYMTestCaseID KBase-T-RMDEBUG2-0431

   506 //! @SYMTestType

   507 //! @SYMPREQ PREQ1426

   508 //! @SYMTestCaseDesc Test getting the code segment list

   509 //! @SYMTestActions Get the code segment list global and for a specified thread

   510 //! @SYMTestExpectedResults The listings should be returned successfully

   511 //! @SYMTestPriority High

   512 //! @SYMTestStatus Implemented

   513 //---------------------------------------------

   514 void CRunModeAgent::TestGetCodeSegsList()

   515 	{

   516 	test.Next(_L("TestGetCodeSegsList\n"));

   517 

   518 	test(ListingSupported(ECodeSegs, EScopeGlobal));

   519 	test(ListingSupported(ECodeSegs, EScopeProcessSpecific));

   520 	test(ListingSupported(ECodeSegs, EScopeThreadSpecific));

   521 

   522 	// Cannot perform this test with OEM2 debug token, as the t_rmdebug2 app

   523 	// needs AllFiles, and the OEM2 debug token does not authorise this.

   524 	// It seems reasonable to suppose that it would work anyway

   525 

   526 #ifndef FEWCAPS_DEBUGTOKEN

   527 	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

   528 

   529  	//test getting the global list, ETrue as should find this process' main codeSeg

   530 	DoTestGetCodeSegsList(ETrue, EScopeGlobal);

   531 

   532 	//test getting this process' codeSegs, ETrue as should find this process' main codeSeg

   533 	DoTestGetCodeSegsList(ETrue, EScopeProcessSpecific, RProcess().Id().Id());

   534 

   535 	//test getting this thread's codeSegs, ETrue as should find this process' main codeSeg

   536 	DoTestGetCodeSegsList(ETrue, EScopeThreadSpecific, RThread().Id().Id());

   537 

   538 	test(KErrNone == iServSession.DetachExecutable(iFileName));

   539 #endif // FEWCAPS_DEBUGTOKEN

   540 

   541 	}

   542 

   543 void CRunModeAgent::DoTestGetCodeSegsList(const TBool aShouldPass, const TListScope aListScope, const TUint64 aTargetId)

   544 	{

   545 	//create data to pass

   546 	RBuf8 buffer;

   547 	TUint32 size = 0;

   548 

   549 	//perform the call to get the Code segs

   550 	DoGetList(ECodeSegs, aListScope, buffer, size, aTargetId);

   551 

   552 	//create memoryInfo to contain info about this process

   553 	RProcess thisProcess;

   554 	TModuleMemoryInfo memoryInfo;

   555 	test(KErrNone == thisProcess.GetMemoryInfo(memoryInfo));

   556 

   557 	// check whether this process came from a file in ROM so we know whether to

   558 	// expect the code seg to be XIP or not.

   559 	RFs fs;

   560 	test(KErrNone == fs.Connect());

   561 	TBool thisFileIsInRom = EFalse;

   562 	if(fs.IsFileInRom(iFileName))

   563 		{

   564 		thisFileIsInRom = ETrue;

   565 		}

   566 

   567 	//look through the buffer to find this process' main code seg

   568 	TBool found = EFalse;

   569 	TUint8* ptr = (TUint8*)buffer.Ptr();

   570 	const TUint8* ptrEnd = ptr + size;

   571 	while(ptr < ptrEnd)

   572 		{

   573 		TCodeSegListEntry* codeSeg = (TCodeSegListEntry*)ptr;

   574 

   575 		if( (codeSeg->iIsXip == thisFileIsInRom) && (0 == iFileName.CompareF(TPtr(&(codeSeg->iName[0]), codeSeg->iNameLength, codeSeg->iNameLength))) )

   576 			{

   577 			if( (memoryInfo.iCodeBase == codeSeg->iCodeBase) &&

   578 					(memoryInfo.iCodeSize == codeSeg->iCodeSize) &&

   579 					(memoryInfo.iConstDataSize == codeSeg->iConstDataSize) &&

   580 					(memoryInfo.iInitialisedDataBase == codeSeg->iInitialisedDataBase) &&

   581 					(memoryInfo.iInitialisedDataSize == codeSeg->iInitialisedDataSize) &&

   582 					(memoryInfo.iUninitialisedDataSize == codeSeg->iUninitialisedDataSize))

   583 				{

   584 				//all matched so means we've found the codeSeg we're looking for

   585 				found = ETrue;

   586 				}

   587 			}

   588 		ptr += Align4(codeSeg->GetSize());

   589 		}

   590 

   591 	//check whether the result was as expected

   592 	test(found == aShouldPass);

   593 

   594 	// only care about rm_debug.ldd if we have global scope (belongs to the system not this process)

   595 	if (aListScope == EScopeGlobal)

   596 	{

   597 		// Search for rm_debug.ldd library and check its UID3 is correct

   598 		found = EFalse;

   599 

   600 _LIT(KRMDebugDriverFileName,"Z:\\sys\bin\\rm_debug.ldd");

   601 

   602 		TFileName rmdebugFilename(KRMDebugDriverFileName);

   603 

   604 		// reset the Ptr

   605 		ptr = (TUint8*)buffer.Ptr();

   606 		ptrEnd = ptr+size;

   607 		while(ptr < ptrEnd)

   608 		{

   609 			TCodeSegListEntry* codeSeg = (TCodeSegListEntry*)ptr;

   610 

   611 			if( rmdebugFilename.CompareF(TPtr(&(codeSeg->iName[0]), codeSeg->iNameLength, codeSeg->iNameLength)))

   612 				{

   613 				if(codeSeg->iUid3 == 0x101f7157 /* Magic */)

   614 					{

   615 					//all matched so means we've found the codeSeg we're looking for

   616 					found = ETrue;

   617 					}

   618 				}

   619 			ptr += Align4(codeSeg->GetSize());

   620 		}

   621 		test((TUint32)found == (TUint32)ETrue);

   622 	}

   623 

   624 	//clean up

   625 	buffer.Close();

   626 

   627 	}

   628 

   629 

   630 /**

   631  * Get a list from the run mode debug system. Most list calls will initially return KErrTooBig, 

   632  * since the initial size of the buffer is 0. However it is sometimes valid for a list to be empty

   633  * given its filtering and scope. These calls should return KErrNone.

   634  */

   635 void CRunModeAgent::DoGetList(const TListId aListId, const TListScope aListScope, RBuf8& aBuffer, TUint32& aSize, const TUint64 aTargetId)

   636 	{

   637 	//close the buffer in case there's stuff allocated in it

   638 	aBuffer.Close();

   639 	//initialise it to be one byte big, which will guarantee data won't fit in it

   640 	test(KErrNone == aBuffer.Create(1));

   641 	aSize = 0;

   642 	

   643 	TInt ret = KErrNone;

   644 	//should pass this test (assuming we've passed in sensible arguments above...)

   645 	if(EScopeGlobal == aListScope)

   646 		{

   647 		ret = iServSession.GetList(aListId, aBuffer, aSize);

   648 		}

   649 	else if(EScopeThreadSpecific == aListScope)

   650 		{

   651 		ret = iServSession.GetList((TThreadId)aTargetId, aListId, aBuffer, aSize);

   652 		}

   653 	else if(EScopeProcessSpecific == aListScope)

   654 		{

   655 		ret = iServSession.GetList((TProcessId)aTargetId, aListId, aBuffer, aSize);

   656 		}

   657 	else

   658 		{

   659 		// unknown list scope

   660 		test(0);

   661 		}

   662 

   663 	if( KErrNone == ret )

   664 		{

   665 		/* In the case that there is no data, just return and let the caller check

   666 		the buffer. It is valid for a caller to not expect any data to be returned.

   667 		*/

   668 		return;

   669 		}

   670 	

   671 	// The only other allowed return is KErrTooBig

   672 	test( ret == KErrTooBig );

   673 

   674 	//keep allocating larger buffers, beginning with the aSize returned by the above call,

   675 	//and hopefully we'll eventually make a large enough one

   676 	test(KErrNone == aBuffer.ReAlloc(aSize));

   677 

   678 	for(;;)

   679 		{

   680 		TInt err = KErrNone;

   681 		if(EScopeGlobal == aListScope)

   682 			{

   683 			err = iServSession.GetList(aListId, aBuffer, aSize);

   684 			}

   685 		else if(EScopeThreadSpecific == aListScope)

   686 			{

   687 			err = iServSession.GetList((TThreadId)aTargetId, aListId, aBuffer, aSize);

   688 			}

   689 		else if(EScopeProcessSpecific == aListScope)

   690 			{

   691 			err = iServSession.GetList((TProcessId)aTargetId, aListId, aBuffer, aSize);

   692 			}

   693 		else

   694 			{

   695 			// unknown list scope

   696 			test(0);

   697 			}

   698 		if(err == KErrTooBig)

   699 			{

   700 			//wasn't big enough so double it

   701 			aSize = aSize << 1;

   702 			err = aBuffer.ReAlloc(aSize);

   703 			if(err != KErrNone)

   704 				{

   705 				//print out a message if couldn't allocate memory and quit

   706 				test.Printf(_L("Out ot memory when attempting to allocate %d bytes."), aSize);

   707 				test(KErrNone == err);

   708 				}

   709 

   710 			RDebug::Printf(" List size =%d", aSize );

   711 			}

   712 		else

   713 			{

   714 			test(KErrNone == err);

   715 			test(aBuffer.Length() == aSize);

   716 			//break out of the loop if the list has been successfully read in

   717 			break;

   718 			}

   719 		}

   720 	}

   721 

   722 //---------------------------------------------

   723 //! @SYMTestCaseID KBase-T-RMDEBUG2-0432

   724 //! @SYMTestType

   725 //! @SYMPREQ PREQ1426

   726 //! @SYMTestCaseDesc Test reading and writing memory

   727 //! @SYMTestActions Multiple calls to read and write memory, with various sizes and at various locations.

   728 //!	Also test that bad input values cause appropriate errors to be returned.

   729 //! @SYMTestExpectedResults All tests should pass and the target process should be left unaffected

   730 //! @SYMTestPriority High

   731 //! @SYMTestStatus Implemented

   732 //---------------------------------------------

   733 void CRunModeAgent::TestMemoryAccess()

   734 {

   735 	TInt err;

   736 

   737 	test.Next(_L("TestMemoryAccess - Read Memory\n"));

   738 

   739 	//initialise buffer

   740 	gMemoryAccessBytes.SetLength(0);

   741 	for (TInt i=0; i<SYMBIAN_RMDBG_MEMORYSIZE; i++)

   742 		{

   743 		gMemoryAccessBytes.Append(i);

   744 		}

   745 

   746 	TUint32 address = (TUint32)(&gMemoryAccessBytes[0]);

   747 	TUint32 dataSize = SYMBIAN_RMDBG_MEMORYSIZE;

   748 

   749 	//create size for buffer that is rounded up to nearest 4 bytes if not

   750 	//already 4 byte aligned

   751 	TUint32 size = dataSize;

   752 	if(size % 4 != 0)

   753 		{

   754 		size += (4 - (size % 4));

   755 		}

   756 

   757 	RBuf8 dataBlock;

   758 	err = dataBlock.Create(size);

   759 	test(err==KErrNone);

   760 	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

   761 

   762 	//suspend the thread prior to memory operations

   763 	test(KErrNone == iServSession.SuspendThread(iThreadID));

   764 

   765 	err = iServSession.ReadMemory(iThreadID, address, size, dataBlock, EAccess32, EEndLE8);

   766 	test(err==KErrNone);

   767 

   768 	for (TInt i=0; i<dataSize; i++)

   769 		{

   770 		test(dataBlock.Ptr()[i] == gMemoryAccessBytes[i]);

   771 		}

   772 

   773 	test.Next(_L("TestMemoryAccess - Write Memory\n"));

   774 

   775 	// Now reset the buffer

   776 	for (TInt i=0; i<dataSize; i++)

   777 		{

   778 		gMemoryAccessBytes[i] = 0;

   779 		}

   780 

   781 	// Write our data into the buffer

   782 	err = iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess32, EEndLE8);

   783 	test(err==KErrNone);

   784 

   785 	for (TInt i=0; i<dataSize; i++)

   786 		{

   787 		test(dataBlock.Ptr()[i] == gMemoryAccessBytes[i]);

   788 		}

   789 

   790 	//final test that everything's not been going wrong

   791 	test(gMemoryAccessBytes[5] != 0);

   792 

   793 	test.Next(_L("TestMemoryAccess - Invalid arguments\n"));

   794 	test.Printf(_L("This test may emit crash-like information. This is intended.\n"));

   795 

   796 	//test address that is not 32 bit aligned

   797 	err = iServSession.ReadMemory(iThreadID, address + 1, size, dataBlock, EAccess32, EEndLE8);

   798 	test(err == KErrArgument);

   799 

   800 	//test size that is not multiple of 4 bytes

   801 	err = iServSession.WriteMemory(iThreadID, address, size + 2, dataBlock, EAccess32, EEndLE8);

   802 	test(err == KErrArgument);

   803 

   804 	//test size > max block size

   805 	err = iServSession.ReadMemory(iThreadID, address, (1<<15), dataBlock, EAccess32, EEndLE8);

   806 	test(err == KErrArgument);

   807 

   808 	//test access size == 2 bytes

   809 	err = iServSession.ReadMemory(iThreadID, address, size, dataBlock, EAccess16, EEndLE8);

   810 	test(err == KErrNotSupported);

   811 

   812 	//test access size == 1 byte

   813 	err = iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess8, EEndLE8);

   814 	test(err == KErrNotSupported);

   815 

   816 	//test endianess == EEndBE8

   817 	err = iServSession.ReadMemory(iThreadID, address, size, dataBlock, EAccess32, EEndBE8);

   818 	test(err == KErrNotSupported);

   819 

   820 	//test endianess == EEndBE32

   821 	err = iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess32, EEndBE32);

   822 	test(err == KErrNotSupported);

   823 

   824 	//test reading off end of memory

   825 	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x00000101, dataBlock, EAccess32, EEndLE8);

   826 	test(err == KErrArgument);

   827 

   828 	//The following three tests check that edge conditions in the range check are handled correctly.

   829 	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x000000FF, dataBlock, EAccess32, EEndLE8);

   830 	test(err == KErrArgument);

   831 

   832 	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x000000F0, dataBlock, EAccess32, EEndLE8);

   833 	test(err == KErrBadDescriptor);

   834 

   835 	//Third range check test. Check that range check is handled correctly even when base + size wraps to 0.

   836 	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x00000100, dataBlock, EAccess32, EEndLE8);

   837 	test(err == KErrBadDescriptor);

   838 	//end of range check tests

   839 

   840 	//test size == 0

   841 	err = iServSession.WriteMemory(iThreadID, address, 0, dataBlock, EAccess32, EEndLE8);

   842 	test(err == KErrArgument);

   843 

   844 	//attempt to write to address outside of process data segments,

   845 	//this address corresponds to the vectors so shouldn't be able to write

   846 	err = iServSession.WriteMemory(iThreadID, 0xffff0000, size, dataBlock, EAccess32, EEndLE8);

   847 	test(err == KErrBadDescriptor);

   848 

   849 	//attempt to read and write to address in process code segment

   850 

   851 	//open a handle to the thread

   852 	RThread debugThread;

   853 	test(debugThread.Open(iThreadID) == KErrNone);

   854 

   855 	//get a reference to the debug process

   856 	RProcess debugProcess;

   857 	test(debugThread.Process(debugProcess) == KErrNone);

   858 

   859 	//get the memory info for the process

   860 	TProcessMemoryInfo info;

   861 	test(debugProcess.GetMemoryInfo(info) == KErrNone);

   862 

   863 	address = info.iCodeBase;

   864 	if(size <= info.iCodeSize)

   865 		{

   866 		test(KErrNone == iServSession.ReadMemory(iThreadID, address, size, dataBlock, EAccess32, EEndLE8));

   867 		test(KErrBadDescriptor == iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess32, EEndLE8));

   868 		}

   869 

   870 	// Some performance tests now

   871 	TUint32 bytesRead = 0;

   872 

   873 	// Allocate a data buffer

   874 	TUint32* p = (TUint32*)User::Alloc(size);

   875 	test(p != 0);

   876 

   877 	TInt nanokernel_tick_period;

   878 	HAL::Get(HAL::ENanoTickPeriod, nanokernel_tick_period);

   879 	test (nanokernel_tick_period != 0);

   880 

   881 	static const TInt KOneMillion = 1000000;

   882 

   883 	TInt nkTicksPerSecond = KOneMillion/nanokernel_tick_period;

   884 

   885 	TUint32 stopTickCount = User::NTickCount() + nkTicksPerSecond;

   886 

   887 	while (User::NTickCount() < stopTickCount)

   888 		{

   889 		err = iServSession.ReadMemory(iThreadID, (TUint32)p, size, dataBlock, EAccess32, EEndLE8);

   890 		test(err==KErrNone);

   891 

   892 		// Increase the count of bytes read

   893 		bytesRead += size;

   894 		}

   895 

   896 	test(bytesRead != 0);

   897 	iMemoryReadKbytesPerSecond = bytesRead/1024;

   898 

   899 	// write memory test

   900 	TUint32 bytesWritten = 0;

   901 

   902 	stopTickCount = User::NTickCount() + nkTicksPerSecond;

   903 

   904 	while (User::NTickCount() < stopTickCount)

   905 		{

   906 		err = iServSession.WriteMemory(iThreadID, (TUint32)p, size, dataBlock, EAccess32, EEndLE8);

   907 		test(err==KErrNone);

   908 

   909 		// Increase the count of bytes read

   910 		bytesWritten += size;

   911 		}

   912 

   913 	test (bytesWritten != 0);

   914 	iMemoryWriteKbytesPerSecond = bytesWritten/1024;

   915 

   916 	User::Free(p);

   917 

   918 	//resume the thread

   919 	test(KErrNone == iServSession.ResumeThread(iThreadID));

   920 

   921 	debugThread.Close();

   922 	dataBlock.Close();

   923 

   924 	test(KErrNone == iServSession.DetachExecutable(iFileName));

   925 	}

   926 

   927 //---------------------------------------------

   928 //! @SYMTestCaseID KBase-T-RMDEBUG2-0433

   929 //! @SYMTestType

   930 //! @SYMPREQ PREQ1426

   931 //! @SYMTestCaseDesc Test suspending and resuming threads

   932 //! @SYMTestActions Multiple calls to suspend and resume threads with and without attaching to the thread

   933 //! @SYMTestExpectedResults All tests should pass and the target process should be left unaffected

   934 //! @SYMTestPriority High

   935 //! @SYMTestStatus Implemented

   936 //---------------------------------------------

   937 void CRunModeAgent::TestSuspendResume()

   938 	{

   939 	TInt err;

   940 

   941 	test.Next(_L("TestSuspendResume - Suspend\n"));

   942 

   943 	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

   944 

   945 	err = iServSession.SuspendThread(iThreadID);

   946 	test(err==KErrNone);

   947 	err = TestRunCountSame( iRunCountSubscribe, iTimer );

   948 	test( KErrNone == err );

   949 	

   950 	// Resume the thread

   951 	test.Next(_L("TestSuspendResume - Resume\n"));

   952 	err = iServSession.ResumeThread(iThreadID);

   953 	test(err==KErrNone);

   954 

   955 	test(KErrNone == iServSession.DetachExecutable(iFileName));

   956 

   957 	err = WaitForRunCountChange( iRunCountSubscribe, iTimer );

   958 	test(KErrNone == err );

   959 	

   960 	// check that agent can resume thread which it previously detached from

   961 	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

   962 	test(KErrNone == iServSession.SuspendThread(iThreadID));

   963 	test(KErrNone == iServSession.DetachExecutable(iFileName));

   964 

   965 	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

   966 	err = TestRunCountSame( iRunCountSubscribe, iTimer );

   967 	test( KErrNone == err );

   968 	test(KErrNone == iServSession.ResumeThread(iThreadID));

   969 	test(KErrNone == iServSession.DetachExecutable(iFileName));

   970 

   971 	err = WaitForRunCountChange( iRunCountSubscribe, iTimer );

   972 	test( KErrNone == err );

   973 	

   974 	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

   975 	test(KErrNone == iServSession.SuspendThread(iThreadID));

   976 	err = TestRunCountSame( iRunCountSubscribe, iTimer );

   977 	test( KErrNone == err );

   978 	test(KErrNone == iServSession.DetachExecutable(iFileName));

   979 	err = TestRunCountSame( iRunCountSubscribe, iTimer );

   980 	test( KErrNone == err );

   981 	    

   982 	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

   983 	err = TestRunCountSame( iRunCountSubscribe, iTimer );

   984 	test( KErrNone == err );

   985 	test(KErrNone == iServSession.ResumeThread(iThreadID));

   986 	test(KErrNone == iServSession.DetachExecutable(iFileName));

   987 	

   988 	err = WaitForRunCountChange( iRunCountSubscribe, iTimer );

   989     test( KErrNone == err );

   990 	}

   991 

   992 //---------------------------------------------

   993 //! @SYMTestCaseID KBase-T-RMDEBUG2-0434

   994 //! @SYMTestType

   995 //! @SYMPREQ PREQ1426

   996 //! @SYMTestCaseDesc Test getting the debug functionality from the driver

   997 //! @SYMTestActions Get the size and contents of the debug functionality block

   998 //! @SYMTestExpectedResults All tests should pass and the expected data should appear in the functionality block

   999 //! @SYMTestPriority High

  1000 //! @SYMTestStatus Implemented

  1001 //---------------------------------------------

  1002 void CRunModeAgent::TestDebugFunctionality()

  1003 	{

  1004 

  1005 	TInt err;

  1006 

  1007 	test.Next(_L("TestDebugFunctionality - GetDebugFunctionalityBufSize\n"));

  1008 

  1009 	TUint32 bufsize = 0;	// Safe default size

  1010 

  1011 	// Get functionality block size

  1012 	err = iServSession.GetDebugFunctionalityBufSize(&bufsize);

  1013 	test(err==KErrNone);

  1014 	test.Next(_L("TestDebugFunctionality - GetDebugFunctionality\n"));

  1015 

  1016 	// Ensure we have a finite buffer size

  1017 	test(bufsize!=0);

  1018 

  1019 	// Allocate space for the functionality data

  1020 	HBufC8* dftext = HBufC8::NewLC(bufsize);

  1021 

  1022 	// create an empty TPtr8 refering to dftext

  1023 	TPtr8 dftextPtr(dftext->Des());

  1024 

  1025 	// Get the functionality block

  1026 	err = iServSession.GetDebugFunctionality(dftextPtr);

  1027 	test(err==KErrNone);

  1028 

  1029 	// Check that the first entry is correct

  1030 	TTagHeader RefHdr =

  1031 	{

  1032 		ETagHeaderIdCore,ECoreLast,

  1033 	};

  1034 

  1035 	// First header passed from rm_debug.ldd

  1036 	TTagHeader* TestHdr = (TTagHeader*)dftextPtr.Ptr();

  1037 

  1038 	// Check

  1039 	test(RefHdr.iTagHdrId==TestHdr->iTagHdrId);

  1040 	// this test might fail if the agent is used with a Debug Security Server different from

  1041 	// the one it was compiled against. So removing it for now.

  1042 	//test(RefHdr.iNumTags==TestHdr->iNumTags);

  1043 

  1044 	// read a value from the data to check it has come through as expected

  1045 	TTagHeader* header = GetTagHdr(dftext->Des(), ETagHeaderIdApiConstants);

  1046 	test(header != NULL);

  1047 	TTag* tag = GetTag(header, EApiConstantsTEventInfoSize);

  1048 	test(tag != NULL);

  1049 	// this test might fail if the agent is used with a Debug Security Server different from

  1050 	// the one it was compiled against. So removing it for now.

  1051 	//test(sizeof(TEventInfo) == tag->iValue);

  1052 

  1053 	// Remove our temporary buffer

  1054 	CleanupStack::PopAndDestroy(dftext);

  1055 	}

  1056 

  1057 //---------------------------------------------

  1058 //! @SYMTestCaseID KBase-T-RMDEBUG2-0435

  1059 //! @SYMTestType

  1060 //! @SYMPREQ PREQ1426

  1061 //! @SYMTestCaseDesc Test setting and clearing consecutive breakpoints

  1062 //! @SYMTestActions Set and clear consecutive breakpoints of all combinations of breakpoint types

  1063 //! @SYMTestExpectedResults All breakpoints should be set and cleared without error

  1064 //! @SYMTestPriority High

  1065 //! @SYMTestStatus Implemented

  1066 //---------------------------------------------

  1067 void CRunModeAgent::TestConsecutiveBreakPoints()

  1068 	{

  1069 	test.Next(_L("TestConsecutiveBreakPoints\n"));

  1070 

  1071 	test(KErrNone == iServSession.SuspendThread(iThreadID));

  1072 

  1073 	// just a temporary structure for storing info about a breakpoint

  1074 	struct TBreakPoint

  1075 		{

  1076 	public:

  1077 		TBreakPoint()

  1078 			:iId(0),

  1079 			iMode((TArchitectureMode)0),

  1080 			iAddress(0)

  1081 			{}

  1082 		TBreakId iId;

  1083 		TArchitectureMode iMode;

  1084 		TUint32 iAddress;

  1085 		inline TInt Size() { return (EArmMode == iMode) ? 4 : 2; }

  1086 		};

  1087 

  1088 	//an address in the target debug thread

  1089 	TUint32 address = (TUint32)(&TestFunction);

  1090 

  1091 	// there are six orders in which three breakpoints can be set, these are looped

  1092 	// through below to check setting and clearing consecutive breakpoints works

  1093 	TUint8 order[6][3] =

  1094 		{

  1095 			{0,1,2},

  1096 			{0,2,1},

  1097 			{1,0,2},

  1098 			{1,2,0},

  1099 			{2,0,1},

  1100 			{2,1,0}

  1101 		};

  1102 

  1103 	// The following code checks that setting and clearing consecutive breakpoints works correctly:

  1104 	// It checks that setting all combinations of three arm and thumb breakpoints succeeds, and check that the

  1105 	// breakpoints can be set in any order, and then cleared in any order

  1106 

  1107 	// the 3 least significant bits of i control whether each of the three breakpoints should be arm or thumb

  1108 	for(TInt i=0; i<8; i++)

  1109 		{

  1110 		// controls the order in which the breakpoints should be set

  1111 		for(TInt j=0; j<6; j++)

  1112 			{

  1113 			// create the three breakpoints and set their modes

  1114 			TBreakPoint bp[3];

  1115 			bp[0].iMode = (i&1) ? EArmMode : EThumbMode;

  1116 			bp[1].iMode = (i&2) ? EArmMode : EThumbMode;

  1117 			bp[2].iMode = (i&4) ? EArmMode : EThumbMode;

  1118 

  1119 			// set the address of each of the breakpoints

  1120 			bp[0].iAddress = address;

  1121 			if(EArmMode == bp[0].iMode)

  1122 				{ // if an arm breakpoint then must be on a four byte boundary

  1123 				bp[0].iAddress = Align4(bp[0].iAddress);

  1124 				}

  1125 			bp[1].iAddress = bp[0].iAddress + bp[0].Size();

  1126 			if(EArmMode == bp[1].iMode)

  1127 				{ // if an arm breakpoint then must be on a four byte boundary

  1128 				bp[1].iAddress = Align4(bp[1].iAddress);

  1129 				}

  1130 			bp[2].iAddress = bp[1].iAddress + bp[1].Size();

  1131 			if(EArmMode == bp[2].iMode)

  1132 				{ // if an arm breakpoint then must be on a four byte boundary

  1133 				bp[2].iAddress = Align4(bp[2].iAddress);

  1134 				}