haiku/headers/private/debugger/arch/Architecture.h

/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2011-2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */
#ifndef ARCHITECTURE_H
#define ARCHITECTURE_H


#include <ByteOrder.h>
#include <OS.h>

#include <Referenceable.h>
#include <Variant.h>

#include "ReturnValueInfo.h"
#include "Types.h"


class CfaContext;
class CpuState;
class DisassembledCode;
class FunctionDebugInfo;
class Image;
class ImageDebugInfoProvider;
class InstructionInfo;
class Register;
class RegisterMap;
class StackFrame;
class StackTrace;
class Statement;
class Team;
class TeamMemory;
class ValueLocation;


enum {
	STACK_GROWTH_DIRECTION_POSITIVE = 0,
	STACK_GROWTH_DIRECTION_NEGATIVE
};


enum {
	WATCHPOINT_CAPABILITY_FLAG_READ = 1,
	WATCHPOINT_CAPABILITY_FLAG_WRITE = 2,
	WATCHPOINT_CAPABILITY_FLAG_READ_WRITE = 4
};


class Architecture : public BReferenceable {
public:
								Architecture(TeamMemory* teamMemory,
									uint8 addressSize,
									size_t debugCpuStateSize,
									bool bigEndian);

	virtual						~Architecture();

	virtual	status_t			Init();

	inline	uint8				AddressSize() const		{ return fAddressSize; }
	inline	size_t				DebugCpuStateSize() const
									{ return fDebugCpuStateSize; }

	inline	bool				IsBigEndian() const		{ return fBigEndian; }
	inline	bool				IsHostEndian() const;

	virtual int32				StackGrowthDirection() const = 0;

	virtual	int32				CountRegisters() const = 0;
	virtual	const Register*		Registers() const = 0;
	virtual status_t			InitRegisterRules(CfaContext& context) const;

	virtual	status_t			GetDwarfRegisterMaps(RegisterMap** _toDwarf,
									RegisterMap** _fromDwarf) const = 0;
										// returns references

	virtual	status_t			GetCpuFeatures(uint32& flags) = 0;

	virtual	status_t			CreateCpuState(CpuState*& _state) = 0;
	virtual	status_t			CreateCpuState(const void* cpuStateData,
									size_t size, CpuState*& _state) = 0;
	virtual	status_t			CreateStackFrame(Image* image,
									FunctionDebugInfo* function,
									CpuState* cpuState, bool isTopFrame,
									StackFrame*& _frame,
									CpuState*& _previousCpuState) = 0;
										// returns reference to previous frame
										// and CPU state; returned CPU state
										// can be NULL
	virtual	void				UpdateStackFrameCpuState(
									const StackFrame* frame,
									Image* previousImage,
									FunctionDebugInfo* previousFunction,
									CpuState* previousCpuState) = 0;
										// Called after a CreateStackFrame()
										// with the image/function corresponding
										// to the CPU state.

	virtual	status_t			ReadValueFromMemory(target_addr_t address,
									uint32 valueType, BVariant& _value) const
										= 0;
	virtual	status_t			ReadValueFromMemory(target_addr_t addressSpace,
									target_addr_t address, uint32 valueType,
									BVariant& _value) const = 0;

	virtual	status_t			DisassembleCode(FunctionDebugInfo* function,
									const void* buffer, size_t bufferSize,
									DisassembledCode*& _sourceCode) = 0;
	virtual	status_t			GetStatement(FunctionDebugInfo* function,
									target_addr_t address,
									Statement*& _statement) = 0;
	virtual	status_t			GetInstructionInfo(target_addr_t address,
									InstructionInfo& _info,
									CpuState* state) = 0;
	virtual	status_t			ResolvePICFunctionAddress(target_addr_t
									instructionAddress,
									CpuState* state,
									target_addr_t& _targetAddress) = 0;

			status_t			CreateStackTrace(Team* team,
									ImageDebugInfoProvider* imageInfoProvider,
									CpuState* cpuState,
									StackTrace*& _stackTrace,
									ReturnValueInfoList* returnValueInfos,
									int32 maxStackDepth = -1,
									bool useExistingTrace = false,
									bool getFullFrameInfo = true);
										// team is not locked

	virtual	status_t			GetWatchpointDebugCapabilities(
									int32& _maxRegisterCount,
									int32& _maxBytesPerRegister,
									uint8& _watchpointCapabilityFlags) = 0;

	virtual	status_t			GetReturnAddressLocation(
									StackFrame* frame, target_size_t valueSize,
									ValueLocation*& _location) = 0;


protected:
			TeamMemory*			fTeamMemory;
			uint8				fAddressSize;
			size_t				fDebugCpuStateSize;
			bool				fBigEndian;
};


bool
Architecture::IsHostEndian() const
{
	return fBigEndian == (B_HOST_IS_BENDIAN != 0);
}


#endif	// ARCHITECTURE_H