mirror of
https://review.haiku-os.org/haiku
synced 2025-02-07 06:16:11 +01:00
da4d62db94
- Made Job Referenceable.
- Turned JobKey into an abstract base class to add flexibility. The new
SimpleJobKey is a subclass with the former functionality.
* TeamWindow: Removed the TeamWindow* parameter from the listener hooks. The
TeamDebugger knows anyway.
* Added IDs to Variable, Function, and FunctionInstance. The latter two generate
the ID on the fly, Variable stores it.
* SpecificImageDebugInfo::CreateFrame(): Changed FunctionDebugInfo* debug
parameter to FunctionInstance* to provide more info (the function ID).
* DwarfInterfaceFactory/DwarfImageDebugInfo:
- Added class DwarfFunctionParameterID, an ID class implementation for
function parameters and set the IDs on the parameter objects.
- Retrieve the size of a type (i.e. the size of its objects) and store it in
DwarfType.
- If a parameter's ValueLocation doesn't have a size, set that of the
respective type.
- Map the register indicies in the parameters' ValueLocations from DWARF to
our indices.
* Added class TypeComponentPath for identifying subcomponents in types.
* Added class StackFrameValues, a container associating variables and their
subcomponents with values.
* StackFrame does now have a StackFrameValues object for parameters and local
variables and a mechanism to notify listeners when values have been retrieved.
* Added GetStackFrameValueJob to retrieve variable values. Lots of functionality
is missing yet. Most notably it doesn't retrieves values for subcomponents.
* Wired everything to trigger loading of variable values and getting notified
when done.
* VariablesView: Added a value column. This is all very basic and has to be
done differently, but at least values for the parameters can be seen already.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@31636 a95241bf-73f2-0310-859d-f6bbb57e9c96
134 lines
3.5 KiB
C++
134 lines
3.5 KiB
C++
/*
|
|
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
|
* Distributed under the terms of the MIT License.
|
|
*/
|
|
#ifndef TEAM_DEBUGGER_H
|
|
#define TEAM_DEBUGGER_H
|
|
|
|
#include <debugger.h>
|
|
#include <Looper.h>
|
|
|
|
#include <debug_support.h>
|
|
|
|
#include "DebugEvent.h"
|
|
#include "Team.h"
|
|
#include "TeamWindow.h"
|
|
#include "ThreadHandler.h"
|
|
#include "Worker.h"
|
|
|
|
|
|
class DebuggerInterface;
|
|
class FileManager;
|
|
class TeamDebugInfo;
|
|
class TeamDebugModel;
|
|
|
|
|
|
class TeamDebugger : public BLooper, private TeamWindow::Listener,
|
|
private JobListener, private Team::Listener {
|
|
public:
|
|
class Listener;
|
|
|
|
public:
|
|
TeamDebugger(Listener* listener);
|
|
~TeamDebugger();
|
|
|
|
status_t Init(team_id teamID, thread_id threadID,
|
|
bool stopInMain);
|
|
|
|
team_id TeamID() const { return fTeamID; }
|
|
|
|
virtual void MessageReceived(BMessage* message);
|
|
|
|
private:
|
|
// TeamWindow::Listener
|
|
virtual void FunctionSourceCodeRequested(
|
|
FunctionInstance* function);
|
|
virtual void ImageDebugInfoRequested(Image* image);
|
|
virtual void StackFrameValueRequested(::Thread* thread,
|
|
StackFrame* stackFrame, Variable* variable,
|
|
TypeComponentPath* path);
|
|
virtual void ThreadActionRequested(thread_id threadID,
|
|
uint32 action);
|
|
virtual void SetBreakpointRequested(target_addr_t address,
|
|
bool enabled);
|
|
virtual void ClearBreakpointRequested(target_addr_t address);
|
|
virtual bool TeamWindowQuitRequested();
|
|
|
|
// JobListener
|
|
virtual void JobDone(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);
|
|
|
|
private:
|
|
struct ImageHandler;
|
|
struct ImageHandlerHashDefinition;
|
|
typedef OpenHashTable<ImageHandlerHashDefinition> ImageHandlerTable;
|
|
|
|
private:
|
|
static status_t _DebugEventListenerEntry(void* data);
|
|
status_t _DebugEventListener();
|
|
|
|
void _HandleDebuggerMessage(DebugEvent* event);
|
|
|
|
bool _HandleThreadCreated(
|
|
ThreadCreatedEvent* event);
|
|
bool _HandleThreadDeleted(
|
|
ThreadDeletedEvent* event);
|
|
bool _HandleImageCreated(
|
|
ImageCreatedEvent* event);
|
|
bool _HandleImageDeleted(
|
|
ImageDeletedEvent* event);
|
|
|
|
void _HandleImageFileChanged(image_id imageID);
|
|
|
|
void _HandleSetUserBreakpoint(target_addr_t address,
|
|
bool enabled);
|
|
void _HandleClearUserBreakpoint(
|
|
target_addr_t address);
|
|
|
|
ThreadHandler* _GetThreadHandler(thread_id threadID);
|
|
|
|
status_t _AddImage(const ImageInfo& imageInfo,
|
|
Image** _image = NULL);
|
|
|
|
void _NotifyUser(const char* title,
|
|
const char* text,...);
|
|
|
|
private:
|
|
Listener* fListener;
|
|
::Team* fTeam;
|
|
TeamDebugModel* fDebugModel;
|
|
team_id fTeamID;
|
|
ThreadHandlerTable fThreadHandlers;
|
|
// protected by the team lock
|
|
ImageHandlerTable* fImageHandlers;
|
|
DebuggerInterface* fDebuggerInterface;
|
|
TeamDebugInfo* fTeamDebugInfo;
|
|
FileManager* fFileManager;
|
|
Worker* fWorker;
|
|
BreakpointManager* fBreakpointManager;
|
|
thread_id fDebugEventListener;
|
|
TeamWindow* fTeamWindow;
|
|
volatile bool fTerminating;
|
|
bool fKillTeamOnQuit;
|
|
};
|
|
|
|
|
|
class TeamDebugger::Listener {
|
|
public:
|
|
virtual ~Listener();
|
|
|
|
virtual void TeamDebuggerQuit(TeamDebugger* debugger) = 0;
|
|
};
|
|
|
|
|
|
#endif // TEAM_DEBUGGER_H
|