// fdebuggerkernel.h
// 
// Copyright (c) 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//
#ifndef FDEBUGGERKERNEL_H
#define FDEBUGGERKERNEL_H

#include <nkern.h>
#include <kernel.h>
#include <kern_priv.h>

#include <fshell/common.mmh>
#include "memoryaccess.h"
class TDynDfcQueWrapper;

class MDebuggerEventClient
	{
public:
	virtual void BreakpointHit(TDes& aPkg) =0;
	};

NONSHARABLE_CLASS(DDebuggerEventHandler) : public DKernelEventHandler
	{
public:
	static DDebuggerEventHandler* New(TDfcQue* aQue);

	TInt GetZombieMode();
	TInt SetZombieMode(TInt aMode);
	HBuf* GetZombieThreadIds();
	TInt ReleaseZombie(DThread* aThread);
	TInt SuspendThread(DThread* aThread);

	TInt RegisterForBreakpointNotification(MDebuggerEventClient* aClient);
	void UnregisterForBreakpointNotification(MDebuggerEventClient* aClient);

	TInt SetBreakpoint(DThread* aThread, TLinAddr aAddress, const RMemoryAccess::TPredicate& aCondition);
	TInt SetSymbolicBreakpoint(DThread* aThread, HBuf* aCodesegName, TUint32 aOffset, const RMemoryAccess::TPredicate& aCondition);
	TInt RegisterPersistantBreakpoint(DThread* aThread, TLinAddr aAddress);
	TInt SetBreakpointEnabled(TInt aBreakpointId, TBool aEnabled);
	TInt ClearBreakpoint(TInt aBreakpointId);
	TInt ContinueFromBreakpoint(DThread* aThread, TLinAddr aExceptionAddress);
	HBuf* GetBreakpoints();

	TUint GetCreatorThread(TUint aThreadId); // Returns 0 if not known

private:
	DDebuggerEventHandler(TDfcQue* aQue);
	~DDebuggerEventHandler();
	static TUint Event(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aPrivateData);
	TUint DoEvent(TKernelEvent aEvent, TAny* a1, TAny* a2);
	void CompleteZombies();
	void Lock();
	void Unlock();
	void BreakpointLock();
	void BreakpointUnlock();
	struct SZombie;
	SZombie* FindZombie(DThread* aThread);
	void ReleaseZombie(SZombie* aZombie);
	void ReleaseZombieAndUnlock(SZombie* aZombie);
	void UnsuspendThread(SZombie* aZombie);
	TInt Zombify(TLinAddr aBreakpointAddr=0);
	struct SBreakpoint;
	SBreakpoint* FindBreakpointByAddress(/*DThread* aThread,*/ TLinAddr aAddress);
	SBreakpoint* FindBreakpointById(TInt aId);
	SBreakpoint* FindBreakpointUsingHardwareContextRegister(TInt aRegister);
	SBreakpoint* FindHardwareBreakpoint(DThread* aThread, TLinAddr aAddress);
	enum TBreakpointPolicy
		{
		EWhatever,
		EHardwareOnly,
		ESoftwareOnly,
		};
	TInt ApplyBreakpoint(SBreakpoint* aBreakpoint, TBreakpointPolicy aPolicy=EWhatever);
	void UnapplyBreakpoint(SBreakpoint* aBreakpoint);
	void ClearBreakpoint(SBreakpoint* aBreakpoint, TBool aResumeAllBlocked=EFalse);
	TInt SetProgramCounter(DThread* aThread, TLinAddr aAddress);
	void ClearAllBreakpoints();
	void RemoveAllHardwareBreakpointsForThread(DThread* aThread);
	void HandleRestoreCode(TLinAddr aAddress);
	static void HandleCodesegRemoved(TAny* aPtr);
	void DoHandleCodesegRemoved();
	TInt ReadInstructions(DThread* aThread, TLinAddr aAddress, TInt aLength, TDes8& aData);
	TInt ApplyHardwareBreakpoint(SBreakpoint* aBreakpoint);
	TInt DoApplyHardwareBreakpoint(SBreakpoint* aBreakpoint, TInt aContextReg);
	static TUint32 GetArmContextIdForThread(DThread* aThread);
	TInt MoveBreakpointToNextInstructionForThread(DThread* aThread, SBreakpoint* aBreakpoint);
#ifdef __EABI__
	void DoClearHardwareBreakpoint(SBreakpoint* aBreakpoint);
	void SetDscr(TUint32 aVal);
	void SetBreakpointPair(TInt aRegister, TUint aBvrValue, TUint aBcrValue);
	TUint ReadBcr(TInt aRegister);
	void SetContextIdBrp(TInt aRegister, TUint aContextId);

	// Ones from the-TLA-that-dare-not-speak-its-name
	TInt ReadKernelRegisterValue(DThread* aThread, TInt aRegister, TUint32& aResult);
	TInt DoReadMemory(DThread* aThread, TLinAddr aAddress, TInt aLength, TDes8& aResult);
	TBool IsPreviousInstructionMovePCToLR(DThread *aThread);
	TInt CurrentInstructionArm(DThread* aThread, TUint32& aInstruction);
	TInt CurrentInstructionThumb(DThread* aThread, TUint32& aInstruction);
	TUint32 PCAfterInstructionExecutes(DThread *aThread, TUint32 aCurrentPC, TUint32 /*aStatusRegister*/, TInt aInstSize, TUint32 &aNewRangeEnd, TBool &aChangingModes);
	TUint32 ShiftedRegValue(DThread *aThread, TUint32 aInstruction, TUint32 aCurrentPC, TUint32 aStatusRegister);
	TInt CurrentPC(DThread* aThread, TUint32& aPC);
	TInt CurrentCPSR(DThread* aThread, TUint32& aCPSR);
	TInt ReadMem32(DThread* aThread, const TUint32 aAddress, TUint32& aValue);
	TInt ReadMem16(DThread* aThread, const TUint32 aAddress, TUint16& aValue);
	TInt RegisterValue(DThread *aThread, const TUint32 aKernelRegisterId, TUint32 &aValue);
#endif

#ifdef FSHELL_ARM_MEM_MAPPED_DEBUG
	TUint32 ReadRegister(TInt aRegisterOffset);
	void WriteRegister(TInt aRegisterOffset, TUint32 aValue);
#endif

private:
	enum TZombieMode
		{
		EDisabled = 0,
		EAbnormalExit = 1,
		EAllExits = 2,
		};
	TZombieMode iZombieMode;
	
	struct SZombie
		{
		DThread* iThread;
		SDblQueLink iLink;
		DSemaphore* iBlocker; // Null if thread manually suspended via SuspendThread
		TLinAddr iBreakpointAddress; // > 0 if the thread is blocked on a breakpoint
		};
	SDblQue iZombies;
	TInt iZombieCount;
	NFastMutex iLock; // For iZombies and other non-breakpoint-related structures

	struct SBreakpoint
		{
		SBreakpoint(DThread* aThread, TInt aBreakpointId, TLinAddr aAddress, const RMemoryAccess::TPredicate& aCondition);
		void SetThreadMatchPattern(HBuf* aMatch);
		TBool MatchesThread(DThread* aThread) const;
		~SBreakpoint(); // Note this DOESNT deque from the breakpoint list - do that first!

		TBool HasModifiedCode() const;
		TBool IsHardware() const;

		DThread* iThread;
		TInt iBreakpointId;
		TLinAddr iAddress; // If the breakpoint is pending, this is actually the codeseg offset
		TBuf8<4> iOrigInstruction;
		SDblQueLink iLink;
		TAny* iCodeSeg; // If the breakpoint is pending, an HBuf* which is the name of the codeseg. For a persistant breakpoint, NULL. For anything that HasModifiedCode(), the DCodeSeg* that the address is in
		enum TFlags
			{
			EDisabledPendingCodesegLoad = 1,
			EDisabledByUser = 2,
			EDisabledDuringContinue = 4,
			EDisabled = EDisabledPendingCodesegLoad|EDisabledByUser|EDisabledDuringContinue,

			EPersistant = 8, // Meaning the actual code has an invalid instruction, so hasn't been ModifyCoded, so we should resume to the next instruction.
			EThumb = 16,
			EHardware = 32, // Implies EThreadSpecific
			ETempContinue = 64,
			EThreadSpecific = 128, // Only match a single specified thread.
			};
		TUint iFlags;
		SBreakpoint* iRealBreakpoint; // If iFlags&ETempContinue, points to the breakpoint we're temping for. Otherwise, this indicates that the breakpoint hasn't called ModifyCode because (currently) there is another breakpoint (in a different thread) at the same address that has done it for us.
		TInt iHardwareBreakpointId; // Only relevant if iFlags&EHardware
		TInt iHardwareBreakpointContextReg; // Ditto. Value is either 4 or 5
		//TInt iContinueCount;
		HBuf* iMatch;
		RMemoryAccess::TPredicate iCondition;

	private:
		SBreakpoint(); // No copying allowed
		};
	TBool iCodeModifierInited;
	SDblQue iBreakpoints;
	TInt iNextBreakpointId;
	MDebuggerEventClient* iBreakpointNotifyClient;
	/* Rules for the breakpoint lock: Any manipulation of iBreakpoints, or of any breakpoint on the iBreakpoints list, must be protected by this lock.
	 * Ditto iFreeHwBreakpoints. SBreakpoint objects not on the list can be manipulated without needing the lock held
	 */
	DMutex* iBreakpointMutex;
	TDfc iHandleCodesegRemovedDfc;
	struct SRemovedCodeseg
		{
		DProcess* iProcess;
		DCodeSeg* iCodeseg;
		SDblQueLink iLink;
		};
	SDblQue iRemovedCodesegs; // Protected by iLock
	TUint32 iFreeHwBreakpoints;
	DPlatChunkHw* iDebugRegistersChunk;

	class TCreatorInfo
		{
	public:
		TCreatorInfo(TUint aThreadId, TUint aCreatorThreadId)
			: iThreadId(aThreadId), iCreatorThreadId(aCreatorThreadId)
			{}

		TUint iThreadId;
		TUint iCreatorThreadId;
		};
	RArray<TCreatorInfo> iCreatorInfo;
	};

#endif // FDEBUGGERKERNEL_H