LLDB  mainline
ProcessWindows.cpp
Go to the documentation of this file.
1 //===-- ProcessWindows.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 #include "ProcessWindows.h"
10 
11 // Windows includes
13 #include <psapi.h>
14 
16 #include "lldb/Core/Module.h"
17 #include "lldb/Core/ModuleSpec.h"
19 #include "lldb/Core/Section.h"
20 #include "lldb/Host/FileSystem.h"
21 #include "lldb/Host/HostInfo.h"
23 #include "lldb/Host/HostProcess.h"
26 #include "lldb/Symbol/ObjectFile.h"
29 #include "lldb/Target/StopInfo.h"
30 #include "lldb/Target/Target.h"
31 #include "lldb/Utility/State.h"
32 
33 #include "llvm/Support/ConvertUTF.h"
34 #include "llvm/Support/Format.h"
35 #include "llvm/Support/Threading.h"
36 #include "llvm/Support/raw_ostream.h"
37 
38 #include "DebuggerThread.h"
39 #include "ExceptionRecord.h"
40 #include "ForwardDecl.h"
41 #include "LocalDebugDelegate.h"
42 #include "ProcessWindowsLog.h"
43 #include "TargetThreadWindows.h"
44 
45 using namespace lldb;
46 using namespace lldb_private;
47 
48 LLDB_PLUGIN_DEFINE_ADV(ProcessWindows, ProcessWindowsCommon)
49 
50 namespace {
51 std::string GetProcessExecutableName(HANDLE process_handle) {
52  std::vector<wchar_t> file_name;
53  DWORD file_name_size = MAX_PATH; // first guess, not an absolute limit
54  DWORD copied = 0;
55  do {
56  file_name_size *= 2;
57  file_name.resize(file_name_size);
58  copied = ::GetModuleFileNameExW(process_handle, NULL, file_name.data(),
59  file_name_size);
60  } while (copied >= file_name_size);
61  file_name.resize(copied);
62  std::string result;
63  llvm::convertWideToUTF8(file_name.data(), result);
64  return result;
65 }
66 
67 std::string GetProcessExecutableName(DWORD pid) {
68  std::string file_name;
69  HANDLE process_handle =
70  ::OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
71  if (process_handle != NULL) {
72  file_name = GetProcessExecutableName(process_handle);
73  ::CloseHandle(process_handle);
74  }
75  return file_name;
76 }
77 } // anonymous namespace
78 
79 namespace lldb_private {
80 
81 ProcessSP ProcessWindows::CreateInstance(lldb::TargetSP target_sp,
82  lldb::ListenerSP listener_sp,
83  const FileSpec *,
84  bool can_connect) {
85  return ProcessSP(new ProcessWindows(target_sp, listener_sp));
86 }
87 
88 static bool ShouldUseLLDBServer() {
89  llvm::StringRef use_lldb_server = ::getenv("LLDB_USE_LLDB_SERVER");
90  return use_lldb_server.equals_insensitive("on") ||
91  use_lldb_server.equals_insensitive("yes") ||
92  use_lldb_server.equals_insensitive("1") ||
93  use_lldb_server.equals_insensitive("true");
94 }
95 
96 void ProcessWindows::Initialize() {
97  if (!ShouldUseLLDBServer()) {
98  static llvm::once_flag g_once_flag;
99 
100  llvm::call_once(g_once_flag, []() {
101  PluginManager::RegisterPlugin(GetPluginNameStatic(),
102  GetPluginDescriptionStatic(),
103  CreateInstance);
104  });
105  }
106 }
107 
108 void ProcessWindows::Terminate() {}
109 
110 llvm::StringRef ProcessWindows::GetPluginDescriptionStatic() {
111  return "Process plugin for Windows";
112 }
113 
114 // Constructors and destructors.
115 
116 ProcessWindows::ProcessWindows(lldb::TargetSP target_sp,
117  lldb::ListenerSP listener_sp)
118  : lldb_private::Process(target_sp, listener_sp),
119  m_watchpoint_ids(
120  RegisterContextWindows::GetNumHardwareBreakpointSlots(),
122 
124 
125 size_t ProcessWindows::GetSTDOUT(char *buf, size_t buf_size, Status &error) {
126  error.SetErrorString("GetSTDOUT unsupported on Windows");
127  return 0;
128 }
129 
130 size_t ProcessWindows::GetSTDERR(char *buf, size_t buf_size, Status &error) {
131  error.SetErrorString("GetSTDERR unsupported on Windows");
132  return 0;
133 }
134 
135 size_t ProcessWindows::PutSTDIN(const char *buf, size_t buf_size,
136  Status &error) {
137  error.SetErrorString("PutSTDIN unsupported on Windows");
138  return 0;
139 }
140 
142  if (bp_site->HardwareRequired())
143  return Status("Hardware breakpoints are not supported.");
144 
146  LLDB_LOG(log, "bp_site = {0:x}, id={1}, addr={2:x}", bp_site,
147  bp_site->GetID(), bp_site->GetLoadAddress());
148 
150  if (!error.Success())
151  LLDB_LOG(log, "error: {0}", error);
152  return error;
153 }
154 
157  LLDB_LOG(log, "bp_site = {0:x}, id={1}, addr={2:x}", bp_site,
158  bp_site->GetID(), bp_site->GetLoadAddress());
159 
161 
162  if (!error.Success())
163  LLDB_LOG(log, "error: {0}", error);
164  return error;
165 }
166 
167 Status ProcessWindows::DoDetach(bool keep_stopped) {
168  Status error;
170  StateType private_state = GetPrivateState();
171  if (private_state != eStateExited && private_state != eStateDetached) {
172  error = DetachProcess();
173  if (error.Success())
175  else
176  LLDB_LOG(log, "Detaching process error: {0}", error);
177  } else {
178  error.SetErrorStringWithFormatv("error: process {0} in state = {1}, but "
179  "cannot detach it in this state.",
180  GetID(), private_state);
181  LLDB_LOG(log, "error: {0}", error);
182  }
183  return error;
184 }
185 
187  ProcessLaunchInfo &launch_info) {
188  Status error;
189  DebugDelegateSP delegate(new LocalDebugDelegate(shared_from_this()));
190  error = LaunchProcess(launch_info, delegate);
191  if (error.Success())
192  SetID(launch_info.GetProcessID());
193  return error;
194 }
195 
196 Status
198  const ProcessAttachInfo &attach_info) {
199  DebugDelegateSP delegate(new LocalDebugDelegate(shared_from_this()));
200  Status error = AttachProcess(pid, attach_info, delegate);
201  if (error.Success())
203  return error;
204 }
205 
208  llvm::sys::ScopedLock lock(m_mutex);
209  Status error;
210 
211  StateType private_state = GetPrivateState();
212  if (private_state == eStateStopped || private_state == eStateCrashed) {
213  LLDB_LOG(log, "process {0} is in state {1}. Resuming...",
214  m_session_data->m_debugger->GetProcess().GetProcessId(),
215  GetPrivateState());
216 
217  LLDB_LOG(log, "resuming {0} threads.", m_thread_list.GetSize());
218 
219  bool failed = false;
220  for (uint32_t i = 0; i < m_thread_list.GetSize(); ++i) {
221  auto thread = std::static_pointer_cast<TargetThreadWindows>(
223  Status result = thread->DoResume();
224  if (result.Fail()) {
225  failed = true;
226  LLDB_LOG(
227  log,
228  "Trying to resume thread at index {0}, but failed with error {1}.",
229  i, result);
230  }
231  }
232 
233  if (failed) {
234  error.SetErrorString("ProcessWindows::DoResume failed");
235  } else {
237  }
238 
239  ExceptionRecordSP active_exception =
240  m_session_data->m_debugger->GetActiveException().lock();
241  if (active_exception) {
242  // Resume the process and continue processing debug events. Mask the
243  // exception so that from the process's view, there is no indication that
244  // anything happened.
245  m_session_data->m_debugger->ContinueAsyncException(
247  }
248  } else {
249  LLDB_LOG(log, "error: process {0} is in state {1}. Returning...",
250  m_session_data->m_debugger->GetProcess().GetProcessId(),
251  GetPrivateState());
252  }
253  return error;
254 }
255 
257  StateType private_state = GetPrivateState();
258  return DestroyProcess(private_state);
259 }
260 
261 Status ProcessWindows::DoHalt(bool &caused_stop) {
262  StateType state = GetPrivateState();
263  if (state != eStateStopped)
264  return HaltProcess(caused_stop);
265  caused_stop = false;
266  return Status();
267 }
268 
270  ArchSpec arch_spec;
271  DidAttach(arch_spec);
272 }
273 
275  llvm::sys::ScopedLock lock(m_mutex);
276 
277  // The initial stop won't broadcast the state change event, so account for
278  // that here.
280  m_session_data->m_stop_at_entry)
282 }
283 
284 static void
285 DumpAdditionalExceptionInformation(llvm::raw_ostream &stream,
286  const ExceptionRecordSP &exception) {
287  // Decode additional exception information for specific exception types based
288  // on
289  // https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ns-winnt-_exception_record
290 
291  const int addr_min_width = 2 + 8; // "0x" + 4 address bytes
292 
293  const std::vector<ULONG_PTR> &args = exception->GetExceptionArguments();
294  switch (exception->GetExceptionCode()) {
295  case EXCEPTION_ACCESS_VIOLATION: {
296  if (args.size() < 2)
297  break;
298 
299  stream << ": ";
300  const int access_violation_code = args[0];
301  const lldb::addr_t access_violation_address = args[1];
302  switch (access_violation_code) {
303  case 0:
304  stream << "Access violation reading";
305  break;
306  case 1:
307  stream << "Access violation writing";
308  break;
309  case 8:
310  stream << "User-mode data execution prevention (DEP) violation at";
311  break;
312  default:
313  stream << "Unknown access violation (code " << access_violation_code
314  << ") at";
315  break;
316  }
317  stream << " location "
318  << llvm::format_hex(access_violation_address, addr_min_width);
319  break;
320  }
321  case EXCEPTION_IN_PAGE_ERROR: {
322  if (args.size() < 3)
323  break;
324 
325  stream << ": ";
326  const int page_load_error_code = args[0];
327  const lldb::addr_t page_load_error_address = args[1];
328  const DWORD underlying_code = args[2];
329  switch (page_load_error_code) {
330  case 0:
331  stream << "In page error reading";
332  break;
333  case 1:
334  stream << "In page error writing";
335  break;
336  case 8:
337  stream << "User-mode data execution prevention (DEP) violation at";
338  break;
339  default:
340  stream << "Unknown page loading error (code " << page_load_error_code
341  << ") at";
342  break;
343  }
344  stream << " location "
345  << llvm::format_hex(page_load_error_address, addr_min_width)
346  << " (status code " << llvm::format_hex(underlying_code, 8) << ")";
347  break;
348  }
349  }
350 }
351 
354  llvm::sys::ScopedLock lock(m_mutex);
355 
356  if (!m_session_data) {
357  LLDB_LOG(log, "no active session. Returning...");
358  return;
359  }
360 
362 
363  std::weak_ptr<ExceptionRecord> exception_record =
364  m_session_data->m_debugger->GetActiveException();
365  ExceptionRecordSP active_exception = exception_record.lock();
366  if (!active_exception) {
367  LLDB_LOG(log,
368  "there is no active exception in process {0}. Why is the "
369  "process stopped?",
370  m_session_data->m_debugger->GetProcess().GetProcessId());
371  return;
372  }
373 
374  StopInfoSP stop_info;
375  m_thread_list.SetSelectedThreadByID(active_exception->GetThreadID());
376  ThreadSP stop_thread = m_thread_list.GetSelectedThread();
377  if (!stop_thread)
378  return;
379 
380  switch (active_exception->GetExceptionCode()) {
381  case EXCEPTION_SINGLE_STEP: {
382  RegisterContextSP register_context = stop_thread->GetRegisterContext();
383  const uint64_t pc = register_context->GetPC();
384  BreakpointSiteSP site(GetBreakpointSiteList().FindByAddress(pc));
385  if (site && site->ValidForThisThread(*stop_thread)) {
386  LLDB_LOG(log,
387  "Single-stepped onto a breakpoint in process {0} at "
388  "address {1:x} with breakpoint site {2}",
389  m_session_data->m_debugger->GetProcess().GetProcessId(), pc,
390  site->GetID());
391  stop_info = StopInfo::CreateStopReasonWithBreakpointSiteID(*stop_thread,
392  site->GetID());
393  stop_thread->SetStopInfo(stop_info);
394 
395  return;
396  }
397 
398  auto *reg_ctx = static_cast<RegisterContextWindows *>(
399  stop_thread->GetRegisterContext().get());
400  uint32_t slot_id = reg_ctx->GetTriggeredHardwareBreakpointSlotId();
401  if (slot_id != LLDB_INVALID_INDEX32) {
402  int id = m_watchpoint_ids[slot_id];
403  LLDB_LOG(log,
404  "Single-stepped onto a watchpoint in process {0} at address "
405  "{1:x} with watchpoint {2}",
406  m_session_data->m_debugger->GetProcess().GetProcessId(), pc, id);
407 
408  if (lldb::WatchpointSP wp_sp =
409  GetTarget().GetWatchpointList().FindByID(id))
410  wp_sp->SetHardwareIndex(slot_id);
411 
413  *stop_thread, id, m_watchpoints[id].address);
414  stop_thread->SetStopInfo(stop_info);
415 
416  return;
417  }
418 
419  LLDB_LOG(log, "single stepping thread {0}", stop_thread->GetID());
420  stop_info = StopInfo::CreateStopReasonToTrace(*stop_thread);
421  stop_thread->SetStopInfo(stop_info);
422 
423  return;
424  }
425 
426  case EXCEPTION_BREAKPOINT: {
427  RegisterContextSP register_context = stop_thread->GetRegisterContext();
428 
429  int breakpoint_size = 1;
430  switch (GetTarget().GetArchitecture().GetMachine()) {
431  case llvm::Triple::aarch64:
432  breakpoint_size = 4;
433  break;
434 
435  case llvm::Triple::arm:
436  case llvm::Triple::thumb:
437  breakpoint_size = 2;
438  break;
439 
440  case llvm::Triple::x86:
441  case llvm::Triple::x86_64:
442  breakpoint_size = 1;
443  break;
444 
445  default:
446  LLDB_LOG(log, "Unknown breakpoint size for architecture");
447  break;
448  }
449 
450  // The current PC is AFTER the BP opcode, on all architectures.
451  uint64_t pc = register_context->GetPC() - breakpoint_size;
452 
453  BreakpointSiteSP site(GetBreakpointSiteList().FindByAddress(pc));
454  if (site) {
455  LLDB_LOG(log,
456  "detected breakpoint in process {0} at address {1:x} with "
457  "breakpoint site {2}",
458  m_session_data->m_debugger->GetProcess().GetProcessId(), pc,
459  site->GetID());
460 
461  if (site->ValidForThisThread(*stop_thread)) {
462  LLDB_LOG(log,
463  "Breakpoint site {0} is valid for this thread ({1:x}), "
464  "creating stop info.",
465  site->GetID(), stop_thread->GetID());
466 
468  *stop_thread, site->GetID());
469  register_context->SetPC(pc);
470  } else {
471  LLDB_LOG(log,
472  "Breakpoint site {0} is not valid for this thread, "
473  "creating empty stop info.",
474  site->GetID());
475  }
476  stop_thread->SetStopInfo(stop_info);
477  return;
478  } else {
479  // The thread hit a hard-coded breakpoint like an `int 3` or
480  // `__debugbreak()`.
481  LLDB_LOG(log,
482  "No breakpoint site matches for this thread. __debugbreak()? "
483  "Creating stop info with the exception.");
484  // FALLTHROUGH: We'll treat this as a generic exception record in the
485  // default case.
486  LLVM_FALLTHROUGH;
487  }
488  }
489 
490  default: {
491  std::string desc;
492  llvm::raw_string_ostream desc_stream(desc);
493  desc_stream << "Exception "
494  << llvm::format_hex(active_exception->GetExceptionCode(), 8)
495  << " encountered at address "
496  << llvm::format_hex(active_exception->GetExceptionAddress(), 8);
497  DumpAdditionalExceptionInformation(desc_stream, active_exception);
498 
500  *stop_thread, desc_stream.str().c_str());
501  stop_thread->SetStopInfo(stop_info);
502  LLDB_LOG(log, "{0}", desc_stream.str());
503  return;
504  }
505  }
506 }
507 
508 bool ProcessWindows::CanDebug(lldb::TargetSP target_sp,
509  bool plugin_specified_by_name) {
510  if (plugin_specified_by_name)
511  return true;
512 
513  // For now we are just making sure the file exists for a given module
514  ModuleSP exe_module_sp(target_sp->GetExecutableModule());
515  if (exe_module_sp.get())
516  return FileSystem::Instance().Exists(exe_module_sp->GetFileSpec());
517  // However, if there is no executable module, we return true since we might
518  // be preparing to attach.
519  return true;
520 }
521 
523  ThreadList &new_thread_list) {
524  Log *log = GetLog(WindowsLog::Thread);
525  // Add all the threads that were previously running and for which we did not
526  // detect a thread exited event.
527  int new_size = 0;
528  int continued_threads = 0;
529  int exited_threads = 0;
530  int new_threads = 0;
531 
532  for (ThreadSP old_thread : old_thread_list.Threads()) {
533  lldb::tid_t old_thread_id = old_thread->GetID();
534  auto exited_thread_iter =
535  m_session_data->m_exited_threads.find(old_thread_id);
536  if (exited_thread_iter == m_session_data->m_exited_threads.end()) {
537  new_thread_list.AddThread(old_thread);
538  ++new_size;
539  ++continued_threads;
540  LLDB_LOGV(log, "Thread {0} was running and is still running.",
541  old_thread_id);
542  } else {
543  LLDB_LOGV(log, "Thread {0} was running and has exited.", old_thread_id);
544  ++exited_threads;
545  }
546  }
547 
548  // Also add all the threads that are new since the last time we broke into
549  // the debugger.
550  for (const auto &thread_info : m_session_data->m_new_threads) {
551  new_thread_list.AddThread(thread_info.second);
552  ++new_size;
553  ++new_threads;
554  LLDB_LOGV(log, "Thread {0} is new since last update.", thread_info.first);
555  }
556 
557  LLDB_LOG(log, "{0} new threads, {1} old threads, {2} exited threads.",
558  new_threads, continued_threads, exited_threads);
559 
560  m_session_data->m_new_threads.clear();
561  m_session_data->m_exited_threads.clear();
562 
563  return new_size > 0;
564 }
565 
567  StateType state = GetPrivateState();
568  switch (state) {
569  case eStateCrashed:
570  case eStateDetached:
571  case eStateUnloaded:
572  case eStateExited:
573  case eStateInvalid:
574  return false;
575  default:
576  return true;
577  }
578 }
579 
581  return HostInfo::GetArchitecture();
582 }
583 
584 size_t ProcessWindows::DoReadMemory(lldb::addr_t vm_addr, void *buf,
585  size_t size, Status &error) {
586  size_t bytes_read = 0;
587  error = ProcessDebugger::ReadMemory(vm_addr, buf, size, bytes_read);
588  return bytes_read;
589 }
590 
591 size_t ProcessWindows::DoWriteMemory(lldb::addr_t vm_addr, const void *buf,
592  size_t size, Status &error) {
593  size_t bytes_written = 0;
594  error = ProcessDebugger::WriteMemory(vm_addr, buf, size, bytes_written);
595  return bytes_written;
596 }
597 
599  Status &error) {
601  error = ProcessDebugger::AllocateMemory(size, permissions, vm_addr);
602  return vm_addr;
603 }
604 
607 }
608 
610  MemoryRegionInfo &info) {
611  return ProcessDebugger::GetMemoryRegionInfo(vm_addr, info);
612 }
613 
615  Target &target = GetTarget();
616  ObjectFile *obj_file = target.GetExecutableModule()->GetObjectFile();
617  Address addr = obj_file->GetImageInfoAddress(&target);
618  if (addr.IsValid())
619  return addr.GetLoadAddress(&target);
620  else
621  return LLDB_INVALID_ADDRESS;
622 }
623 
625  if (m_dyld_up.get() == NULL)
628  return static_cast<DynamicLoaderWindowsDYLD *>(m_dyld_up.get());
629 }
630 
632  // No need to acquire the lock since m_session_data isn't accessed.
634  LLDB_LOG(log, "Process {0} exited with code {1}", GetID(), exit_code);
635 
636  TargetSP target = CalculateTarget();
637  if (target) {
638  ModuleSP executable_module = target->GetExecutableModule();
639  ModuleList unloaded_modules;
640  unloaded_modules.Append(executable_module);
641  target->ModulesDidUnload(unloaded_modules, true);
642  }
643 
644  SetProcessExitStatus(GetID(), true, 0, exit_code);
646 
648 }
649 
651  DebuggerThreadSP debugger = m_session_data->m_debugger;
653  LLDB_LOG(log, "Debugger connected to process {0}. Image base = {1:x}",
654  debugger->GetProcess().GetProcessId(), image_base);
655 
656  ModuleSP module = GetTarget().GetExecutableModule();
657  if (!module) {
658  // During attach, we won't have the executable module, so find it now.
659  const DWORD pid = debugger->GetProcess().GetProcessId();
660  const std::string file_name = GetProcessExecutableName(pid);
661  if (file_name.empty()) {
662  return;
663  }
664 
665  FileSpec executable_file(file_name);
666  FileSystem::Instance().Resolve(executable_file);
667  ModuleSpec module_spec(executable_file);
668  Status error;
669  module =
670  GetTarget().GetOrCreateModule(module_spec, true /* notify */, &error);
671  if (!module) {
672  return;
673  }
674 
676  }
677 
678  if (auto dyld = GetDynamicLoader())
679  dyld->OnLoadModule(module, ModuleSpec(), image_base);
680 
681  // Add the main executable module to the list of pending module loads. We
682  // can't call GetTarget().ModulesDidLoad() here because we still haven't
683  // returned from DoLaunch() / DoAttach() yet so the target may not have set
684  // the process instance to `this` yet.
685  llvm::sys::ScopedLock lock(m_mutex);
686 
687  const HostThread &host_main_thread = debugger->GetMainThread();
688  ThreadSP main_thread =
689  std::make_shared<TargetThreadWindows>(*this, host_main_thread);
690 
691  tid_t id = host_main_thread.GetNativeThread().GetThreadId();
692  main_thread->SetID(id);
693 
694  m_session_data->m_new_threads[id] = main_thread;
695 }
696 
699  const ExceptionRecord &record) {
701  llvm::sys::ScopedLock lock(m_mutex);
702 
703  // FIXME: Without this check, occasionally when running the test suite there
704  // is
705  // an issue where m_session_data can be null. It's not clear how this could
706  // happen but it only surfaces while running the test suite. In order to
707  // properly diagnose this, we probably need to first figure allow the test
708  // suite to print out full lldb logs, and then add logging to the process
709  // plugin.
710  if (!m_session_data) {
711  LLDB_LOG(log,
712  "Debugger thread reported exception {0:x} at address {1:x}, "
713  "but there is no session.",
714  record.GetExceptionCode(), record.GetExceptionAddress());
716  }
717 
718  if (!first_chance) {
719  // Not any second chance exception is an application crash by definition.
720  // It may be an expression evaluation crash.
722  }
723 
725  switch (record.GetExceptionCode()) {
726  case EXCEPTION_BREAKPOINT:
727  // Handle breakpoints at the first chance.
729 
730  if (!m_session_data->m_initial_stop_received) {
731  LLDB_LOG(
732  log,
733  "Hit loader breakpoint at address {0:x}, setting initial stop event.",
734  record.GetExceptionAddress());
735  m_session_data->m_initial_stop_received = true;
736  ::SetEvent(m_session_data->m_initial_stop_event);
737  } else {
738  LLDB_LOG(log, "Hit non-loader breakpoint at address {0:x}.",
739  record.GetExceptionAddress());
740  }
742  break;
743  case EXCEPTION_SINGLE_STEP:
746  break;
747  default:
748  LLDB_LOG(log,
749  "Debugger thread reported exception {0:x} at address {1:x} "
750  "(first_chance={2})",
751  record.GetExceptionCode(), record.GetExceptionAddress(),
752  first_chance);
753  // For non-breakpoints, give the application a chance to handle the
754  // exception first.
755  if (first_chance)
757  else
759  }
760 
761  return result;
762 }
763 
765  llvm::sys::ScopedLock lock(m_mutex);
766 
767  ThreadSP thread = std::make_shared<TargetThreadWindows>(*this, new_thread);
768 
769  const HostNativeThread &native_new_thread = new_thread.GetNativeThread();
770  tid_t id = native_new_thread.GetThreadId();
771  thread->SetID(id);
772 
773  m_session_data->m_new_threads[id] = thread;
774 
775  for (const std::map<int, WatchpointInfo>::value_type &p : m_watchpoints) {
776  auto *reg_ctx = static_cast<RegisterContextWindows *>(
777  thread->GetRegisterContext().get());
778  reg_ctx->AddHardwareBreakpoint(p.second.slot_id, p.second.address,
779  p.second.size, p.second.read,
780  p.second.write);
781  }
782 }
783 
785  llvm::sys::ScopedLock lock(m_mutex);
786 
787  // On a forced termination, we may get exit thread events after the session
788  // data has been cleaned up.
789  if (!m_session_data)
790  return;
791 
792  // A thread may have started and exited before the debugger stopped allowing a
793  // refresh.
794  // Just remove it from the new threads list in that case.
795  auto iter = m_session_data->m_new_threads.find(thread_id);
796  if (iter != m_session_data->m_new_threads.end())
797  m_session_data->m_new_threads.erase(iter);
798  else
799  m_session_data->m_exited_threads.insert(thread_id);
800 }
801 
802 void ProcessWindows::OnLoadDll(const ModuleSpec &module_spec,
803  lldb::addr_t module_addr) {
804  if (auto dyld = GetDynamicLoader())
805  dyld->OnLoadModule(nullptr, module_spec, module_addr);
806 }
807 
809  if (auto dyld = GetDynamicLoader())
810  dyld->OnUnloadModule(module_addr);
811 }
812 
814 
816  llvm::sys::ScopedLock lock(m_mutex);
818 
819  if (m_session_data->m_initial_stop_received) {
820  // This happened while debugging. Do we shutdown the debugging session,
821  // try to continue, or do something else?
822  LLDB_LOG(log,
823  "Error {0} occurred during debugging. Unexpected behavior "
824  "may result. {1}",
825  error.GetError(), error);
826  } else {
827  // If we haven't actually launched the process yet, this was an error
828  // launching the process. Set the internal error and signal the initial
829  // stop event so that the DoLaunch method wakes up and returns a failure.
830  m_session_data->m_launch_error = error;
831  ::SetEvent(m_session_data->m_initial_stop_event);
832  LLDB_LOG(
833  log,
834  "Error {0} occurred launching the process before the initial stop. {1}",
835  error.GetError(), error);
836  return;
837  }
838 }
839 
842  return {};
843 }
844 
848  return {};
849 }
850 
852  Status error;
853 
854  if (wp->IsEnabled()) {
855  wp->SetEnabled(true, notify);
856  return error;
857  }
858 
859  WatchpointInfo info;
860  for (info.slot_id = 0;
862  info.slot_id++)
864  break;
866  error.SetErrorStringWithFormat("Can't find free slot for watchpoint %i",
867  wp->GetID());
868  return error;
869  }
870  info.address = wp->GetLoadAddress();
871  info.size = wp->GetByteSize();
872  info.read = wp->WatchpointRead();
873  info.write = wp->WatchpointWrite();
874 
875  for (unsigned i = 0U; i < m_thread_list.GetSize(); i++) {
876  Thread *thread = m_thread_list.GetThreadAtIndex(i).get();
877  auto *reg_ctx = static_cast<RegisterContextWindows *>(
878  thread->GetRegisterContext().get());
879  if (!reg_ctx->AddHardwareBreakpoint(info.slot_id, info.address, info.size,
880  info.read, info.write)) {
881  error.SetErrorStringWithFormat(
882  "Can't enable watchpoint %i on thread 0x%llx", wp->GetID(),
883  thread->GetID());
884  break;
885  }
886  }
887  if (error.Fail()) {
888  for (unsigned i = 0U; i < m_thread_list.GetSize(); i++) {
889  Thread *thread = m_thread_list.GetThreadAtIndex(i).get();
890  auto *reg_ctx = static_cast<RegisterContextWindows *>(
891  thread->GetRegisterContext().get());
892  reg_ctx->RemoveHardwareBreakpoint(info.slot_id);
893  }
894  return error;
895  }
896 
897  m_watchpoints[wp->GetID()] = info;
898  m_watchpoint_ids[info.slot_id] = wp->GetID();
899 
900  wp->SetEnabled(true, notify);
901 
902  return error;
903 }
904 
906  Status error;
907 
908  if (!wp->IsEnabled()) {
909  wp->SetEnabled(false, notify);
910  return error;
911  }
912 
913  auto it = m_watchpoints.find(wp->GetID());
914  if (it == m_watchpoints.end()) {
915  error.SetErrorStringWithFormat("Info about watchpoint %i is not found",
916  wp->GetID());
917  return error;
918  }
919 
920  for (unsigned i = 0U; i < m_thread_list.GetSize(); i++) {
921  Thread *thread = m_thread_list.GetThreadAtIndex(i).get();
922  auto *reg_ctx = static_cast<RegisterContextWindows *>(
923  thread->GetRegisterContext().get());
924  if (!reg_ctx->RemoveHardwareBreakpoint(it->second.slot_id)) {
925  error.SetErrorStringWithFormat(
926  "Can't disable watchpoint %i on thread 0x%llx", wp->GetID(),
927  thread->GetID());
928  break;
929  }
930  }
931  if (error.Fail())
932  return error;
933 
934  m_watchpoint_ids[it->second.slot_id] = LLDB_INVALID_BREAK_ID;
935  m_watchpoints.erase(it);
936 
937  wp->SetEnabled(false, notify);
938 
939  return error;
940 }
941 } // namespace lldb_private
lldb_private::ProcessWindows::DidAttach
void DidAttach(lldb_private::ArchSpec &arch_spec) override
Called after attaching a process.
Definition: ProcessWindows.cpp:274
lldb_private::ProcessDebugger::GetDebuggedProcessId
lldb::pid_t GetDebuggedProcessId() const
Definition: ProcessDebugger.cpp:68
lldb_private::StoppointSite::GetLoadAddress
virtual lldb::addr_t GetLoadAddress() const
Definition: StoppointSite.h:27
ProcessWindows.h
lldb_private::ProcessWindows::DoReadMemory
size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error) override
Actually do the reading of memory from a process.
Definition: ProcessWindows.cpp:584
lldb_private::ProcessWindows::OnDebugString
void OnDebugString(const std::string &string) override
Definition: ProcessWindows.cpp:813
lldb_private::ArchSpec
Definition: ArchSpec.h:33
ExceptionResult::BreakInDebugger
@ BreakInDebugger
lldb_private::HostThread::GetNativeThread
HostNativeThread & GetNativeThread()
Definition: HostThread.cpp:32
FileSystem.h
lldb_private::ProcessWindows::m_watchpoint_ids
std::vector< lldb::break_id_t > m_watchpoint_ids
Definition: ProcessWindows.h:119
lldb_private::Process::m_thread_list
ThreadList m_thread_list
The threads for this process as the user will see them.
Definition: Process.h:2848
lldb_private::Address::IsValid
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:345
lldb_private::WindowsLog::Process
@ Process
ModuleSpec.h
lldb_private::HostThread
Definition: HostThread.h:29
lldb_private::HostThreadPosix
Definition: HostThreadPosix.h:16
lldb_private::Target::GetOrCreateModule
lldb::ModuleSP GetOrCreateModule(const ModuleSpec &module_spec, bool notify, Status *error_ptr=nullptr)
Find a binary on the system and return its Module, or return an existing Module that is already in th...
Definition: Target.cpp:2060
lldb_private::Process::GetPrivateState
lldb::StateType GetPrivateState()
Definition: Process.cpp:1410
ExceptionResult::MaskException
@ MaskException
lldb_private::Process::EnableSoftwareBreakpoint
virtual Status EnableSoftwareBreakpoint(BreakpointSite *bp_site)
Definition: Process.cpp:1751
HostProcess.h
lldb_private::ProcessWindows::GetSTDOUT
size_t GetSTDOUT(char *buf, size_t buf_size, Status &error) override
Get any available STDOUT.
Definition: ProcessWindows.cpp:125
lldb_private::DebuggerThreadSP
std::shared_ptr< DebuggerThread > DebuggerThreadSP
Definition: ForwardDecl.h:36
lldb_private::StoppointSite::GetByteSize
uint32_t GetByteSize() const
Definition: StoppointSite.h:31
lldb_private::ProcessWindows::WatchpointInfo
Definition: ProcessWindows.h:111
TargetThreadWindows.h
lldb_private::DynamicLoader::FindPlugin
static DynamicLoader * FindPlugin(Process *process, llvm::StringRef plugin_name)
Find a dynamic loader plugin for a given process.
Definition: DynamicLoader.cpp:32
lldb_private::Process
Definition: Process.h:338
lldb_private::Target::GetExecutableModule
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
Definition: Target.cpp:1357
lldb_private::Process::GetBreakpointSiteList
BreakpointSiteList & GetBreakpointSiteList()
Definition: Process.cpp:1561
Module.h
lldb_private::Process::GetTarget
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1206
lldb_private::ProcessWindows::DoHalt
Status DoHalt(bool &caused_stop) override
Halts a running process.
Definition: ProcessWindows.cpp:261
lldb_private::ThreadList::RefreshStateAfterStop
void RefreshStateAfterStop()
Definition: ThreadList.cpp:459
lldb_private::ProcessWindows::IsAlive
bool IsAlive() override
Check if a process is still alive.
Definition: ProcessWindows.cpp:566
lldb_private::ProcessWindows::DoAttachToProcessWithID
Status DoAttachToProcessWithID(lldb::pid_t pid, const lldb_private::ProcessAttachInfo &attach_info) override
Attach to an existing process using a process ID.
Definition: ProcessWindows.cpp:197
lldb_private::Module
Definition: Module.h:85
lldb_private::ProcessWindows::~ProcessWindows
~ProcessWindows()
Definition: ProcessWindows.cpp:123
lldb_private::ProcessInfo::GetProcessID
lldb::pid_t GetProcessID() const
Definition: ProcessInfo.h:67
lldb_private::StopInfo::CreateStopReasonToTrace
static lldb::StopInfoSP CreateStopReasonToTrace(Thread &thread)
Definition: StopInfo.cpp:1272
lldb_private::ProcessWindows::GetImageInfoAddress
lldb::addr_t GetImageInfoAddress() override
Get the image information address for the current process.
Definition: ProcessWindows.cpp:614
lldb_private::MemoryRegionInfo
Definition: MemoryRegionInfo.h:21
lldb_private::FileSystem::Exists
bool Exists(const FileSpec &file_spec) const
Returns whether the given file exists.
Definition: common/FileSystem.cpp:150
lldb_private::ProcessDebugger::m_mutex
llvm::sys::Mutex m_mutex
Definition: ProcessDebugger.h:97
lldb_private::ProcessDebugger::ReadMemory
Status ReadMemory(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)
Definition: ProcessDebugger.cpp:262
lldb_private::ProcessWindows::OnExitProcess
void OnExitProcess(uint32_t exit_code) override
Definition: ProcessWindows.cpp:631
lldb_private::RegisterContextWindows::DoHardwareBreakpointsTriggerAfter
static constexpr bool DoHardwareBreakpointsTriggerAfter()
Definition: RegisterContextWindows.h:41
lldb_private::Process::SetID
void SetID(lldb::pid_t new_pid)
Sets the stored pid.
Definition: Process.h:540
lldb_private::StoppointSite::GetID
lldb::break_id_t GetID() const
Definition: StoppointSite.h:49
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::ProcessWindows
Definition: ProcessWindows.h:23
pc
@ pc
Definition: CompactUnwindInfo.cpp:1251
lldb_private::Process::SetPrivateState
void SetPrivateState(lldb::StateType state)
Definition: Process.cpp:1412
lldb_private::ProcessWindows::OnDebuggerError
void OnDebuggerError(const Status &error, uint32_t type) override
Definition: ProcessWindows.cpp:815
lldb_private::ProcessWindows::WatchpointInfo::read
bool read
Definition: ProcessWindows.h:115
lldb_private::Target
Definition: Target.h:464
Section.h
lldb_private::DynamicLoaderWindowsDYLD::GetPluginNameStatic
static llvm::StringRef GetPluginNameStatic()
Definition: DynamicLoaderWindowsDYLD.h:27
LLDB_LOGV
#define LLDB_LOGV(log,...)
Definition: Log.h:277
LLDB_PLUGIN_DEFINE_ADV
LLDB_PLUGIN_DEFINE_ADV(ObjectContainerUniversalMachO, ObjectContainerMachOArchive) void ObjectContainerUniversalMachO
Definition: ObjectContainerUniversalMachO.cpp:23
lldb_private::ProcessWindows::GetWatchpointSupportInfo
Status GetWatchpointSupportInfo(uint32_t &num) override
Definition: ProcessWindows.cpp:840
lldb_private::ProcessDebugger::DestroyProcess
Status DestroyProcess(lldb::StateType process_state)
Definition: ProcessDebugger.cpp:211
lldb_private::ProcessWindows::EnableWatchpoint
Status EnableWatchpoint(Watchpoint *wp, bool notify=true) override
Definition: ProcessWindows.cpp:851
lldb::eStateExited
@ eStateExited
Process has exited and can't be examined.
Definition: lldb-enumerations.h:90
lldb_private::ProcessDebugger::DetachProcess
Status DetachProcess()
Definition: ProcessDebugger.cpp:74
lldb_private::ProcessWindows::WatchpointInfo::size
uint32_t size
Definition: ProcessWindows.h:114
lldb_private::ProcessWindows::DisableWatchpoint
Status DisableWatchpoint(Watchpoint *wp, bool notify=true) override
Definition: ProcessWindows.cpp:905
ProcessWindowsLog.h
lldb_private::Watchpoint::SetEnabled
void SetEnabled(bool enabled, bool notify=true)
Definition: Watchpoint.cpp:237
lldb_private::ProcessWindows::OnExitThread
void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) override
Definition: ProcessWindows.cpp:784
lldb_private::ProcessWindows::PutSTDIN
size_t PutSTDIN(const char *buf, size_t buf_size, Status &error) override
Puts data into this process's STDIN.
Definition: ProcessWindows.cpp:135
lldb::eStateStopped
@ eStateStopped
Process or thread is stopped and can be examined.
Definition: lldb-enumerations.h:84
Target.h
lldb_private::Watchpoint::IsEnabled
bool IsEnabled() const
Definition: Watchpoint.cpp:218
lldb_private::ProcessWindows::DisableBreakpointSite
Status DisableBreakpointSite(BreakpointSite *bp_site) override
Definition: ProcessWindows.cpp:155
lldb_private::ProcessWindows::OnLoadDll
void OnLoadDll(const ModuleSpec &module_spec, lldb::addr_t module_addr) override
Definition: ProcessWindows.cpp:802
lldb_private::ProcessDebugger::AttachProcess
Status AttachProcess(lldb::pid_t pid, const ProcessAttachInfo &attach_info, DebugDelegateSP delegate)
Definition: ProcessDebugger.cpp:171
lldb_private::FileSpec
Definition: FileSpec.h:56
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::ProcessWindows::DoUpdateThreadList
bool DoUpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list) override
Update the thread list following process plug-in's specific logic.
Definition: ProcessWindows.cpp:522
lldb_private::ThreadList::SetSelectedThreadByID
bool SetSelectedThreadByID(lldb::tid_t tid, bool notify=false)
Definition: ThreadList.cpp:661
lldb_private::ProcessWindows::DoWriteMemory
size_t DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, Status &error) override
Actually do the writing of memory to a process.
Definition: ProcessWindows.cpp:591
lldb::eStateCrashed
@ eStateCrashed
Process or thread has crashed and can be examined.
Definition: lldb-enumerations.h:88
lldb_private::WindowsLog::Breakpoints
@ Breakpoints
lldb_private::BreakpointSite
Definition: BreakpointSite.h:35
lldb_private::ProcessLaunchInfo
Definition: ProcessLaunchInfo.h:31
Watchpoint.h
lldb_private::ModuleList
Definition: ModuleList.h:81
lldb_private::ProcessWindows::GetDynamicLoader
DynamicLoaderWindowsDYLD * GetDynamicLoader() override
Get the dynamic loader plug-in for this process.
Definition: ProcessWindows.cpp:624
lldb_private::eLoadDependentsNo
@ eLoadDependentsNo
Definition: Target.h:65
MemoryRegionInfo.h
HostNativeProcessBase.h
lldb_private::Process::DisableSoftwareBreakpoint
virtual Status DisableSoftwareBreakpoint(BreakpointSite *bp_site)
Definition: Process.cpp:1827
lldb_private::Thread
Definition: Thread.h:61
lldb_private::RegisterContextWindows::AddHardwareBreakpoint
bool AddHardwareBreakpoint(uint32_t slot, lldb::addr_t address, uint32_t size, bool read, bool write)
Definition: RegisterContextWindows.cpp:76
lldb_private::Watchpoint
Definition: Watchpoint.h:24
lldb_private::Status::Fail
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
ForwardDecl.h
lldb_private::StoppointSite::HardwareRequired
bool HardwareRequired() const
Definition: StoppointSite.h:37
lldb_private::Process::m_dyld_up
lldb::DynamicLoaderUP m_dyld_up
Definition: Process.h:2872
lldb_private::WindowsLog::Thread
@ Thread
lldb_private::ObjectFile::GetImageInfoAddress
virtual lldb_private::Address GetImageInfoAddress(Target *target)
Similar to Process::GetImageInfoAddress().
Definition: ObjectFile.h:477
ExceptionResult
ExceptionResult
Definition: ForwardDecl.h:16
lldb_private::ProcessDebugger::LaunchProcess
Status LaunchProcess(ProcessLaunchInfo &launch_info, DebugDelegateSP delegate)
Definition: ProcessDebugger.cpp:105
lldb_private::ThreadList
Definition: ThreadList.h:26
lldb_private::ExceptionRecord::GetExceptionCode
DWORD GetExceptionCode() const
Definition: ExceptionRecord.h:58
lldb_private::ThreadCollection::Threads
virtual ThreadIterable Threads()
Definition: ThreadCollection.h:46
lldb_private::Process::SetProcessExitStatus
static bool SetProcessExitStatus(lldb::pid_t pid, bool exited, int signo, int status)
Static function that can be used with the host function Host::StartMonitoringChildProcess ().
Definition: Process.cpp:1104
lldb_private::StopInfo::CreateStopReasonWithWatchpointID
static lldb::StopInfoSP CreateStopReasonWithWatchpointID(Thread &thread, lldb::break_id_t watch_id, lldb::addr_t watch_hit_addr=LLDB_INVALID_ADDRESS)
Definition: StopInfo.cpp:1261
lldb_private::ProcessWindows::DoGetMemoryRegionInfo
Status DoGetMemoryRegionInfo(lldb::addr_t vm_addr, MemoryRegionInfo &info) override
DoGetMemoryRegionInfo is called by GetMemoryRegionInfo after it has removed non address bits from loa...
Definition: ProcessWindows.cpp:609
lldb_private::ProcessWindows::DoResume
Status DoResume() override
Resumes all of a process's threads as configured using the Thread run control functions.
Definition: ProcessWindows.cpp:206
lldb_private::Watchpoint::WatchpointRead
bool WatchpointRead() const
Definition: Watchpoint.cpp:265
lldb::eStateDetached
@ eStateDetached
Process has been detached and can't be examined.
Definition: lldb-enumerations.h:89
lldb_private::ProcessWindows::GetSTDERR
size_t GetSTDERR(char *buf, size_t buf_size, Status &error) override
Get any available STDERR.
Definition: ProcessWindows.cpp:130
ExceptionResult::SendToApplication
@ SendToApplication
lldb_private::RegisterContextWindows
Definition: RegisterContextWindows.h:19
lldb_private::ProcessWindows::OnCreateThread
void OnCreateThread(const HostThread &thread) override
Definition: ProcessWindows.cpp:764
HostInfo.h
lldb_private::DebugDelegateSP
std::shared_ptr< IDebugDelegate > DebugDelegateSP
Definition: ForwardDecl.h:33
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::ThreadList::GetThreadAtIndex
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
Definition: ThreadList.cpp:91
lldb_private::FileSystem::Resolve
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
Definition: common/FileSystem.cpp:235
lldb_private::LocalDebugDelegate
Definition: LocalDebugDelegate.h:41
lldb_private::WindowsLog::Exception
@ Exception
lldb_private::ProcessWindows::RefreshStateAfterStop
void RefreshStateAfterStop() override
Currently called as part of ShouldStop.
Definition: ProcessWindows.cpp:352
ExceptionRecord.h
lldb_private::ProcessWindows::DoDeallocateMemory
Status DoDeallocateMemory(lldb::addr_t ptr) override
Actually deallocate memory in the process.
Definition: ProcessWindows.cpp:605
lldb::eStateUnloaded
@ eStateUnloaded
Process is object is valid, but not currently loaded.
Definition: lldb-enumerations.h:75
lldb_private::ProcessAttachInfo
Definition: Process.h:113
ObjectFile.h
lldb_private::ProcessWindows::DidLaunch
void DidLaunch() override
Called after launching a process.
Definition: ProcessWindows.cpp:269
lldb_private::UserID::GetID
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47
lldb_private::ExceptionRecord::GetExceptionAddress
lldb::addr_t GetExceptionAddress() const
Definition: ExceptionRecord.h:63
lldb_private::Target::SetExecutableModule
void SetExecutableModule(lldb::ModuleSP &module_sp, LoadDependentFiles load_dependent_files=eLoadDependentsDefault)
Set the main executable module.
Definition: Target.cpp:1406
lldb_private::ShouldUseLLDBServer
static bool ShouldUseLLDBServer()
Definition: ProcessWindows.cpp:88
DebuggerThread.h
LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
lldb_private::Process::CalculateTarget
lldb::TargetSP CalculateTarget() override
Definition: Process.cpp:4176
lldb_private::ProcessDebugger::DeallocateMemory
Status DeallocateMemory(lldb::addr_t addr)
Definition: ProcessDebugger.cpp:355
lldb_private::ProcessWindows::GetSystemArchitecture
ArchSpec GetSystemArchitecture() override
Get the system architecture for this process.
Definition: ProcessWindows.cpp:580
lldb_private::ModuleSpec
Definition: ModuleSpec.h:27
lldb_private::ProcessWindows::OnDebuggerConnected
void OnDebuggerConnected(lldb::addr_t image_base) override
Definition: ProcessWindows.cpp:650
lldb_private::Status
Definition: Status.h:44
uint32_t
lldb_private::Address
Definition: Address.h:59
id
void * id
Definition: PlatformiOSSimulatorCoreSimulatorSupport.h:20
lldb::pid_t
uint64_t pid_t
Definition: lldb-types.h:85
lldb_private::RegisterContextWindows::RemoveHardwareBreakpoint
bool RemoveHardwareBreakpoint(uint32_t slot)
Definition: RegisterContextWindows.cpp:121
lldb_private::ProcessWindows::m_watchpoints
std::map< lldb::break_id_t, WatchpointInfo > m_watchpoints
Definition: ProcessWindows.h:118
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
lldb_private::ThreadList::GetSize
uint32_t GetSize(bool can_update=true)
Definition: ThreadList.cpp:83
StopInfo.h
windows.h
lldb_private::ProcessWindows::CanDebug
bool CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name) override
Check if a plug-in instance can debug the file in module.
Definition: ProcessWindows.cpp:508
PluginManager.h
lldb_private::ProcessWindows::DoDetach
Status DoDetach(bool keep_stopped) override
Detaches from a running or stopped process.
Definition: ProcessWindows.cpp:167
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::Process::GetID
lldb::pid_t GetID() const
Returns the pid of the process or LLDB_INVALID_PROCESS_ID if there is no known pid.
Definition: Process.h:535
lldb_private::ProcessWindows::DoDestroy
Status DoDestroy() override
Definition: ProcessWindows.cpp:256
lldb_private::FileSystem::Instance
static FileSystem & Instance()
Definition: common/FileSystem.cpp:46
lldb_private::ProcessWindows::DoAllocateMemory
lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions, Status &error) override
Actually allocate memory in the process.
Definition: ProcessWindows.cpp:598
lldb_private::ProcessDebugger::HaltProcess
Status HaltProcess(bool &caused_stop)
Definition: ProcessDebugger.cpp:247
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::ProcessDebugger::AllocateMemory
Status AllocateMemory(size_t size, uint32_t permissions, lldb::addr_t &addr)
Definition: ProcessDebugger.cpp:326
lldb_private::ProcessWindows::OnDebugException
ExceptionResult OnDebugException(bool first_chance, const ExceptionRecord &record) override
Definition: ProcessWindows.cpp:698
lldb::eStateInvalid
@ eStateInvalid
Definition: lldb-enumerations.h:74
lldb_private::ProcessWindows::WatchpointInfo::slot_id
uint32_t slot_id
Definition: ProcessWindows.h:112
State.h
lldb_private::ThreadCollection::AddThread
void AddThread(const lldb::ThreadSP &thread_sp)
Definition: ThreadCollection.cpp:24
LLDB_INVALID_INDEX32
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:75
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:73
lldb_private::StopInfo::CreateStopReasonWithBreakpointSiteID
static lldb::StopInfoSP CreateStopReasonWithBreakpointSiteID(Thread &thread, lldb::break_id_t break_id)
Definition: StopInfo.cpp:1249
lldb_private::Log
Definition: Log.h:48
lldb_private::DynamicLoaderWindowsDYLD
Definition: DynamicLoaderWindowsDYLD.h:19
lldb_private::ProcessWindows::WatchpointInfo::write
bool write
Definition: ProcessWindows.h:116
lldb_private::Thread::GetRegisterContext
virtual lldb::RegisterContextSP GetRegisterContext()=0
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::RegisterContextWindows::GetNumHardwareBreakpointSlots
static constexpr uint32_t GetNumHardwareBreakpointSlots()
Definition: RegisterContextWindows.h:38
lldb_private::DumpAdditionalExceptionInformation
static void DumpAdditionalExceptionInformation(llvm::raw_ostream &stream, const ExceptionRecordSP &exception)
Definition: ProcessWindows.cpp:285
lldb_private::ThreadList::GetSelectedThread
lldb::ThreadSP GetSelectedThread()
Definition: ThreadList.cpp:649
lldb_private::StopInfo::CreateStopReasonWithException
static lldb::StopInfoSP CreateStopReasonWithException(Thread &thread, const char *description)
Definition: StopInfo.cpp:1283
lldb_private::ExceptionRecordSP
std::shared_ptr< ExceptionRecord > ExceptionRecordSP
Definition: ForwardDecl.h:37
LocalDebugDelegate.h
DynamicLoader.h
lldb
Definition: SBAddress.h:15
lldb_private::ProcessDebugger::WriteMemory
Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written)
Definition: ProcessDebugger.cpp:296
lldb::eStateRunning
@ eStateRunning
Process or thread is running and can't be examined.
Definition: lldb-enumerations.h:85
lldb_private::ProcessDebugger::m_session_data
std::unique_ptr< ProcessWindowsData > m_session_data
Definition: ProcessDebugger.h:98
lldb_private::ProcessDebugger::OnExitProcess
virtual void OnExitProcess(uint32_t exit_code)
Definition: ProcessDebugger.cpp:472
lldb_private::Watchpoint::WatchpointWrite
bool WatchpointWrite() const
Definition: Watchpoint.cpp:267
HostThreadWindows.h
lldb_private::ObjectFile
Definition: ObjectFile.h:60
lldb_private::ModuleList::Append
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
lldb_private::ProcessDebugger::GetMemoryRegionInfo
Status GetMemoryRegionInfo(lldb::addr_t load_addr, MemoryRegionInfo &range_info)
Definition: ProcessDebugger.cpp:380
lldb_private::ExceptionRecord
Definition: ExceptionRecord.h:25
lldb_private::ProcessWindows::DoLaunch
Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override
Launch a new process.
Definition: ProcessWindows.cpp:186
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86
lldb_private::ProcessWindows::WatchpointInfo::address
lldb::addr_t address
Definition: ProcessWindows.h:113
lldb_private::ProcessWindows::EnableBreakpointSite
Status EnableBreakpointSite(BreakpointSite *bp_site) override
Definition: ProcessWindows.cpp:141
lldb_private::ProcessWindows::OnUnloadDll
void OnUnloadDll(lldb::addr_t module_addr) override
Definition: ProcessWindows.cpp:808