LLDB  mainline
NativeRegisterContextWindows_WoW64.cpp
Go to the documentation of this file.
1 //===-- NativeRegisterContextWindows_WoW64.cpp ----------------------------===//
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 #if defined(__x86_64__) || defined(_M_X64)
10 
11 #include "NativeRegisterContextWindows_WoW64.h"
12 
13 #include "NativeThreadWindows.h"
14 #include "Plugins/Process/Utility/RegisterContextWindows_i386.h"
15 #include "ProcessWindowsLog.h"
16 #include "lldb/Host/HostInfo.h"
17 #include "lldb/Host/HostThread.h"
18 #include "lldb/Host/windows/HostThreadWindows.h"
19 #include "lldb/Host/windows/windows.h"
20 
21 #include "lldb/Utility/Log.h"
22 #include "lldb/Utility/RegisterValue.h"
23 #include "llvm/ADT/STLExtras.h"
24 
25 using namespace lldb;
26 using namespace lldb_private;
27 
28 #define REG_CONTEXT_SIZE sizeof(::WOW64_CONTEXT)
29 
30 namespace {
31 static const uint32_t g_gpr_regnums_WoW64[] = {
32  lldb_eax_i386, lldb_ebx_i386, lldb_ecx_i386, lldb_edx_i386,
33  lldb_edi_i386, lldb_esi_i386, lldb_ebp_i386, lldb_esp_i386,
34  lldb_eip_i386, lldb_eflags_i386, lldb_cs_i386, lldb_fs_i386,
35  lldb_gs_i386, lldb_ss_i386, lldb_ds_i386, lldb_es_i386,
36  LLDB_INVALID_REGNUM // Register set must be terminated with this flag.
37 };
38 
39 static const RegisterSet g_reg_sets_WoW64[] = {
40  {"General Purpose Registers", "gpr",
41  llvm::array_lengthof(g_gpr_regnums_WoW64) - 1, g_gpr_regnums_WoW64},
42 };
43 enum { k_num_register_sets = 1 };
44 
45 static const DWORD kWoW64ContextFlags =
46  WOW64_CONTEXT_CONTROL | WOW64_CONTEXT_INTEGER | WOW64_CONTEXT_SEGMENTS;
47 
48 } // namespace
49 
50 static RegisterInfoInterface *
51 CreateRegisterInfoInterface(const ArchSpec &target_arch) {
52  // i686 32bit instruction set.
53  assert((target_arch.GetAddressByteSize() == 4 &&
54  HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
55  "Register setting path assumes this is a 64-bit host");
56  return new RegisterContextWindows_i386(target_arch);
57 }
58 
59 static Status
60 GetWoW64ThreadContextHelper(lldb::thread_t thread_handle,
61  PWOW64_CONTEXT context_ptr,
62  const DWORD control_flag = kWoW64ContextFlags) {
63  Log *log = GetLog(WindowsLog::Registers);
64  Status error;
65  memset(context_ptr, 0, sizeof(::WOW64_CONTEXT));
66  context_ptr->ContextFlags = control_flag;
67  if (!::Wow64GetThreadContext(thread_handle, context_ptr)) {
68  error.SetError(GetLastError(), eErrorTypeWin32);
69  LLDB_LOG(log, "{0} Wow64GetThreadContext failed with error {1}",
70  __FUNCTION__, error);
71  return error;
72  }
73  return Status();
74 }
75 
76 static Status SetWoW64ThreadContextHelper(lldb::thread_t thread_handle,
77  PWOW64_CONTEXT context_ptr) {
78  Log *log = GetLog(WindowsLog::Registers);
79  Status error;
80  if (!::Wow64SetThreadContext(thread_handle, context_ptr)) {
81  error.SetError(GetLastError(), eErrorTypeWin32);
82  LLDB_LOG(log, "{0} Wow64SetThreadContext failed with error {1}",
83  __FUNCTION__, error);
84  return error;
85  }
86  return Status();
87 }
88 
89 NativeRegisterContextWindows_WoW64::NativeRegisterContextWindows_WoW64(
90  const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
91  : NativeRegisterContextWindows(native_thread,
92  CreateRegisterInfoInterface(target_arch)) {}
93 
94 bool NativeRegisterContextWindows_WoW64::IsGPR(uint32_t reg_index) const {
95  return (reg_index >= k_first_gpr_i386 && reg_index < k_first_alias_i386);
96 }
97 
98 bool NativeRegisterContextWindows_WoW64::IsDR(uint32_t reg_index) const {
99  return (reg_index >= lldb_dr0_i386 && reg_index <= lldb_dr7_i386);
100 }
101 
102 uint32_t NativeRegisterContextWindows_WoW64::GetRegisterSetCount() const {
103  return k_num_register_sets;
104 }
105 
106 const RegisterSet *
107 NativeRegisterContextWindows_WoW64::GetRegisterSet(uint32_t set_index) const {
108  if (set_index >= k_num_register_sets)
109  return nullptr;
110  return &g_reg_sets_WoW64[set_index];
111 }
112 
113 Status NativeRegisterContextWindows_WoW64::GPRRead(const uint32_t reg,
114  RegisterValue &reg_value) {
115  ::WOW64_CONTEXT tls_context;
116  Status error = GetWoW64ThreadContextHelper(GetThreadHandle(), &tls_context);
117  if (error.Fail())
118  return error;
119 
120  switch (reg) {
121  case lldb_eax_i386:
122  reg_value.SetUInt32(tls_context.Eax);
123  break;
124  case lldb_ebx_i386:
125  reg_value.SetUInt32(tls_context.Ebx);
126  break;
127  case lldb_ecx_i386:
128  reg_value.SetUInt32(tls_context.Ecx);
129  break;
130  case lldb_edx_i386:
131  reg_value.SetUInt32(tls_context.Edx);
132  break;
133  case lldb_edi_i386:
134  reg_value.SetUInt32(tls_context.Edi);
135  break;
136  case lldb_esi_i386:
137  reg_value.SetUInt32(tls_context.Esi);
138  break;
139  case lldb_ebp_i386:
140  reg_value.SetUInt32(tls_context.Ebp);
141  break;
142  case lldb_esp_i386:
143  reg_value.SetUInt32(tls_context.Esp);
144  break;
145  case lldb_eip_i386:
146  reg_value.SetUInt32(tls_context.Eip);
147  break;
148  case lldb_eflags_i386:
149  reg_value.SetUInt32(tls_context.EFlags);
150  break;
151  case lldb_cs_i386:
152  reg_value.SetUInt32(tls_context.SegCs);
153  break;
154  case lldb_fs_i386:
155  reg_value.SetUInt32(tls_context.SegFs);
156  break;
157  case lldb_gs_i386:
158  reg_value.SetUInt32(tls_context.SegGs);
159  break;
160  case lldb_ss_i386:
161  reg_value.SetUInt32(tls_context.SegSs);
162  break;
163  case lldb_ds_i386:
164  reg_value.SetUInt32(tls_context.SegDs);
165  break;
166  case lldb_es_i386:
167  reg_value.SetUInt32(tls_context.SegEs);
168  break;
169  }
170 
171  return error;
172 }
173 
174 Status
175 NativeRegisterContextWindows_WoW64::GPRWrite(const uint32_t reg,
176  const RegisterValue &reg_value) {
177  ::WOW64_CONTEXT tls_context;
178  auto thread_handle = GetThreadHandle();
179  Status error = GetWoW64ThreadContextHelper(thread_handle, &tls_context);
180  if (error.Fail())
181  return error;
182 
183  switch (reg) {
184  case lldb_eax_i386:
185  tls_context.Eax = reg_value.GetAsUInt32();
186  break;
187  case lldb_ebx_i386:
188  tls_context.Ebx = reg_value.GetAsUInt32();
189  break;
190  case lldb_ecx_i386:
191  tls_context.Ecx = reg_value.GetAsUInt32();
192  break;
193  case lldb_edx_i386:
194  tls_context.Edx = reg_value.GetAsUInt32();
195  break;
196  case lldb_edi_i386:
197  tls_context.Edi = reg_value.GetAsUInt32();
198  break;
199  case lldb_esi_i386:
200  tls_context.Esi = reg_value.GetAsUInt32();
201  break;
202  case lldb_ebp_i386:
203  tls_context.Ebp = reg_value.GetAsUInt32();
204  break;
205  case lldb_esp_i386:
206  tls_context.Esp = reg_value.GetAsUInt32();
207  break;
208  case lldb_eip_i386:
209  tls_context.Eip = reg_value.GetAsUInt32();
210  break;
211  case lldb_eflags_i386:
212  tls_context.EFlags = reg_value.GetAsUInt32();
213  break;
214  case lldb_cs_i386:
215  tls_context.SegCs = reg_value.GetAsUInt32();
216  break;
217  case lldb_fs_i386:
218  tls_context.SegFs = reg_value.GetAsUInt32();
219  break;
220  case lldb_gs_i386:
221  tls_context.SegGs = reg_value.GetAsUInt32();
222  break;
223  case lldb_ss_i386:
224  tls_context.SegSs = reg_value.GetAsUInt32();
225  break;
226  case lldb_ds_i386:
227  tls_context.SegDs = reg_value.GetAsUInt32();
228  break;
229  case lldb_es_i386:
230  tls_context.SegEs = reg_value.GetAsUInt32();
231  break;
232  }
233 
234  return SetWoW64ThreadContextHelper(thread_handle, &tls_context);
235 }
236 
237 Status NativeRegisterContextWindows_WoW64::DRRead(const uint32_t reg,
238  RegisterValue &reg_value) {
239  ::WOW64_CONTEXT tls_context;
240  DWORD context_flag = CONTEXT_DEBUG_REGISTERS;
241  Status error = GetWoW64ThreadContextHelper(GetThreadHandle(), &tls_context,
242  context_flag);
243  if (error.Fail())
244  return error;
245 
246  switch (reg) {
247  case lldb_dr0_i386:
248  reg_value.SetUInt32(tls_context.Dr0);
249  break;
250  case lldb_dr1_i386:
251  reg_value.SetUInt32(tls_context.Dr1);
252  break;
253  case lldb_dr2_i386:
254  reg_value.SetUInt32(tls_context.Dr2);
255  break;
256  case lldb_dr3_i386:
257  reg_value.SetUInt32(tls_context.Dr3);
258  break;
259  case lldb_dr4_i386:
260  return Status("register DR4 is obsolete");
261  case lldb_dr5_i386:
262  return Status("register DR5 is obsolete");
263  case lldb_dr6_i386:
264  reg_value.SetUInt32(tls_context.Dr6);
265  break;
266  case lldb_dr7_i386:
267  reg_value.SetUInt32(tls_context.Dr7);
268  break;
269  }
270 
271  return {};
272 }
273 
274 Status
275 NativeRegisterContextWindows_WoW64::DRWrite(const uint32_t reg,
276  const RegisterValue &reg_value) {
277  ::WOW64_CONTEXT tls_context;
278  DWORD context_flag = CONTEXT_DEBUG_REGISTERS;
279  auto thread_handle = GetThreadHandle();
280  Status error =
281  GetWoW64ThreadContextHelper(thread_handle, &tls_context, context_flag);
282  if (error.Fail())
283  return error;
284 
285  switch (reg) {
286  case lldb_dr0_i386:
287  tls_context.Dr0 = reg_value.GetAsUInt32();
288  break;
289  case lldb_dr1_i386:
290  tls_context.Dr1 = reg_value.GetAsUInt32();
291  break;
292  case lldb_dr2_i386:
293  tls_context.Dr2 = reg_value.GetAsUInt32();
294  break;
295  case lldb_dr3_i386:
296  tls_context.Dr3 = reg_value.GetAsUInt32();
297  break;
298  case lldb_dr4_i386:
299  return Status("register DR4 is obsolete");
300  case lldb_dr5_i386:
301  return Status("register DR5 is obsolete");
302  case lldb_dr6_i386:
303  tls_context.Dr6 = reg_value.GetAsUInt32();
304  break;
305  case lldb_dr7_i386:
306  tls_context.Dr7 = reg_value.GetAsUInt32();
307  break;
308  }
309 
310  return SetWoW64ThreadContextHelper(thread_handle, &tls_context);
311 }
312 
313 Status
314 NativeRegisterContextWindows_WoW64::ReadRegister(const RegisterInfo *reg_info,
315  RegisterValue &reg_value) {
316  Status error;
317  if (!reg_info) {
318  error.SetErrorString("reg_info NULL");
319  return error;
320  }
321 
322  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
323  if (reg == LLDB_INVALID_REGNUM) {
324  // This is likely an internal register for lldb use only and should not be
325  // directly queried.
326  error.SetErrorStringWithFormat("register \"%s\" is an internal-only lldb "
327  "register, cannot read directly",
328  reg_info->name);
329  return error;
330  }
331 
332  if (IsGPR(reg))
333  return GPRRead(reg, reg_value);
334 
335  if (IsDR(reg))
336  return DRRead(reg, reg_value);
337 
338  return Status("unimplemented");
339 }
340 
341 Status NativeRegisterContextWindows_WoW64::WriteRegister(
342  const RegisterInfo *reg_info, const RegisterValue &reg_value) {
343  Status error;
344 
345  if (!reg_info) {
346  error.SetErrorString("reg_info NULL");
347  return error;
348  }
349 
350  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
351  if (reg == LLDB_INVALID_REGNUM) {
352  // This is likely an internal register for lldb use only and should not be
353  // directly written.
354  error.SetErrorStringWithFormat("register \"%s\" is an internal-only lldb "
355  "register, cannot write directly",
356  reg_info->name);
357  return error;
358  }
359 
360  if (IsGPR(reg))
361  return GPRWrite(reg, reg_value);
362 
363  if (IsDR(reg))
364  return DRWrite(reg, reg_value);
365 
366  return Status("unimplemented");
367 }
368 
369 Status NativeRegisterContextWindows_WoW64::ReadAllRegisterValues(
370  lldb::WritableDataBufferSP &data_sp) {
371  const size_t data_size = REG_CONTEXT_SIZE;
372  data_sp = std::make_shared<DataBufferHeap>(data_size, 0);
373  ::WOW64_CONTEXT tls_context;
374  Status error = GetWoW64ThreadContextHelper(GetThreadHandle(), &tls_context);
375  if (error.Fail())
376  return error;
377 
378  uint8_t *dst = data_sp->GetBytes();
379  ::memcpy(dst, &tls_context, data_size);
380  return error;
381 }
382 
383 Status NativeRegisterContextWindows_WoW64::WriteAllRegisterValues(
384  const lldb::DataBufferSP &data_sp) {
385  Status error;
386  const size_t data_size = REG_CONTEXT_SIZE;
387  if (!data_sp) {
388  error.SetErrorStringWithFormat(
389  "NativeRegisterContextWindows_WoW64::%s invalid data_sp provided",
390  __FUNCTION__);
391  return error;
392  }
393 
394  if (data_sp->GetByteSize() != data_size) {
395  error.SetErrorStringWithFormatv(
396  "data_sp contained mismatched data size, expected {0}, actual {1}",
397  data_size, data_sp->GetByteSize());
398  return error;
399  }
400 
401  ::WOW64_CONTEXT tls_context;
402  memcpy(&tls_context, data_sp->GetBytes(), data_size);
403  return SetWoW64ThreadContextHelper(GetThreadHandle(), &tls_context);
404 }
405 
406 Status NativeRegisterContextWindows_WoW64::IsWatchpointHit(uint32_t wp_index,
407  bool &is_hit) {
408  is_hit = false;
409 
410  if (wp_index >= NumSupportedHardwareWatchpoints())
411  return Status("watchpoint index out of range");
412 
413  RegisterValue reg_value;
414  Status error = DRRead(lldb_dr6_i386, reg_value);
415  if (error.Fail())
416  return error;
417 
418  is_hit = reg_value.GetAsUInt32() & (1 << wp_index);
419 
420  return {};
421 }
422 
423 Status NativeRegisterContextWindows_WoW64::GetWatchpointHitIndex(
424  uint32_t &wp_index, lldb::addr_t trap_addr) {
425  wp_index = LLDB_INVALID_INDEX32;
426 
427  for (uint32_t i = 0; i < NumSupportedHardwareWatchpoints(); i++) {
428  bool is_hit;
429  Status error = IsWatchpointHit(i, is_hit);
430  if (error.Fail())
431  return error;
432 
433  if (is_hit) {
434  wp_index = i;
435  return {};
436  }
437  }
438 
439  return {};
440 }
441 
442 Status NativeRegisterContextWindows_WoW64::IsWatchpointVacant(uint32_t wp_index,
443  bool &is_vacant) {
444  is_vacant = false;
445 
446  if (wp_index >= NumSupportedHardwareWatchpoints())
447  return Status("Watchpoint index out of range");
448 
449  RegisterValue reg_value;
450  Status error = DRRead(lldb_dr7_i386, reg_value);
451  if (error.Fail())
452  return error;
453 
454  is_vacant = !(reg_value.GetAsUInt32() & (1 << (2 * wp_index)));
455 
456  return error;
457 }
458 
459 bool NativeRegisterContextWindows_WoW64::ClearHardwareWatchpoint(
460  uint32_t wp_index) {
461  if (wp_index >= NumSupportedHardwareWatchpoints())
462  return false;
463 
464  // for watchpoints 0, 1, 2, or 3, respectively, clear bits 0, 1, 2, or 3 of
465  // the debug status register (DR6)
466 
467  RegisterValue reg_value;
468  Status error = DRRead(lldb_dr6_i386, reg_value);
469  if (error.Fail())
470  return false;
471 
472  uint32_t bit_mask = 1 << wp_index;
473  uint32_t status_bits = reg_value.GetAsUInt32() & ~bit_mask;
474  error = DRWrite(lldb_dr6_i386, RegisterValue(status_bits));
475  if (error.Fail())
476  return false;
477 
478  // for watchpoints 0, 1, 2, or 3, respectively, clear bits {0-1,16-19},
479  // {2-3,20-23}, {4-5,24-27}, or {6-7,28-31} of the debug control register
480  // (DR7)
481 
482  error = DRRead(lldb_dr7_i386, reg_value);
483  if (error.Fail())
484  return false;
485 
486  bit_mask = (0x3 << (2 * wp_index)) | (0xF << (16 + 4 * wp_index));
487  uint32_t control_bits = reg_value.GetAsUInt32() & ~bit_mask;
488  return DRWrite(lldb_dr7_i386, RegisterValue(control_bits)).Success();
489 }
490 
491 Status NativeRegisterContextWindows_WoW64::ClearAllHardwareWatchpoints() {
492  RegisterValue reg_value;
493 
494  // clear bits {0-4} of the debug status register (DR6)
495 
496  Status error = DRRead(lldb_dr6_i386, reg_value);
497  if (error.Fail())
498  return error;
499 
500  uint32_t status_bits = reg_value.GetAsUInt32() & ~0xF;
501  error = DRWrite(lldb_dr6_i386, RegisterValue(status_bits));
502  if (error.Fail())
503  return error;
504 
505  // clear bits {0-7,16-31} of the debug control register (DR7)
506 
507  error = DRRead(lldb_dr7_i386, reg_value);
508  if (error.Fail())
509  return error;
510 
511  uint32_t control_bits = reg_value.GetAsUInt32() & ~0xFFFF00FF;
512  return DRWrite(lldb_dr7_i386, RegisterValue(control_bits));
513 }
514 
515 uint32_t NativeRegisterContextWindows_WoW64::SetHardwareWatchpoint(
516  lldb::addr_t addr, size_t size, uint32_t watch_flags) {
517  switch (size) {
518  case 1:
519  case 2:
520  case 4:
521  break;
522  default:
523  return LLDB_INVALID_INDEX32;
524  }
525 
526  if (watch_flags == 0x2)
527  watch_flags = 0x3;
528 
529  if (watch_flags != 0x1 && watch_flags != 0x3)
530  return LLDB_INVALID_INDEX32;
531 
532  for (uint32_t wp_index = 0; wp_index < NumSupportedHardwareWatchpoints();
533  ++wp_index) {
534  bool is_vacant;
535  if (IsWatchpointVacant(wp_index, is_vacant).Fail())
536  return LLDB_INVALID_INDEX32;
537 
538  if (is_vacant) {
539  if (!ClearHardwareWatchpoint(wp_index))
540  return LLDB_INVALID_INDEX32;
541 
542  if (ApplyHardwareBreakpoint(wp_index, addr, size, watch_flags).Fail())
543  return LLDB_INVALID_INDEX32;
544 
545  return wp_index;
546  }
547  }
548  return LLDB_INVALID_INDEX32;
549 }
550 
551 Status NativeRegisterContextWindows_WoW64::ApplyHardwareBreakpoint(
552  uint32_t wp_index, lldb::addr_t addr, size_t size, uint32_t flags) {
553  RegisterValue reg_value;
554  auto error = DRRead(lldb_dr7_i386, reg_value);
555  if (error.Fail())
556  return error;
557 
558  // for watchpoints 0, 1, 2, or 3, respectively, set bits 1, 3, 5, or 7
559  uint32_t enable_bit = 1 << (2 * wp_index);
560 
561  // set bits 16-17, 20-21, 24-25, or 28-29
562  // with 0b01 for write, and 0b11 for read/write
563  uint32_t rw_bits = flags << (16 + 4 * wp_index);
564 
565  // set bits 18-19, 22-23, 26-27, or 30-31
566  // with 0b00, 0b01, 0b10, or 0b11
567  // for 1, 2, 8 (if supported), or 4 bytes, respectively
568  uint32_t size_bits = (size == 8 ? 0x2 : size - 1) << (18 + 4 * wp_index);
569 
570  uint32_t bit_mask = (0x3 << (2 * wp_index)) | (0xF << (16 + 4 * wp_index));
571 
572  uint32_t control_bits = reg_value.GetAsUInt32() & ~bit_mask;
573  control_bits |= enable_bit | rw_bits | size_bits;
574 
575  error = DRWrite(lldb_dr7_i386, RegisterValue(control_bits));
576  if (error.Fail())
577  return error;
578 
579  error = DRWrite(lldb_dr0_i386 + wp_index, RegisterValue(addr));
580  if (error.Fail())
581  return error;
582 
583  return {};
584 }
585 
586 lldb::addr_t
587 NativeRegisterContextWindows_WoW64::GetWatchpointAddress(uint32_t wp_index) {
588  if (wp_index >= NumSupportedHardwareWatchpoints())
589  return LLDB_INVALID_ADDRESS;
590 
591  RegisterValue reg_value;
592  if (DRRead(lldb_dr0_i386 + wp_index, reg_value).Fail())
593  return LLDB_INVALID_ADDRESS;
594 
595  return reg_value.GetAsUInt32();
596 }
597 
598 uint32_t NativeRegisterContextWindows_WoW64::NumSupportedHardwareWatchpoints() {
599  return 4;
600 }
601 
602 #endif // defined(__x86_64__) || defined(_M_X64)
lldb_private::lldb_dr2_i386
@ lldb_dr2_i386
Definition: lldb-x86-register-enums.h:119
lldb_private::lldb_fs_i386
@ lldb_fs_i386
Definition: lldb-x86-register-enums.h:29
lldb_private::ArchSpec
Definition: ArchSpec.h:33
lldb_private::lldb_eax_i386
@ lldb_eax_i386
Definition: lldb-x86-register-enums.h:18
LLDB_INVALID_REGNUM
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:79
lldb_private::lldb_ecx_i386
@ lldb_ecx_i386
Definition: lldb-x86-register-enums.h:20
lldb_private::RegisterValue
Definition: RegisterValue.h:28
lldb_private::NativeThreadProtocol
Definition: NativeThreadProtocol.h:24
arm64_dwarf::x2
@ x2
Definition: ARM64_DWARF_Registers.h:19
lldb_private::lldb_esi_i386
@ lldb_esi_i386
Definition: lldb-x86-register-enums.h:23
lldb_private::RegisterInfoInterface
Definition: RegisterInfoInterface.h:21
RegisterValue.h
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
arm64_dwarf::x3
@ x3
Definition: ARM64_DWARF_Registers.h:20
lldb::eErrorTypeWin32
@ eErrorTypeWin32
Standard Win32 error codes.
Definition: lldb-enumerations.h:312
lldb_private::lldb_cs_i386
@ lldb_cs_i386
Definition: lldb-x86-register-enums.h:28
ProcessWindowsLog.h
REG_CONTEXT_SIZE
#define REG_CONTEXT_SIZE
Definition: RegisterContextDarwin_arm.cpp:181
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::lldb_dr3_i386
@ lldb_dr3_i386
Definition: lldb-x86-register-enums.h:120
HostThread.h
lldb::thread_t
pthread_t thread_t
Definition: lldb-types.h:58
lldb::eRegisterKindLLDB
@ eRegisterKindLLDB
lldb's internal register numbers
Definition: lldb-enumerations.h:234
Log.h
lldb_private::lldb_edi_i386
@ lldb_edi_i386
Definition: lldb-x86-register-enums.h:22
lldb_private::lldb_dr0_i386
@ lldb_dr0_i386
Definition: lldb-x86-register-enums.h:117
lldb_private::lldb_eip_i386
@ lldb_eip_i386
Definition: lldb-x86-register-enums.h:26
lldb_private::NativeRegisterContextWindows
Definition: NativeRegisterContextWindows.h:20
lldb_private::lldb_ebp_i386
@ lldb_ebp_i386
Definition: lldb-x86-register-enums.h:24
lldb_private::lldb_gs_i386
@ lldb_gs_i386
Definition: lldb-x86-register-enums.h:30
k_num_register_sets
constexpr size_t k_num_register_sets
Definition: RegisterContextFreeBSD_mips64.cpp:55
arm64_dwarf::x1
@ x1
Definition: ARM64_DWARF_Registers.h:18
RegisterContextWindows_i386.h
HostInfo.h
lldb_private::lldb_es_i386
@ lldb_es_i386
Definition: lldb-x86-register-enums.h:33
lldb_private::lldb_ebx_i386
@ lldb_ebx_i386
Definition: lldb-x86-register-enums.h:19
RegisterContextWindows_i386
Definition: RegisterContextWindows_i386.h:14
NativeRegisterContextWindows_WoW64.h
lldb_private::ArchSpec::GetAddressByteSize
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:684
lldb_private::RegisterValue::SetUInt32
void SetUInt32(uint32_t uint, Type t=eTypeUInt32)
Definition: RegisterValue.h:200
lldb_private::lldb_esp_i386
@ lldb_esp_i386
Definition: lldb-x86-register-enums.h:25
lldb_private::Status
Definition: Status.h:44
uint32_t
lldb_private::lldb_dr1_i386
@ lldb_dr1_i386
Definition: lldb-x86-register-enums.h:118
windows.h
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:263
lldb_private::lldb_ss_i386
@ lldb_ss_i386
Definition: lldb-x86-register-enums.h:31
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
LLDB_INVALID_INDEX32
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:75
lldb_private::Log
Definition: Log.h:48
lldb_private::lldb_dr4_i386
@ lldb_dr4_i386
Definition: lldb-x86-register-enums.h:121
lldb_private::k_first_gpr_i386
@ k_first_gpr_i386
Definition: lldb-x86-register-enums.h:17
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:235
lldb_private::RegisterValue::GetAsUInt32
uint32_t GetAsUInt32(uint32_t fail_value=UINT32_MAX, bool *success_ptr=nullptr) const
Definition: RegisterValue.cpp:533
lldb_private::lldb_dr6_i386
@ lldb_dr6_i386
Definition: lldb-x86-register-enums.h:123
lldb
Definition: SBAddress.h:15
lldb_private::k_first_alias_i386
@ k_first_alias_i386
Definition: lldb-x86-register-enums.h:35
lldb_private::lldb_dr5_i386
@ lldb_dr5_i386
Definition: lldb-x86-register-enums.h:122
lldb_private::lldb_ds_i386
@ lldb_ds_i386
Definition: lldb-x86-register-enums.h:32
HostThreadWindows.h
lldb_private::lldb_dr7_i386
@ lldb_dr7_i386
Definition: lldb-x86-register-enums.h:124
lldb_private::lldb_eflags_i386
@ lldb_eflags_i386
Definition: lldb-x86-register-enums.h:27
NativeThreadWindows.h
lldb_private::lldb_edx_i386
@ lldb_edx_i386
Definition: lldb-x86-register-enums.h:21
Generated on Sun May 22 2022 22:54:56 for LLDB by   doxygen 1.8.17