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

 // e32utils\d_exc\d_exc.cpp

 // Trap and log user-side exceptions and panics.

 // USAGE:

 // d_exc

 // Trap panics and exceptions forever.  Prompt whether to log.

 // Logs go on C: drive.

 // d_exc [-m] [-nN] [-pN] [-b] [-d log_path]

 // -m	minimal logging (no stack dump)

 // -nN	stop after N exceptions/panics

 // -pN	log to serial port N instead of C: drive

 // -b	do not prompt; always log

 // -d  specify the path for log files.  If not given, logs are

 // written to the root of the system drive.  If just a path

 // name is given, logs are written to that directory (must

 // start with a \) on the system drive.

 // 

 //

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32svr.h>

 #include <d32comm.h>

 #include <f32file.h>

 #include "minkda.h"

 RNotifier Notifier;				// The "UI"

 RMinKda Trapper;

 RFs FileSession;

 TBuf16<KMaxFileName> LogPath; // to specify log file location

 // Possible outputs where crash information can be dumped

 enum TOutputType{ EFile, ESerial };

 // Variables shared between DumpLine() and the various functions used

 // to format crash info.

 TOutputType ActiveOutput = EFile;	

 TBool IoError;						// ETrue after I/O error

 RBusDevComm CommPort;				// Handle to serial port used

 RFile File;							// Handle to text file used

 // Maximum length in characters of a line in the file containing

 // textual information about the crash.

 const TInt KMaxLineLength = KMaxFullName + 32;

 class TLexNew : public TLex16

 	{

 public:

 	inline TLexNew(const TDesC16& aDes) {Assign(aDes);}

 	TInt ExtractParameter(TDes16 &aParam);

 	};

 TInt TLexNew::ExtractParameter(TDes16 &aParam)

 	{

 	TBuf16<512> token;

 	TBuf16<512> param;

 	TBool GetNext = EFalse;

 	//exit..if it's empty (empty option at the end of command)

 	if (!Peek())

 		return KErrArgument;

 	// remove any space between option and the rest of param..

 	SkipSpace();

 	// just see, what's next.. 

 	// if there this a param with spaces- should be in "quotes"

 	if (Peek() == '"')

 		{

 		GetNext = ETrue;

 		Inc(); // skip this quote " and move to next position..   

 		}

 	// remove spaces after quotes ("  param...")

 	SkipSpace();

 	// ..mark next character position as a start of our token 

 	Mark();

 	// move until the end of our token (next space).. 

 	SkipCharacters();

 	//and get it!!

 	token.Copy(MarkedToken());

 	// if.. there was one-word param.. with quotes..shrink it..and don't try to search next one..

 	if (*(token.MidTPtr(token.Length()-1).Ptr()) == '"')

 		{

 		// just shrink it by that ending quote..

 		token.SetLength(token.Length()-1);

 		GetNext=EFalse;

 		}

 	// This is at least beginning of our param.. let's use it!

 	// add this to beginning of our param..

 	param.Append(token);

 	// if this was param specified in quotes..search for the ending quote..

 	while (GetNext)

 		{

 		// Next is space.. 

 		SkipSpace();

 		// before taking next one..check it - if '-' on the beginning..

 		// it's either next param specifier..(no ending quote at all) 

 		if (Peek() == '-')

 			return KErrArgument;

 		// get the next one..

 		token.Copy(NextToken());

 		// was there any token more? ..if not- we're at the end..

 		// so the ending quote still wasn't found...

 		if (!token.Length())

 			return KErrArgument;

 		// is this the last one - with quote" at the end?

 		if (*(token.MidTPtr(token.Length()-1).Ptr()) == '"')

 			{

 			// just shrink it by that ending quote..

 			token.SetLength(token.Length()-1);

 			GetNext=EFalse;

 			}

 		param.Append(_L(" ")); // there was space in orig. param..restore it..

 		param.Append(token); // and append this token to our param..

 		}

 	// if there was any space at the end..(e.g. if specified: -d"c:\logs  ")

 	// - remove it

 	param.TrimRight();

 	//finally - copy param to the referenced descriptor

 	aParam.Copy(param);

 	return KErrNone;

 	}

 TInt ValidatePath(TDes16 &aLogPath)

 	{

 	// check the length first.. (20 chars for file name..)

 	if (aLogPath.Length() >(KMaxFileName - 20))

 		{

 		Notifier.InfoPrint(_L("directory name too long.."));

 		return KErrArgument;

 		}

 	// if it hasn't drive letter (colon wasn't second..)

 	if (*(aLogPath.MidTPtr(1).Ptr()) != ':')

 		{

 		// if it starts with "\" use system drive.. 

 		if (*(aLogPath.MidTPtr(0).Ptr()) == '\\')

 			{

 			// if someone specified param like: "\ path\" ...obviously..

 			if (*(aLogPath.MidTPtr(1).Ptr()) == ' ')

 				return KErrArgument;

 			TBuf16<2> drive;

 			drive.Append(RFs::GetSystemDriveChar());

 			drive.LowerCase();

 			drive.Append(_L(":"));

 			aLogPath.Insert(0, drive);

 			}

 		else //otherwise -path not valid.. 

 			{

 			return KErrArgument;

 			}

 		}

 	// and add backslash if needed

 	if (*(aLogPath.MidTPtr(aLogPath.Length()-1).Ptr()) != '\\')

 		aLogPath.Append(_L("\\"));

 	//open file session..

 	if (FileSession.Connect() != KErrNone)

 		return KErrGeneral;

 	RDir dir;

 	TInt err=KErrNone;

 	if (dir.Open(FileSession, aLogPath, KEntryAttMatchExclusive) != KErrNone)

 		{

 		Notifier.InfoPrint(_L("specified directory doesn't exist"));

 		LogPath.Zero(); //clear global path..

 		err = KErrArgument;

 		}

 	else

 		{

 		dir.Close();

 		}

 	// close file session..

 	FileSession.Close();

 	return err;

 	}

 // Open specified serial port and push handle on the cleanup stack.

 void OpenCommPortLC(TInt aPortNum)

 	{

 #ifdef __WINS__	

 	_LIT(KPdd, "ECDRV");

 #else

 	_LIT(KPdd, "EUART");

 #endif

 	_LIT(KLdd, "ECOMM");

 	_LIT(KErrPdd, "Failed to load serial PDD");

 	_LIT(KErrLdd, "Failed to load serial LDD");

 	_LIT(KErrOpen, "Failed to open comm port");

 	_LIT(KErrCfg, "Failed to configure comm port");

 	TInt r = User::LoadPhysicalDevice(KPdd);

 	if (r != KErrNone && r != KErrAlreadyExists)

 		{

 		Notifier.InfoPrint(KErrPdd);

 		User::Leave(r);

 		}

 	r = User::LoadLogicalDevice(KLdd);

 	if (r != KErrNone && r != KErrAlreadyExists)

 		{

 		Notifier.InfoPrint(KErrLdd);

 		User::Leave(r);

 		}

 	r = CommPort.Open(aPortNum);

 	if (r != KErrNone)

 		{

 		Notifier.InfoPrint(KErrOpen);

 		User::Leave(r);

 		}

 	CleanupClosePushL(CommPort);

 	TCommConfig cfgBuf;

 	TCommConfigV01& cfg=cfgBuf();

 	CommPort.Config(cfgBuf);

 	cfg.iRate=EBps115200;

 	cfg.iDataBits=EData8;

 	cfg.iStopBits=EStop1;

 	cfg.iParity=EParityNone;

 	cfg.iHandshake=KConfigObeyXoff|KConfigSendXoff;

 	cfg.iFifo=EFifoEnable;

 	cfg.iTerminatorCount=0;

 	cfg.iSIREnable=ESIRDisable;

 	r = CommPort.SetConfig(cfgBuf);

 	if (r != KErrNone)

 		{

 		Notifier.InfoPrint(KErrCfg);

 		User::Leave(r);

 		}

 	}

 void ParseCmdLineL(TInt& aPortNum, TInt& aMaxTrapCount, TBool& aInteractive, TBool& aDumpStack)

 	{

 	_LIT(KInvalidArg, "Invalid command-line");

 	HBufC* cl = HBufC::NewLC(User::CommandLineLength());

 	TPtr clp = cl->Des();

 	User::CommandLine(clp);

 	// If started from UIKON shell, ignore command-line and use defaults

 	if (clp.Match(_L("?:\\*")) == 0)

 		return;

 	TLexNew lex(*cl);

 	while (! lex.Eos())

 		{

 		TInt r = KErrArgument;

 		if (lex.Get() == '-')

 			{

 			switch (lex.Get())

 				{

 			case 'n':

 				r = lex.Val(aMaxTrapCount);

 				break;

 			case 'p':

 				r = lex.Val(aPortNum);

 				if (r == KErrNone)

 					ActiveOutput = ESerial;

 				break;

 			case 'b':

 				aInteractive = EFalse;

 				r = KErrNone;

 				break;

 			case 'm':

 				aDumpStack = EFalse;

 				r = KErrNone;

 				break;

 			case 'd':

 				//try to extract path and store it in global buffer

 				r = lex.ExtractParameter(LogPath);

 				// check, if specified path is valid

 				if (r == KErrNone)  

 					r = ValidatePath(LogPath);  

 				break;

 				}

 			}

 		if (r != KErrNone)

 			{

 			Notifier.InfoPrint(KInvalidArg);

 			User::Leave(KErrArgument);

 			}

 		lex.SkipSpace();

 		}

 	CleanupStack::PopAndDestroy(cl);

 	}

 // Dump specified line + CRLF on the selected output.  Set IoError to

 // ETrue if an error occurs.

 void DumpLine(TDes8& aLine)

 	{

 	TInt r;

 	_LIT8(KCrLf, "\r\n");

 	aLine.Append(KCrLf);

 	if (ActiveOutput == ESerial)

 		{

 		TRequestStatus s;

 		CommPort.Write(s, aLine);

 		User::WaitForRequest(s);

 		r = s.Int();

 		}

 	else

 		r = File.Write(aLine);

 	if (r != KErrNone)

 		IoError = ETrue;

 	}

 void DumpExcInfo(const TDbgCpuExcInfo& aInfo, TDes8& aLine)

 	{

 	_LIT8(KHdr, "\r\nUNHANDLED EXCEPTION:");

 	aLine = KHdr;

 	DumpLine(aLine);

 #ifdef __MARM__

 	_LIT8(KFmt1, "code=%d PC=%08x FAR=%08x FSR=%08x");

 	aLine.Format(KFmt1, aInfo.iExcCode, aInfo.iFaultPc, aInfo.iFaultAddress, aInfo.iFaultStatus);

 	DumpLine(aLine);

 	_LIT8(KFmt2, "R13svc=%08x R14svc=%08x SPSRsvc=%08x");

 	aLine.Format(KFmt2, aInfo.iR13Svc, aInfo.iR14Svc, aInfo.iSpsrSvc); 

 	DumpLine(aLine);

 #else

 	(void) aInfo; // silence warning

 #endif

 	}

 void DumpRegisters(const TDbgRegSet& aRegs, TDes8& aLine)

 	{

 #if defined(__MARM__)

 	_LIT8(KHdr, "\r\nUSER REGISTERS:");

 	aLine = KHdr;

 	DumpLine(aLine);

 	_LIT8(KFmtCpsr, "CPSR=%08x");

 	aLine.Format(KFmtCpsr, aRegs.iCpsr);

 	DumpLine(aLine);

 	for (TInt i=0; i<TDbgRegSet::KRegCount; i+=4)

 		{

 		_LIT8(KFmtReg, "r%02d=%08x %08x %08x %08x");

 		aLine.Format(KFmtReg, i, aRegs.iRn[i], aRegs.iRn[i+1], aRegs.iRn[i+2], aRegs.iRn[i+3]);

 		DumpLine(aLine);

 		}

 #else

 	(void) aRegs; // silence warnings

 	(void) aLine; 

 #endif

 	}

 void DumpCodeSegs(TUint aPid, TDes8& aLine)

 	{

 	_LIT(KPanicCodeMods, "DEXC-CODEMOD");

 	_LIT8(KHdr, "\r\nCODE SEGMENTS:");

 	_LIT8(KFmtOverflow, "Only first %d code modules displayed");

 	_LIT8(KFmtMod, "%08X-%08X %S");

 	aLine = KHdr;

 	DumpLine(aLine);

 	// :FIXME: improve API

 	// :FIXME: suspend/resume all threads in process

 	const TInt KMaxCount = 128;

 	TAny* handles[KMaxCount];

 	TInt c = KMaxCount;

 	TInt r = Trapper.GetCodeSegs(aPid, handles, c);

 	__ASSERT_ALWAYS(r == KErrNone, User::Panic(KPanicCodeMods, r));

 	if (c > KMaxCount)

 		{

 		aLine.Format(KFmtOverflow, c);

 		DumpLine(aLine);

 		c = KMaxCount;

 		}

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

 		{

 		TDbgCodeSegInfo info;

 		r = Trapper.GetCodeSegInfo(handles[i], aPid, info);

 		if (r == KErrNone)

 			{

 			TBuf8<KMaxFileName> path;

 			path.Copy(info.iPath);

 			aLine.Format(KFmtMod, info.iCodeBase, info.iCodeBase+info.iCodeSize, &path);

 			DumpLine(aLine);

 			}

 		}

 	}

 void DumpTextInfo(const TDbgCrashInfo& aCrashInfo, const TDbgThreadInfo& aThreadInfo)

 	{

 	_LIT(KFmtTextFile, "d_exc_%d.txt");

 	_LIT(KErrTextOpen, "text file open error");

 	_LIT(KErrTextWrite, "text file write error");

 	if (ActiveOutput == EFile)

 		{

 		TBuf16<KMaxFileName> name;

 		name.Format(KFmtTextFile, aCrashInfo.iTid);

 		// if -d param wasn't specified, use default location..(root dir on system drive)

 		if(!LogPath.Length())

 			{

 			LogPath.Append(RFs::GetSystemDriveChar());

 			LogPath.LowerCase();

 			LogPath.Append(_L(":\\"));

 			}

 		TBuf16<KMaxFileName> filename;

 		filename.Copy(LogPath); 

 		filename.Append(name);

 		TInt r = File.Replace(FileSession, filename, EFileWrite+EFileShareAny+EFileStream);

 		if (r != KErrNone)

 			{

 			Notifier.InfoPrint(KErrTextOpen);

 			return;

 			}

 		}

 	IoError = EFalse;

 	// Note that following buffer is passed to callee functions and

 	// reuse to minimise stack footprint.

 	TBuf8<KMaxLineLength> line;

 	line.Fill('-', 76);

 	DumpLine(line);

 	_LIT8(KHdr, "EKA2 USER CRASH LOG");

 	line = KHdr;

 	DumpLine(line);

 	line.Copy(aThreadInfo.iFullName);

 	_LIT8(KName, "Thread Name: ");

 	line.Insert(0, KName);

 	DumpLine(line);

 	_LIT8(KFmtTid, "Thread ID: %u");

 	line.Format(KFmtTid, aCrashInfo.iTid);

 	DumpLine(line);

 	_LIT8(KFmtStack, "User Stack %08X-%08X");

 	line.Format(KFmtStack, aThreadInfo.iStackBase,

 				aThreadInfo.iStackBase+aThreadInfo.iStackSize);

 	DumpLine(line);

 	if (aCrashInfo.iType == TDbgCrashInfo::EPanic)

 		{

 		TBuf8<KMaxExitCategoryName> cat;

 		cat.Copy(aThreadInfo.iExitCategory);

 		_LIT8(KFmtPanic, "Panic: %S-%d");

 		line.Format(KFmtPanic, &cat, aThreadInfo.iExitReason);

 		DumpLine(line);

 		}

 	else

 		DumpExcInfo(aCrashInfo.iCpu, line);

 	DumpRegisters(aThreadInfo.iCpu, line);

 	DumpCodeSegs(aThreadInfo.iPid, line);

 	line.Zero();

 	DumpLine(line);

 	if (IoError)

 		Notifier.InfoPrint(KErrTextWrite);

 	if (ActiveOutput == EFile)

 		File.Close();

 	}

 // Output stack on selected output.  If serial port, use

 // human-readable format.  If file, use binary format.

 void DumpStack(TUint aTid, const TDbgThreadInfo& aInfo)

 	{

 	_LIT(KFmtStackFile, "d_exc_%d.stk");

 	_LIT(KErrStackOpen, "stack file open error");

 	_LIT(KErrStackWrite, "stack file write error");

 	_LIT(KPanicReadStack, "DEXC-READSTACK");

 	TInt r;

 	IoError = EFalse;

 	RFile file;

 	if (ActiveOutput == EFile)

 		{

 		TBuf16<KMaxFileName> name;

 		name.Format(KFmtStackFile, aTid);

 		// if -d param wasn't specified, use default location..(root dir on system drive)

 		if(!LogPath.Length())

 			{

 			LogPath.Append(RFs::GetSystemDriveChar());

 			LogPath.LowerCase();

 			LogPath.Append(_L(":\\"));

 			}

 		TBuf16<KMaxFileName> filename;

 		filename.Copy(LogPath); 

 		filename.Append(name);

 		r = file.Replace(FileSession, filename, EFileWrite+EFileShareAny+EFileStream);

 		if (r != KErrNone)

 			{

 			Notifier.InfoPrint(KErrStackOpen);

 			return;

 			}

 		}

 	const TInt KBufSize = 256;

 	TBuf8<KBufSize> buf;

 	TLinAddr top = aInfo.iStackBase + aInfo.iStackSize;

 	for (TLinAddr base = aInfo.iStackBase; base < top; base += KBufSize)

 		{

 		// Read chunk of stack.  Should always succeeds as thread has

 		// been suspended by LDD.

 		r = Trapper.ReadMem(aTid, base, buf);

 		__ASSERT_ALWAYS(r == KErrNone, User::Panic(KPanicReadStack, r));

 		if (ActiveOutput == ESerial)

 			{

 			TBuf8<80> out;

 			TBuf8<20> ascii;

 			TUint a = base;

 			TInt len = buf.Length();

 			TInt offset = 0;

 			while(len>0)

 				{

 				out.Zero();

 				ascii.Zero();

 				out.AppendNumFixedWidth(a,EHex,8);

 				out.Append(_L8(": "));

 				TUint b;

 				for (b=0; b<16; b++)

 					{

 					TUint8 c=*(buf.Ptr()+offset+b);

 					out.AppendNumFixedWidth(c,EHex,2);

 					out.Append(' ');

 					if (c<0x20 || c>=0x7f)

 						c=0x2e;

 					ascii.Append(TChar(c));

 					}

 				out.Append(ascii);

 				DumpLine(out);

 				a+=16;

 				offset += 16;

 				len-=16;

 				} 

 			}

 		else

 			{

 			if (file.Write(buf) != KErrNone)

 				IoError = ETrue;

 			}

 		}

 	if (IoError)

 		Notifier.InfoPrint(KErrStackWrite);

 	if (ActiveOutput == EFile)

 		file.Close();

 	}

 // Display a dialog box containing basic facts about the crash and ask

 // the user whether to dump detailed information or skip this crash.

 enum TDebugChoice { EDoDebug, EDoNotDebug }; 

 TDebugChoice CrashDialog(TDbgCrashInfo::TType aCrashType, const TDbgThreadInfo& aInfo)

 	{

 	_LIT(KExc, "Exception");

 	_LIT(KPanic, "Panic %S:%d");

 	_LIT(KBut1, "Do Not Debug");

 	_LIT(KBut2, "Debug");

 	TBuf<64> line1;

 	if (aCrashType == TDbgCrashInfo::EException)

 		line1 = KExc;

 	else

 		line1.Format(KPanic, &aInfo.iExitCategory, aInfo.iExitReason);

 	TInt r;

 	TRequestStatus s;

 	Notifier.Notify(line1, aInfo.iFullName, KBut1, KBut2, r, s);

 	User::WaitForRequest(s);

 	return r == 0 ? EDoNotDebug : EDoDebug;

 	}

 void MainL()

 	{

 	_LIT(KErrFs, "Failed to connect to file server");

 	_LIT(KErrLoadLdd, "Failed to load KDA LDD");

 	_LIT(KErrOpenLdd, "Failed to open KDA LDD");

 	_LIT(KLddPath, "MINKDA");

 	_LIT(KStarted, "D_EXC started");

 	_LIT(KCrash, "Crash detected");

 	_LIT(KPanicThreadInfo, "DEXC-THREADINFO");

 	TInt portNum;

 	TInt maxTrapCount = -1;

 	TBool isInteractive = ETrue;

 	TBool dumpStack = ETrue;

 	ParseCmdLineL(portNum, maxTrapCount, isInteractive, dumpStack);

 	// Open selected output and push resulting handle on cleanup

 	// stack.

 	TInt r;

 	if (ActiveOutput == EFile)

 		{

 		if ((r = FileSession.Connect()) != KErrNone)

 			{

 			Notifier.InfoPrint(KErrFs);

 			User::Leave(r);

 			}

 		CleanupClosePushL(FileSession);

 		}

 	else

 		OpenCommPortLC(portNum);

 	r = User::LoadLogicalDevice(KLddPath);

 	if (r != KErrNone && r != KErrAlreadyExists)

 		{

 		Notifier.InfoPrint(KErrLoadLdd);

 		User::Leave(r);

 		}

 // See comment near __KHEAP_MARKEND

 //	 __KHEAP_MARK;

 	r = Trapper.Open();

 	if (r != KErrNone)

 		{

 		Notifier.InfoPrint(KErrOpenLdd);

 		User::Leave(r);

 		}

 	CleanupClosePushL(Trapper);

 	Notifier.InfoPrint(KStarted);

 	// Main loop

 	TRequestStatus s;

 	TDbgCrashInfo crashInfo;

 	Trapper.Trap(s, crashInfo);

 	for (TInt crashCount = 0; maxTrapCount<0 || crashCount<maxTrapCount; ++crashCount)

 		{

 		User::WaitForRequest(s);

 		// Get more info about crashed thread.  Should always succeeds

 		// as the thread has been suspended by LDD.

 		TDbgThreadInfo threadInfo;

 		TInt r = Trapper.GetThreadInfo(crashInfo.iTid, threadInfo);

 		__ASSERT_ALWAYS(r == KErrNone, User::Panic(KPanicThreadInfo, r));

 		if (! isInteractive)

 			Notifier.InfoPrint(KCrash);

 		if (! isInteractive || CrashDialog(crashInfo.iType, threadInfo) == EDoDebug)

 			{

 			DumpTextInfo(crashInfo, threadInfo);

 			if (dumpStack)

 				DumpStack(crashInfo.iTid, threadInfo);

 			}

 		Trapper.Trap(s, crashInfo);

 		Trapper.KillCrashedThread();

 		}

 	Trapper.CancelTrap();

 	CleanupStack::PopAndDestroy(&Trapper);

 	CleanupStack::PopAndDestroy(); // FileSession or CommPort

 // Commented out because the InfoPrint thread may or may not have

 // terminated when we reach this point.  It if hasn't a spurious

 // memory leak will be reported.

 // #ifdef _DEBUG

 // 	User::After(3000000);

 // 	 __KHEAP_MARKEND;

 // #endif

 	User::FreeLogicalDevice(KKdaLddName);

 	}

 TInt E32Main()

 	{

 	_LIT(KPanicNtf, "DEXC-NO-NTF");

 	_LIT(KPanicLeave, "DEXC-LEAVE");

 	_LIT(KPanicOom, "DEXC-NO-CLEANUP");

 	// :FIXME: remove when platform security is always on

 	RProcess().DataCaging(RProcess::EDataCagingOn);

 #ifdef _DEBUG

 	TInt phcStart;

 	TInt thcStart;

 	RThread().HandleCount(phcStart, thcStart);

 #endif

 	TInt r = Notifier.Connect();

 	__ASSERT_ALWAYS(r == KErrNone, User::Panic(KPanicNtf, r));

 	__UHEAP_MARK;

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	__ASSERT_ALWAYS(cleanup, User::Panic(KPanicOom, KErrNoMemory));

 	TRAP(r, MainL());

  	__ASSERT_ALWAYS(r == KErrNone, User::Panic(KPanicLeave, r));

 	delete cleanup;

 	__UHEAP_MARKEND;

 	Notifier.Close();

 #ifdef _DEBUG

 	TInt phcEnd;

 	TInt thcEnd;

 	RThread().HandleCount(phcEnd, thcEnd);

 	__ASSERT_DEBUG(phcStart == phcEnd, User::Panic(_L("DEXC-PHC"), phcEnd-phcStart));

 	__ASSERT_DEBUG(thcStart == thcEnd, User::Panic(_L("DEXC-THC"), thcEnd-thcStart));

 #endif

 	return r;

 	}