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)
603