headers/private/debugger/arch/Architecture.h

   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
  61         inline  uint8                           AddressSize() const             { return fAddressSize; }
  62         inline  size_t                          DebugCpuStateSize() const
  63                                                                         { return fDebugCpuStateSize; }
  64
  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
 150 Architecture::IsHostEndian() const
 151 {
 152         return fBigEndian == (B_HOST_IS_BENDIAN != 0);
 153 }
 154
 155
 156 #endif  // ARCHITECTURE_H