1 /*
2 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
3 * Copyright 2011-2016, Rene Gollent, rene@gollent.com.
4 * Distributed under the terms of the MIT License.
5 */
6 #ifndef ARCHITECTURE_H
7 #define ARCHITECTURE_H
8
9
10 #include <ByteOrder.h>
11 #include <OS.h>
12
13 #include <Referenceable.h>
14 #include <Variant.h>
15
16 #include "ReturnValueInfo.h"
17 #include "Types.h"
18
19
20 class CfaContext;
21 class CpuState;
22 class DisassembledCode;
23 class FunctionDebugInfo;
24 class Image;
25 class ImageDebugInfoProvider;
26 class InstructionInfo;
27 class Register;
28 class RegisterMap;
29 class StackFrame;
30 class StackTrace;
31 class Statement;
32 class Team;
33 class TeamMemory;
34 class ValueLocation;
35
36
37 enum {
38 STACK_GROWTH_DIRECTION_POSITIVE = 0,
39 STACK_GROWTH_DIRECTION_NEGATIVE
40 };
41
42
43 enum {
44 WATCHPOINT_CAPABILITY_FLAG_READ = 1,
45 WATCHPOINT_CAPABILITY_FLAG_WRITE = 2,
46 WATCHPOINT_CAPABILITY_FLAG_READ_WRITE = 4
47 };
48
49
50 class Architecture : public BReferenceable {
51 public:
52 Architecture(TeamMemory* teamMemory,
53 uint8 addressSize,
54 size_t debugCpuStateSize,
55 bool bigEndian);
56
57 virtual ~Architecture();
58
59 virtual status_t Init();
60
AddressSize()61 inline uint8 AddressSize() const { return fAddressSize; }
DebugCpuStateSize()62 inline size_t DebugCpuStateSize() const
63 { return fDebugCpuStateSize; }
64
IsBigEndian()65 inline bool IsBigEndian() const { return fBigEndian; }
66 inline bool IsHostEndian() const;
67
68 virtual int32 StackGrowthDirection() const = 0;
69
70 virtual int32 CountRegisters() const = 0;
71 virtual const Register* Registers() const = 0;
72 virtual status_t InitRegisterRules(CfaContext& context) const;
73
74 virtual status_t GetDwarfRegisterMaps(RegisterMap** _toDwarf,
75 RegisterMap** _fromDwarf) const = 0;
76 // returns references
77
78 virtual status_t GetCpuFeatures(uint32& flags) = 0;
79
80 virtual status_t CreateCpuState(CpuState*& _state) = 0;
81 virtual status_t CreateCpuState(const void* cpuStateData,
82 size_t size, CpuState*& _state) = 0;
83 virtual status_t CreateStackFrame(Image* image,
84 FunctionDebugInfo* function,
85 CpuState* cpuState, bool isTopFrame,
86 StackFrame*& _frame,
87 CpuState*& _previousCpuState) = 0;
88 // returns reference to previous frame
89 // and CPU state; returned CPU state
90 // can be NULL
91 virtual void UpdateStackFrameCpuState(
92 const StackFrame* frame,
93 Image* previousImage,
94 FunctionDebugInfo* previousFunction,
95 CpuState* previousCpuState) = 0;
96 // Called after a CreateStackFrame()
97 // with the image/function corresponding
98 // to the CPU state.
99
100 virtual status_t ReadValueFromMemory(target_addr_t address,
101 uint32 valueType, BVariant& _value) const
102 = 0;
103 virtual status_t ReadValueFromMemory(target_addr_t addressSpace,
104 target_addr_t address, uint32 valueType,
105 BVariant& _value) const = 0;
106
107 virtual status_t DisassembleCode(FunctionDebugInfo* function,
108 const void* buffer, size_t bufferSize,
109 DisassembledCode*& _sourceCode) = 0;
110 virtual status_t GetStatement(FunctionDebugInfo* function,
111 target_addr_t address,
112 Statement*& _statement) = 0;
113 virtual status_t GetInstructionInfo(target_addr_t address,
114 InstructionInfo& _info,
115 CpuState* state) = 0;
116 virtual status_t ResolvePICFunctionAddress(target_addr_t
117 instructionAddress,
118 CpuState* state,
119 target_addr_t& _targetAddress) = 0;
120
121 status_t CreateStackTrace(Team* team,
122 ImageDebugInfoProvider* imageInfoProvider,
123 CpuState* cpuState,
124 StackTrace*& _stackTrace,
125 ReturnValueInfoList* returnValueInfos,
126 int32 maxStackDepth = -1,
127 bool useExistingTrace = false,
128 bool getFullFrameInfo = true);
129 // team is not locked
130
131 virtual status_t GetWatchpointDebugCapabilities(
132 int32& _maxRegisterCount,
133 int32& _maxBytesPerRegister,
134 uint8& _watchpointCapabilityFlags) = 0;
135
136 virtual status_t GetReturnAddressLocation(
137 StackFrame* frame, target_size_t valueSize,
138 ValueLocation*& _location) = 0;
139
140
141 protected:
142 TeamMemory* fTeamMemory;
143 uint8 fAddressSize;
144 size_t fDebugCpuStateSize;
145 bool fBigEndian;
146 };
147
148
149 bool
IsHostEndian()150 Architecture::IsHostEndian() const
151 {
152 return fBigEndian == (B_HOST_IS_BENDIAN != 0);
153 }
154
155
156 #endif // ARCHITECTURE_H
157