1 //===-- NativeRegisterContext.h ---------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_HOST_COMMON_NATIVEREGISTERCONTEXT_H 10 #define LLDB_HOST_COMMON_NATIVEREGISTERCONTEXT_H 11 12 #include "lldb/Host/common/NativeWatchpointList.h" 13 #include "lldb/lldb-private.h" 14 15 namespace lldb_private { 16 17 class NativeThreadProtocol; 18 19 enum class ExpeditedRegs { Minimal, Full }; 20 21 class NativeRegisterContext 22 : public std::enable_shared_from_this<NativeRegisterContext> { 23 public: 24 // Constructors and Destructors 25 NativeRegisterContext(NativeThreadProtocol &thread); 26 27 virtual ~NativeRegisterContext(); 28 29 // void 30 // InvalidateIfNeeded (bool force); 31 32 // Subclasses must override these functions 33 // virtual void 34 // InvalidateAllRegisters () = 0; 35 36 virtual uint32_t GetRegisterCount() const = 0; 37 38 virtual uint32_t GetUserRegisterCount() const = 0; 39 40 virtual const RegisterInfo *GetRegisterInfoAtIndex(uint32_t reg) const = 0; 41 42 const char *GetRegisterSetNameForRegisterAtIndex(uint32_t reg_index) const; 43 44 virtual uint32_t GetRegisterSetCount() const = 0; 45 46 virtual const RegisterSet *GetRegisterSet(uint32_t set_index) const = 0; 47 48 virtual Status ReadRegister(const RegisterInfo *reg_info, 49 RegisterValue ®_value) = 0; 50 51 virtual Status WriteRegister(const RegisterInfo *reg_info, 52 const RegisterValue ®_value) = 0; 53 54 virtual Status ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) = 0; 55 56 virtual Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) = 0; 57 58 uint32_t ConvertRegisterKindToRegisterNumber(uint32_t kind, 59 uint32_t num) const; 60 61 // Subclasses can override these functions if desired 62 virtual uint32_t NumSupportedHardwareBreakpoints(); 63 64 virtual uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size); 65 66 virtual bool ClearHardwareBreakpoint(uint32_t hw_idx); 67 68 virtual Status ClearAllHardwareBreakpoints(); 69 70 virtual Status GetHardwareBreakHitIndex(uint32_t &bp_index, 71 lldb::addr_t trap_addr); 72 73 virtual uint32_t NumSupportedHardwareWatchpoints(); 74 75 virtual uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, 76 uint32_t watch_flags); 77 78 virtual bool ClearHardwareWatchpoint(uint32_t hw_index); 79 80 virtual Status ClearWatchpointHit(uint32_t hw_index); 81 82 virtual Status ClearAllHardwareWatchpoints(); 83 84 virtual Status IsWatchpointHit(uint32_t wp_index, bool &is_hit); 85 86 virtual Status GetWatchpointHitIndex(uint32_t &wp_index, 87 lldb::addr_t trap_addr); 88 89 virtual Status IsWatchpointVacant(uint32_t wp_index, bool &is_vacant); 90 91 virtual lldb::addr_t GetWatchpointAddress(uint32_t wp_index); 92 93 // MIPS Linux kernel returns a masked address (last 3bits are masked) 94 // when a HW watchpoint is hit. However user may not have set a watchpoint on 95 // this address. This function emulates the instruction at PC and finds the 96 // base address used in the load/store instruction. This gives the exact 97 // address used to read/write the variable being watched. For example: 'n' is 98 // at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is set at 'm', 99 // then watch exception is generated even when 'n' is read/written. This 100 // function returns address of 'n' so that client can check whether a 101 // watchpoint is set on this address or not. 102 virtual lldb::addr_t GetWatchpointHitAddress(uint32_t wp_index); 103 104 virtual bool HardwareSingleStep(bool enable); 105 106 virtual Status 107 ReadRegisterValueFromMemory(const lldb_private::RegisterInfo *reg_info, 108 lldb::addr_t src_addr, size_t src_len, 109 RegisterValue ®_value); 110 111 virtual Status 112 WriteRegisterValueToMemory(const lldb_private::RegisterInfo *reg_info, 113 lldb::addr_t dst_addr, size_t dst_len, 114 const RegisterValue ®_value); 115 116 // Subclasses should not override these 117 virtual lldb::tid_t GetThreadID() const; 118 119 virtual NativeThreadProtocol &GetThread() { return m_thread; } 120 121 virtual std::vector<uint32_t> 122 GetExpeditedRegisters(ExpeditedRegs expType) const; 123 124 virtual bool RegisterOffsetIsDynamic() const { return false; } 125 126 const RegisterInfo *GetRegisterInfoByName(llvm::StringRef reg_name, 127 uint32_t start_idx = 0); 128 129 const RegisterInfo *GetRegisterInfo(uint32_t reg_kind, uint32_t reg_num); 130 131 lldb::addr_t GetPC(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS); 132 133 virtual lldb::addr_t 134 GetPCfromBreakpointLocation(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS); 135 136 Status SetPC(lldb::addr_t pc); 137 138 lldb::addr_t GetSP(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS); 139 140 Status SetSP(lldb::addr_t sp); 141 142 lldb::addr_t GetFP(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS); 143 144 Status SetFP(lldb::addr_t fp); 145 146 const char *GetRegisterName(uint32_t reg); 147 148 lldb::addr_t GetReturnAddress(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS); 149 150 lldb::addr_t GetFlags(lldb::addr_t fail_value = 0); 151 152 lldb::addr_t ReadRegisterAsUnsigned(uint32_t reg, lldb::addr_t fail_value); 153 154 lldb::addr_t ReadRegisterAsUnsigned(const RegisterInfo *reg_info, 155 lldb::addr_t fail_value); 156 157 Status WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval); 158 159 Status WriteRegisterFromUnsigned(const RegisterInfo *reg_info, uint64_t uval); 160 161 // uint32_t 162 // GetStopID () const 163 // { 164 // return m_stop_id; 165 // } 166 167 // void 168 // SetStopID (uint32_t stop_id) 169 // { 170 // m_stop_id = stop_id; 171 // } 172 173 protected: 174 // Classes that inherit from RegisterContext can see and modify these 175 NativeThreadProtocol 176 &m_thread; // The thread that this register context belongs to. 177 // uint32_t m_stop_id; // The stop ID that any data in this 178 // context is valid for 179 180 private: 181 // For RegisterContext only 182 NativeRegisterContext(const NativeRegisterContext &) = delete; 183 const NativeRegisterContext & 184 operator=(const NativeRegisterContext &) = delete; 185 }; 186 187 } // namespace lldb_private 188 189 #endif // LLDB_HOST_COMMON_NATIVEREGISTERCONTEXT_H 190