9c9c24ce08
Architecture: - Store and provide accessor for the size in bytes of the low-level debug_cpu_state size of the respective target CPU. Adjust subclasses to pass in the appropriate size information.
157 lines
4.3 KiB
C++
157 lines
4.3 KiB
C++
/*
|
|
* 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
|