Debugger: Split into core library and application.

- Add subfolder src/kits/debugger which contains the debugger's core functionality and lower layers. Correspondingly add headers/private/debugger for shared headers to be used by clients such as the Debugger application and eventual remote_debug_server. Adjust various files to account for differences as a result of the split and moves. - Add libdebugger.so to minimal Jamfile.
2016-06-04 13:18:39 -04:00
parent e6687e8f3d
commit fce4895d18
417 changed files with 492 additions and 390 deletions
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2009, Ingo Weinhold, [email protected].
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef STACK_FRAME_H
+#define STACK_FRAME_H
+
+
+#include <OS.h>
+
+#include <ObjectList.h>
+#include <Referenceable.h>
+#include <util/DoublyLinkedList.h>
+
+#include "Types.h"
+
+
+enum stack_frame_type {
+	STACK_FRAME_TYPE_SYSCALL,		// syscall frame
+	STACK_FRAME_TYPE_STANDARD,		// standard frame
+	STACK_FRAME_TYPE_SIGNAL,		// signal handler frame
+	STACK_FRAME_TYPE_FRAMELESS		// dummy frame for a frameless function
+};
+
+
+class CpuState;
+class Image;
+class FunctionInstance;
+class StackFrameDebugInfo;
+class StackFrameValueInfos;
+class StackFrameValues;
+class TypeComponentPath;
+class Variable;
+
+
+class StackFrame : public BReferenceable {
+public:
+	class Listener;
+
+public:
+								StackFrame(stack_frame_type type,
+									CpuState* cpuState,
+									target_addr_t frameAddress,
+									target_addr_t instructionPointer,
+									StackFrameDebugInfo* debugInfo);
+								~StackFrame();
+
+			status_t			Init();
+
+			stack_frame_type	Type() const			{ return fType; }
+			CpuState*			GetCpuState() const		{ return fCpuState; }
+			target_addr_t		FrameAddress() const { return fFrameAddress; }
+			StackFrameDebugInfo* DebugInfo() const		{ return fDebugInfo; }
+
+			target_addr_t		InstructionPointer() const
+									{ return fInstructionPointer; }
+
+			CpuState*			PreviousCpuState() const
+									{ return fPreviousCpuState; }
+			void				SetPreviousCpuState(CpuState* state);
+
+			target_addr_t		ReturnAddress() const { return fReturnAddress; }
+			void				SetReturnAddress(target_addr_t address);
+
+			Image*				GetImage() const		{ return fImage; }
+			void				SetImage(Image* image);
+
+			FunctionInstance*	Function() const		{ return fFunction; }
+			void				SetFunction(FunctionInstance* function);
+
+			int32				CountParameters() const;
+			Variable*			ParameterAt(int32 index) const;
+			bool				AddParameter(Variable* parameter);
+
+			int32				CountLocalVariables() const;
+			Variable*			LocalVariableAt(int32 index) const;
+			bool				AddLocalVariable(Variable* variable);
+
+			StackFrameValues*	Values() const			{ return fValues; }
+			StackFrameValueInfos* ValueInfos() const	{ return fValueInfos; }
+
+			// team lock must be held
+			void				AddListener(Listener* listener);
+			void				RemoveListener(Listener* listener);
+
+			void				NotifyValueRetrieved(Variable* variable,
+									TypeComponentPath* path);
+
+private:
+			typedef BObjectList<Variable> VariableList;
+			typedef DoublyLinkedList<Listener> ListenerList;
+
+private:
+			stack_frame_type	fType;
+			CpuState*			fCpuState;
+			CpuState*			fPreviousCpuState;
+			target_addr_t		fFrameAddress;
+			target_addr_t		fInstructionPointer;
+			target_addr_t		fReturnAddress;
+			StackFrameDebugInfo* fDebugInfo;
+			Image*				fImage;
+			FunctionInstance*	fFunction;
+			VariableList		fParameters;
+			VariableList		fLocalVariables;
+			StackFrameValues*	fValues;
+			StackFrameValueInfos* fValueInfos;
+			ListenerList		fListeners;
+};
+
+
+class StackFrame::Listener : public DoublyLinkedListLinkImpl<Listener> {
+public:
+	virtual						~Listener();
+
+	virtual	void				StackFrameValueRetrieved(StackFrame* stackFrame,
+									Variable* variable,
+									TypeComponentPath* path);
+									// called with lock held
+};
+
+
+#endif	// STACK_FRAME_H