Coverage Report

Created: 2022-01-22 13:19

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Host/common/NativeRegisterContext.h
Line
Count
Source (jump to first uncovered line)
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 &reg_value) = 0;
50
51
  virtual Status WriteRegister(const RegisterInfo *reg_info,
52
                               const RegisterValue &reg_value) = 0;
53
54
  virtual Status ReadAllRegisterValues(lldb::DataBufferSP &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 &reg_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 &reg_value);
115
116
  // Subclasses should not override these
117
  virtual lldb::tid_t GetThreadID() const;
118
119
0
  virtual NativeThreadProtocol &GetThread() { return m_thread; }
120
121
  virtual std::vector<uint32_t>
122
  GetExpeditedRegisters(ExpeditedRegs expType) const;
123
124
0
  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