113901SN/A/*
213901SN/A * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
313901SN/A * Distributed under the terms of the MIT License.
413901SN/A */
513901SN/A#ifndef TEAM_DEBUGGER_H
613901SN/A#define TEAM_DEBUGGER_H
713901SN/A
813901SN/A
913901SN/A#include <debugger.h>
1013901SN/A#include <Looper.h>
1113901SN/A
1213901SN/A#include <debug_support.h>
1313901SN/A
1413901SN/A#include "DebugEvent.h"
1513901SN/A#include "Team.h"
1613901SN/A#include "TeamSettings.h"
1713901SN/A#include "ThreadHandler.h"
1813901SN/A#include "UserInterface.h"
1913901SN/A#include "Worker.h"
2013901SN/A
2113901SN/A
2213901SN/Aclass DebuggerInterface;
2313901SN/Aclass DebugReportGenerator;
2413901SN/Aclass FileManager;
2513901SN/Aclass SettingsManager;
2613901SN/Aclass TeamDebugInfo;
2713901SN/Aclass TeamMemoryBlockManager;
2813901SN/Aclass WatchpointManager;
29
30
31class TeamDebugger : public BLooper, private UserInterfaceListener,
32	private JobListener, private Team::Listener {
33public:
34	class Listener;
35
36public:
37								TeamDebugger(Listener* listener,
38									UserInterface* userInterface,
39									SettingsManager* settingsManager);
40								~TeamDebugger();
41
42			status_t			Init(team_id teamID, thread_id threadID,
43									bool stopInMain);
44
45			void				Activate();
46
47			team_id				TeamID() const	{ return fTeamID; }
48
49	virtual	void				MessageReceived(BMessage* message);
50
51private:
52	// UserInterfaceListener
53	virtual	void				FunctionSourceCodeRequested(
54									FunctionInstance* function);
55	virtual void				SourceEntryLocateRequested(
56									const char* sourcePath,
57									const char* locatedPath);
58	virtual	void				ImageDebugInfoRequested(Image* image);
59	virtual	void				ValueNodeValueRequested(CpuState* cpuState,
60									ValueNodeContainer* container,
61									ValueNode* valueNode);
62	virtual	void				ThreadActionRequested(thread_id threadID,
63									uint32 action);
64	virtual	void				SetBreakpointRequested(target_addr_t address,
65									bool enabled);
66	virtual	void				SetBreakpointEnabledRequested(
67									UserBreakpoint* breakpoint,
68									bool enabled);
69	virtual	void				ClearBreakpointRequested(target_addr_t address);
70	virtual	void				ClearBreakpointRequested(
71									UserBreakpoint* breakpoint);
72	virtual	void				SetWatchpointRequested(target_addr_t address,
73									uint32 type, int32 length, bool enabled);
74	virtual	void				SetWatchpointEnabledRequested(
75									Watchpoint *watchpoint, bool enabled);
76	virtual	void				ClearWatchpointRequested(target_addr_t address);
77	virtual	void				ClearWatchpointRequested(
78									Watchpoint* breakpoint);
79
80	virtual void				InspectRequested(target_addr_t address,
81									TeamMemoryBlock::Listener* listener);
82
83	virtual void				DebugReportRequested(entry_ref* targetPath);
84
85	virtual	bool				UserInterfaceQuitRequested(
86									QuitOption quitOption);
87
88	// JobListener
89	virtual	void				JobDone(Job* job);
90	virtual	void				JobFailed(Job* job);
91	virtual	void				JobAborted(Job* job);
92
93	// Team::Listener
94	virtual	void				ThreadStateChanged(
95									const ::Team::ThreadEvent& event);
96	virtual	void				ThreadCpuStateChanged(
97									const ::Team::ThreadEvent& event);
98	virtual	void				ThreadStackTraceChanged(
99									const ::Team::ThreadEvent& event);
100	virtual	void				ImageDebugInfoChanged(
101									const ::Team::ImageEvent& event);
102
103private:
104	struct ImageHandler;
105	struct ImageHandlerHashDefinition;
106	struct ImageInfoPendingThread;
107	struct ImageInfoPendingThreadHashDefinition;
108
109	typedef BOpenHashTable<ImageHandlerHashDefinition> ImageHandlerTable;
110	typedef BOpenHashTable<ImageInfoPendingThreadHashDefinition>
111		ImageInfoPendingThreadTable;
112
113private:
114	static	status_t			_DebugEventListenerEntry(void* data);
115			status_t			_DebugEventListener();
116
117			void				_HandleDebuggerMessage(DebugEvent* event);
118
119			bool				_HandleThreadCreated(
120									ThreadCreatedEvent* event);
121			bool				_HandleThreadRenamed(
122									ThreadRenamedEvent* event);
123			bool				_HandleThreadPriorityChanged(
124									ThreadPriorityChangedEvent* event);
125			bool				_HandleThreadDeleted(
126									ThreadDeletedEvent* event);
127			bool				_HandleImageCreated(
128									ImageCreatedEvent* event);
129			bool				_HandleImageDeleted(
130									ImageDeletedEvent* event);
131
132			void				_HandleImageDebugInfoChanged(image_id imageID);
133			void				_HandleImageFileChanged(image_id imageID);
134
135			void				_HandleSetUserBreakpoint(target_addr_t address,
136									bool enabled);
137			void				_HandleSetUserBreakpoint(
138									UserBreakpoint* breakpoint, bool enabled);
139			void				_HandleClearUserBreakpoint(
140									target_addr_t address);
141			void				_HandleClearUserBreakpoint(
142									UserBreakpoint* breakpoint);
143
144			void				_HandleSetWatchpoint(target_addr_t address,
145									uint32 type, int32 length, 	bool enabled);
146			void				_HandleSetWatchpoint(
147									Watchpoint* watchpoint, bool enabled);
148			void				_HandleClearWatchpoint(	target_addr_t address);
149			void				_HandleClearWatchpoint(Watchpoint* watchpoint);
150
151			void				_HandleInspectAddress(
152									target_addr_t address,
153									TeamMemoryBlock::Listener* listener);
154
155			ThreadHandler*		_GetThreadHandler(thread_id threadID);
156
157			status_t			_AddImage(const ImageInfo& imageInfo,
158									Image** _image = NULL);
159
160			void				_LoadSettings();
161			void				_SaveSettings();
162
163			void				_NotifyUser(const char* title,
164									const char* text,...);
165
166private:
167			Listener*			fListener;
168			SettingsManager*	fSettingsManager;
169			::Team*				fTeam;
170			team_id				fTeamID;
171			ThreadHandlerTable	fThreadHandlers;
172									// protected by the team lock
173			ImageHandlerTable*	fImageHandlers;
174			ImageInfoPendingThreadTable* fImageInfoPendingThreads;
175			DebuggerInterface*	fDebuggerInterface;
176			TeamDebugInfo*		fTeamDebugInfo;
177			FileManager*		fFileManager;
178			Worker*				fWorker;
179			BreakpointManager*	fBreakpointManager;
180			WatchpointManager*	fWatchpointManager;
181			TeamMemoryBlockManager*
182								fMemoryBlockManager;
183			DebugReportGenerator*
184								fReportGenerator;
185			thread_id			fDebugEventListener;
186			UserInterface*		fUserInterface;
187	volatile bool				fTerminating;
188			bool				fKillTeamOnQuit;
189			TeamSettings		fTeamSettings;
190};
191
192
193class TeamDebugger::Listener {
194public:
195	virtual						~Listener();
196
197	virtual void				TeamDebuggerStarted(TeamDebugger* debugger) = 0;
198	virtual	void				TeamDebuggerQuit(TeamDebugger* debugger) = 0;
199};
200
201
202#endif	// TEAM_DEBUGGER_H
203