05fc1277c4
UserInterface:
- Add Clone() function to set of required virtuals. This asks the subclass
to create a new instance of its respective type.
{CommandLine,Graphical,Report}UserInterface:
- Implement the above function.
TeamDebugger:
- Add accessor for the currently active UI.
TargetHostInterface:
- Set correct request type when setting up the options for a team restart.
- Ask the TeamDebugger for its user interface and clone it in order to fill
in that aspect of the debug options. This fixes a regression introduced in
commit 880a64, which inadvertently resulted in team restarts no longer
working.
301 lines
9.1 KiB
C++
301 lines
9.1 KiB
C++
/*
|
|
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
|
* Copyright 2013-2016, Rene Gollent, rene@gollent.com.
|
|
* Distributed under the terms of the MIT License.
|
|
*/
|
|
#ifndef TEAM_DEBUGGER_H
|
|
#define TEAM_DEBUGGER_H
|
|
|
|
|
|
#include <debugger.h>
|
|
#include <Looper.h>
|
|
|
|
#include "Team.h"
|
|
#include "TeamSettings.h"
|
|
#include "ThreadHandler.h"
|
|
#include "UserInterface.h"
|
|
#include "util/Worker.h"
|
|
|
|
|
|
class DebugEvent;
|
|
class DebuggerInterface;
|
|
class DebugReportGenerator;
|
|
class FileManager;
|
|
class ImageCreatedEvent;
|
|
class ImageDebugInfoLoadingState;
|
|
class ImageDeletedEvent;
|
|
class PostSyscallEvent;
|
|
class SettingsManager;
|
|
class TeamDebugInfo;
|
|
class TeamDeletedEvent;
|
|
class TeamExecEvent;
|
|
class TeamMemoryBlockManager;
|
|
class Thread;
|
|
class ThreadCreatedEvent;
|
|
class ThreadDeletedEvent;
|
|
class ThreadRenamedEvent;
|
|
class ThreadPriorityChangedEvent;
|
|
class WatchpointManager;
|
|
|
|
|
|
class TeamDebugger : public BLooper, private UserInterfaceListener,
|
|
private JobListener, private Team::Listener {
|
|
public:
|
|
class Listener;
|
|
|
|
public:
|
|
TeamDebugger(Listener* listener,
|
|
UserInterface* userInterface,
|
|
SettingsManager* settingsManager);
|
|
~TeamDebugger();
|
|
|
|
status_t Init(DebuggerInterface* interface,
|
|
thread_id threadID, int argc,
|
|
const char* const* argv,
|
|
bool stopInMain);
|
|
|
|
void Activate();
|
|
|
|
team_id TeamID() const { return fTeamID; }
|
|
|
|
bool IsPostMortem() const { return fIsPostMortem; }
|
|
|
|
int ArgumentCount() const
|
|
{ return fCommandLineArgc; }
|
|
const char** Arguments() const
|
|
{ return fCommandLineArgv; }
|
|
SettingsManager* GetSettingsManager() const
|
|
{ return fSettingsManager; }
|
|
UserInterface* GetUserInterface() const
|
|
{ return fUserInterface; }
|
|
|
|
virtual void MessageReceived(BMessage* message);
|
|
|
|
private:
|
|
// UserInterfaceListener
|
|
virtual void FunctionSourceCodeRequested(
|
|
FunctionInstance* function,
|
|
bool forceDisassembly = false);
|
|
virtual void SourceEntryLocateRequested(
|
|
const char* sourcePath,
|
|
const char* locatedPath);
|
|
virtual void SourceEntryInvalidateRequested(
|
|
LocatableFile* sourceFile);
|
|
virtual void ImageDebugInfoRequested(Image* image);
|
|
virtual void ValueNodeValueRequested(CpuState* cpuState,
|
|
ValueNodeContainer* container,
|
|
ValueNode* valueNode);
|
|
virtual void ValueNodeWriteRequested(ValueNode* node,
|
|
CpuState* state,
|
|
Value* newValue);
|
|
virtual void ThreadActionRequested(thread_id threadID,
|
|
uint32 action, target_addr_t address);
|
|
|
|
virtual void SetBreakpointRequested(target_addr_t address,
|
|
bool enabled, bool hidden = false);
|
|
virtual void SetBreakpointEnabledRequested(
|
|
UserBreakpoint* breakpoint,
|
|
bool enabled);
|
|
virtual void SetBreakpointConditionRequested(
|
|
UserBreakpoint* breakpoint,
|
|
const char* condition);
|
|
virtual void ClearBreakpointConditionRequested(
|
|
UserBreakpoint* breakpoint);
|
|
virtual void ClearBreakpointRequested(target_addr_t address);
|
|
virtual void ClearBreakpointRequested(
|
|
UserBreakpoint* breakpoint);
|
|
|
|
virtual void SetStopOnImageLoadRequested(bool enabled,
|
|
bool useImageNames);
|
|
virtual void AddStopImageNameRequested(
|
|
const char* name);
|
|
virtual void RemoveStopImageNameRequested(
|
|
const char* name);
|
|
|
|
virtual void SetDefaultSignalDispositionRequested(
|
|
int32 disposition);
|
|
virtual void SetCustomSignalDispositionRequested(
|
|
int32 signal, int32 disposition);
|
|
virtual void RemoveCustomSignalDispositionRequested(
|
|
int32 signal);
|
|
|
|
virtual void SetWatchpointRequested(target_addr_t address,
|
|
uint32 type, int32 length, bool enabled);
|
|
virtual void SetWatchpointEnabledRequested(
|
|
Watchpoint *watchpoint, bool enabled);
|
|
virtual void ClearWatchpointRequested(target_addr_t address);
|
|
virtual void ClearWatchpointRequested(
|
|
Watchpoint* breakpoint);
|
|
|
|
virtual void InspectRequested(target_addr_t address,
|
|
TeamMemoryBlock::Listener* listener);
|
|
virtual void MemoryWriteRequested(target_addr_t address,
|
|
const void* data, target_size_t size);
|
|
|
|
virtual void ExpressionEvaluationRequested(
|
|
SourceLanguage* language,
|
|
ExpressionInfo* info,
|
|
StackFrame* frame = NULL,
|
|
::Thread* thread = NULL);
|
|
|
|
virtual void DebugReportRequested(entry_ref* targetPath);
|
|
|
|
virtual void WriteCoreFileRequested(entry_ref* targetPath);
|
|
|
|
virtual void TeamRestartRequested();
|
|
|
|
virtual bool UserInterfaceQuitRequested(
|
|
QuitOption quitOption);
|
|
|
|
// JobListener
|
|
virtual void JobStarted(Job* job);
|
|
virtual void JobDone(Job* job);
|
|
virtual void JobWaitingForInput(Job* job);
|
|
virtual void JobFailed(Job* job);
|
|
virtual void JobAborted(Job* job);
|
|
|
|
// Team::Listener
|
|
virtual void ThreadStateChanged(
|
|
const ::Team::ThreadEvent& event);
|
|
virtual void ThreadCpuStateChanged(
|
|
const ::Team::ThreadEvent& event);
|
|
virtual void ThreadStackTraceChanged(
|
|
const ::Team::ThreadEvent& event);
|
|
virtual void ImageDebugInfoChanged(
|
|
const ::Team::ImageEvent& event);
|
|
|
|
private:
|
|
struct ImageHandler;
|
|
struct ImageHandlerHashDefinition;
|
|
struct ImageInfoPendingThread;
|
|
struct ImageInfoPendingThreadHashDefinition;
|
|
|
|
typedef BOpenHashTable<ImageHandlerHashDefinition> ImageHandlerTable;
|
|
typedef BOpenHashTable<ImageInfoPendingThreadHashDefinition>
|
|
ImageInfoPendingThreadTable;
|
|
|
|
private:
|
|
static status_t _DebugEventListenerEntry(void* data);
|
|
status_t _DebugEventListener();
|
|
|
|
void _HandleDebuggerMessage(DebugEvent* event);
|
|
|
|
bool _HandleTeamDeleted(
|
|
TeamDeletedEvent* event);
|
|
bool _HandleThreadCreated(
|
|
ThreadCreatedEvent* event);
|
|
bool _HandleThreadRenamed(
|
|
ThreadRenamedEvent* event);
|
|
bool _HandleThreadPriorityChanged(
|
|
ThreadPriorityChangedEvent* event);
|
|
bool _HandleThreadDeleted(
|
|
ThreadDeletedEvent* event);
|
|
bool _HandleImageCreated(
|
|
ImageCreatedEvent* event);
|
|
bool _HandleImageDeleted(
|
|
ImageDeletedEvent* event);
|
|
bool _HandlePostSyscall(
|
|
PostSyscallEvent* event);
|
|
|
|
void _PrepareForTeamExec(TeamExecEvent* event);
|
|
|
|
void _HandleImageDebugInfoChanged(image_id imageID);
|
|
void _HandleImageFileChanged(image_id imageID);
|
|
|
|
void _HandleSetUserBreakpoint(target_addr_t address,
|
|
bool enabled, bool hidden);
|
|
void _HandleSetUserBreakpoint(
|
|
UserBreakpoint* breakpoint, bool enabled);
|
|
void _HandleClearUserBreakpoint(
|
|
target_addr_t address);
|
|
void _HandleClearUserBreakpoint(
|
|
UserBreakpoint* breakpoint);
|
|
|
|
void _HandleSetWatchpoint(target_addr_t address,
|
|
uint32 type, int32 length, bool enabled);
|
|
void _HandleSetWatchpoint(
|
|
Watchpoint* watchpoint, bool enabled);
|
|
void _HandleClearWatchpoint( target_addr_t address);
|
|
void _HandleClearWatchpoint(Watchpoint* watchpoint);
|
|
|
|
void _HandleInspectAddress(
|
|
target_addr_t address,
|
|
TeamMemoryBlock::Listener* listener);
|
|
void _HandleWriteMemory(
|
|
target_addr_t address, void* data,
|
|
target_size_t size);
|
|
|
|
void _HandleEvaluateExpression(
|
|
SourceLanguage* language,
|
|
ExpressionInfo* info,
|
|
StackFrame* frame,
|
|
::Thread* thread);
|
|
|
|
void _HandleWriteCoreFile(const entry_ref& ref);
|
|
|
|
status_t _HandleSetArguments(int argc,
|
|
const char* const* argv);
|
|
|
|
void _HandleDebugInfoJobUserInput(
|
|
ImageDebugInfoLoadingState* state);
|
|
|
|
ThreadHandler* _GetThreadHandler(thread_id threadID);
|
|
|
|
status_t _AddImage(const ImageInfo& imageInfo,
|
|
Image** _image = NULL);
|
|
|
|
void _LoadSettings();
|
|
void _SaveSettings();
|
|
|
|
void _NotifyUser(const char* title,
|
|
const char* text,...);
|
|
|
|
void _ResetUserBackgroundStatusIfNeeded();
|
|
// updates user interface to
|
|
// ready/completed message
|
|
// for background work status
|
|
|
|
private:
|
|
Listener* fListener;
|
|
SettingsManager* fSettingsManager;
|
|
::Team* fTeam;
|
|
team_id fTeamID;
|
|
bool fIsPostMortem;
|
|
ThreadHandlerTable fThreadHandlers;
|
|
// protected by the team lock
|
|
ImageHandlerTable* fImageHandlers;
|
|
ImageInfoPendingThreadTable* fImageInfoPendingThreads;
|
|
DebuggerInterface* fDebuggerInterface;
|
|
TeamDebugInfo* fTeamDebugInfo;
|
|
FileManager* fFileManager;
|
|
Worker* fWorker;
|
|
BreakpointManager* fBreakpointManager;
|
|
WatchpointManager* fWatchpointManager;
|
|
TeamMemoryBlockManager*
|
|
fMemoryBlockManager;
|
|
DebugReportGenerator*
|
|
fReportGenerator;
|
|
thread_id fDebugEventListener;
|
|
UserInterface* fUserInterface;
|
|
volatile bool fTerminating;
|
|
bool fKillTeamOnQuit;
|
|
TeamSettings fTeamSettings;
|
|
int fCommandLineArgc;
|
|
const char** fCommandLineArgv;
|
|
bool fExecPending;
|
|
};
|
|
|
|
|
|
class TeamDebugger::Listener {
|
|
public:
|
|
virtual ~Listener();
|
|
|
|
virtual void TeamDebuggerStarted(TeamDebugger* debugger) = 0;
|
|
virtual void TeamDebuggerRestartRequested(
|
|
TeamDebugger* debugger) = 0;
|
|
virtual void TeamDebuggerQuit(TeamDebugger* debugger) = 0;
|
|
};
|
|
|
|
|
|
#endif // TEAM_DEBUGGER_H
|