LLDB  mainline
ProcessDebugger.cpp
Go to the documentation of this file.
1 //===-- ProcessDebugger.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 "ProcessDebugger.h"
10 
11 // Windows includes
13 #include <psapi.h>
14 
15 #include "lldb/Host/FileSystem.h"
17 #include "lldb/Host/HostProcess.h"
18 #include "lldb/Host/HostThread.h"
21 #include "lldb/Target/Process.h"
22 #include "llvm/Support/ConvertUTF.h"
23 #include "llvm/Support/Error.h"
24 
25 #include "DebuggerThread.h"
26 #include "ExceptionRecord.h"
27 #include "ProcessWindowsLog.h"
28 
29 using namespace lldb;
30 using namespace lldb_private;
31 
32 static DWORD ConvertLldbToWinApiProtect(uint32_t protect) {
33  // We also can process a read / write permissions here, but if the debugger
34  // will make later a write into the allocated memory, it will fail. To get
35  // around it is possible inside DoWriteMemory to remember memory permissions,
36  // allow write, write and restore permissions, but for now we process only
37  // the executable permission.
38  //
39  // TODO: Process permissions other than executable
40  if (protect & ePermissionsExecutable)
41  return PAGE_EXECUTE_READWRITE;
42 
43  return PAGE_READWRITE;
44 }
45 
46 // The Windows page protection bits are NOT independent masks that can be
47 // bitwise-ORed together. For example, PAGE_EXECUTE_READ is not (PAGE_EXECUTE
48 // | PAGE_READ). To test for an access type, it's necessary to test for any of
49 // the bits that provide that access type.
50 static bool IsPageReadable(uint32_t protect) {
51  return (protect & PAGE_NOACCESS) == 0;
52 }
53 
54 static bool IsPageWritable(uint32_t protect) {
55  return (protect & (PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY |
56  PAGE_READWRITE | PAGE_WRITECOPY)) != 0;
57 }
58 
59 static bool IsPageExecutable(uint32_t protect) {
60  return (protect & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE |
61  PAGE_EXECUTE_WRITECOPY)) != 0;
62 }
63 
64 namespace lldb_private {
65 
66 ProcessDebugger::~ProcessDebugger() {}
67 
68 lldb::pid_t ProcessDebugger::GetDebuggedProcessId() const {
69  if (m_session_data)
70  return m_session_data->m_debugger->GetProcess().GetProcessId();
72 }
73 
74 Status ProcessDebugger::DetachProcess() {
75  Log *log = GetLog(WindowsLog::Process);
76  DebuggerThreadSP debugger_thread;
77  {
78  // Acquire the lock only long enough to get the DebuggerThread.
79  // StopDebugging() will trigger a call back into ProcessDebugger which will
80  // also acquire the lock. Thus we have to release the lock before calling
81  // StopDebugging().
82  llvm::sys::ScopedLock lock(m_mutex);
83 
84  if (!m_session_data) {
85  LLDB_LOG(log, "there is no active session.");
86  return Status();
87  }
88 
89  debugger_thread = m_session_data->m_debugger;
90  }
91 
92  Status error;
93 
94  LLDB_LOG(log, "detaching from process {0}.",
95  debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle());
96  error = debugger_thread->StopDebugging(false);
97 
98  // By the time StopDebugging returns, there is no more debugger thread, so
99  // we can be assured that no other thread will race for the session data.
100  m_session_data.reset();
101 
102  return error;
103 }
104 
105 Status ProcessDebugger::LaunchProcess(ProcessLaunchInfo &launch_info,
106  DebugDelegateSP delegate) {
107  // Even though m_session_data is accessed here, it is before a debugger
108  // thread has been kicked off. So there's no race conditions, and it
109  // shouldn't be necessary to acquire the mutex.
110 
111  Log *log = GetLog(WindowsLog::Process);
112  Status result;
113 
114  FileSpec working_dir = launch_info.GetWorkingDirectory();
115  namespace fs = llvm::sys::fs;
116  if (working_dir) {
117  FileSystem::Instance().Resolve(working_dir);
118  if (!FileSystem::Instance().IsDirectory(working_dir)) {
119  result.SetErrorStringWithFormat("No such file or directory: %s",
120  working_dir.GetPath().c_str());
121  return result;
122  }
123  }
124 
125  if (!launch_info.GetFlags().Test(eLaunchFlagDebug)) {
126  StreamString stream;
127  stream.Printf("ProcessDebugger unable to launch '%s'. ProcessDebugger can "
128  "only be used for debug launches.",
129  launch_info.GetExecutableFile().GetPath().c_str());
130  std::string message = stream.GetString().str();
131  result.SetErrorString(message.c_str());
132 
133  LLDB_LOG(log, "error: {0}", message);
134  return result;
135  }
136 
137  bool stop_at_entry = launch_info.GetFlags().Test(eLaunchFlagStopAtEntry);
138  m_session_data.reset(new ProcessWindowsData(stop_at_entry));
139  m_session_data->m_debugger.reset(new DebuggerThread(delegate));
140  DebuggerThreadSP debugger = m_session_data->m_debugger;
141 
142  // Kick off the DebugLaunch asynchronously and wait for it to complete.
143  result = debugger->DebugLaunch(launch_info);
144  if (result.Fail()) {
145  LLDB_LOG(log, "failed launching '{0}'. {1}",
146  launch_info.GetExecutableFile().GetPath(), result);
147  return result;
148  }
149 
150  HostProcess process;
151  Status error = WaitForDebuggerConnection(debugger, process);
152  if (error.Fail()) {
153  LLDB_LOG(log, "failed launching '{0}'. {1}",
154  launch_info.GetExecutableFile().GetPath(), error);
155  return error;
156  }
157 
158  LLDB_LOG(log, "successfully launched '{0}'",
159  launch_info.GetExecutableFile().GetPath());
160 
161  // We've hit the initial stop. If eLaunchFlagsStopAtEntry was specified, the
162  // private state should already be set to eStateStopped as a result of
163  // hitting the initial breakpoint. If it was not set, the breakpoint should
164  // have already been resumed from and the private state should already be
165  // eStateRunning.
166  launch_info.SetProcessID(process.GetProcessId());
167 
168  return result;
169 }
170 
171 Status ProcessDebugger::AttachProcess(lldb::pid_t pid,
172  const ProcessAttachInfo &attach_info,
173  DebugDelegateSP delegate) {
174  Log *log = GetLog(WindowsLog::Process);
175  m_session_data.reset(
176  new ProcessWindowsData(!attach_info.GetContinueOnceAttached()));
177  DebuggerThreadSP debugger(new DebuggerThread(delegate));
178 
179  m_session_data->m_debugger = debugger;
180 
181  DWORD process_id = static_cast<DWORD>(pid);
182  Status error = debugger->DebugAttach(process_id, attach_info);
183  if (error.Fail()) {
184  LLDB_LOG(
185  log,
186  "encountered an error occurred initiating the asynchronous attach. {0}",
187  error);
188  return error;
189  }
190 
191  HostProcess process;
192  error = WaitForDebuggerConnection(debugger, process);
193  if (error.Fail()) {
194  LLDB_LOG(log,
195  "encountered an error waiting for the debugger to connect. {0}",
196  error);
197  return error;
198  }
199 
200  LLDB_LOG(log, "successfully attached to process with pid={0}", process_id);
201 
202  // We've hit the initial stop. If eLaunchFlagsStopAtEntry was specified, the
203  // private state should already be set to eStateStopped as a result of
204  // hitting the initial breakpoint. If it was not set, the breakpoint should
205  // have already been resumed from and the private state should already be
206  // eStateRunning.
207 
208  return error;
209 }
210 
211 Status ProcessDebugger::DestroyProcess(const lldb::StateType state) {
212  Log *log = GetLog(WindowsLog::Process);
213  DebuggerThreadSP debugger_thread;
214  {
215  // Acquire this lock inside an inner scope, only long enough to get the
216  // DebuggerThread. StopDebugging() will trigger a call back into
217  // ProcessDebugger which will acquire the lock again, so we need to not
218  // deadlock.
219  llvm::sys::ScopedLock lock(m_mutex);
220 
221  if (!m_session_data) {
222  LLDB_LOG(log, "warning: state = {0}, but there is no active session.",
223  state);
224  return Status();
225  }
226 
227  debugger_thread = m_session_data->m_debugger;
228  }
229 
230  if (state == eStateExited || state == eStateDetached) {
231  LLDB_LOG(log, "warning: cannot destroy process {0} while state = {1}.",
232  GetDebuggedProcessId(), state);
233  return Status();
234  }
235 
236  LLDB_LOG(log, "Shutting down process {0}.",
237  debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle());
238  auto error = debugger_thread->StopDebugging(true);
239 
240  // By the time StopDebugging returns, there is no more debugger thread, so
241  // we can be assured that no other thread will race for the session data.
242  m_session_data.reset();
243 
244  return error;
245 }
246 
247 Status ProcessDebugger::HaltProcess(bool &caused_stop) {
248  Log *log = GetLog(WindowsLog::Process);
249  Status error;
250  llvm::sys::ScopedLock lock(m_mutex);
251  caused_stop = ::DebugBreakProcess(m_session_data->m_debugger->GetProcess()
252  .GetNativeProcess()
253  .GetSystemHandle());
254  if (!caused_stop) {
255  error.SetError(::GetLastError(), eErrorTypeWin32);
256  LLDB_LOG(log, "DebugBreakProcess failed with error {0}", error);
257  }
258 
259  return error;
260 }
261 
262 Status ProcessDebugger::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
263  size_t &bytes_read) {
264  Status error;
265  bytes_read = 0;
266  Log *log = GetLog(WindowsLog::Memory);
267  llvm::sys::ScopedLock lock(m_mutex);
268 
269  if (!m_session_data) {
270  error.SetErrorString(
271  "cannot read, there is no active debugger connection.");
272  LLDB_LOG(log, "error: {0}", error);
273  return error;
274  }
275 
276  LLDB_LOG(log, "attempting to read {0} bytes from address {1:x}", size,
277  vm_addr);
278 
279  HostProcess process = m_session_data->m_debugger->GetProcess();
280  void *addr = reinterpret_cast<void *>(vm_addr);
281  SIZE_T num_of_bytes_read = 0;
282  if (!::ReadProcessMemory(process.GetNativeProcess().GetSystemHandle(), addr,
283  buf, size, &num_of_bytes_read)) {
284  error.SetError(GetLastError(), eErrorTypeWin32);
285  LLDB_LOG(log, "reading failed with error: {0}", error);
286  } else {
287  bytes_read = num_of_bytes_read;
288  }
289  return error;
290 }
291 
292 Status ProcessDebugger::WriteMemory(lldb::addr_t vm_addr, const void *buf,
293  size_t size, size_t &bytes_written) {
294  Status error;
295  bytes_written = 0;
296  Log *log = GetLog(WindowsLog::Memory);
297  llvm::sys::ScopedLock lock(m_mutex);
298  LLDB_LOG(log, "attempting to write {0} bytes into address {1:x}", size,
299  vm_addr);
300 
301  if (!m_session_data) {
302  error.SetErrorString(
303  "cannot write, there is no active debugger connection.");
304  LLDB_LOG(log, "error: {0}", error);
305  return error;
306  }
307 
308  HostProcess process = m_session_data->m_debugger->GetProcess();
309  void *addr = reinterpret_cast<void *>(vm_addr);
310  SIZE_T num_of_bytes_written = 0;
311  lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
312  if (::WriteProcessMemory(handle, addr, buf, size, &num_of_bytes_written)) {
313  FlushInstructionCache(handle, addr, num_of_bytes_written);
314  bytes_written = num_of_bytes_written;
315  } else {
316  error.SetError(GetLastError(), eErrorTypeWin32);
317  LLDB_LOG(log, "writing failed with error: {0}", error);
318  }
319  return error;
320 }
321 
322 Status ProcessDebugger::AllocateMemory(size_t size, uint32_t permissions,
323  lldb::addr_t &addr) {
324  Status error;
325  addr = LLDB_INVALID_ADDRESS;
326  Log *log = GetLog(WindowsLog::Memory);
327  llvm::sys::ScopedLock lock(m_mutex);
328  LLDB_LOG(log, "attempting to allocate {0} bytes with permissions {1}", size,
329  permissions);
330 
331  if (!m_session_data) {
332  error.SetErrorString(
333  "cannot allocate, there is no active debugger connection");
334  LLDB_LOG(log, "error: {0}", error);
335  return error;
336  }
337 
338  HostProcess process = m_session_data->m_debugger->GetProcess();
339  lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
340  auto protect = ConvertLldbToWinApiProtect(permissions);
341  auto result = ::VirtualAllocEx(handle, nullptr, size, MEM_COMMIT, protect);
342  if (!result) {
343  error.SetError(GetLastError(), eErrorTypeWin32);
344  LLDB_LOG(log, "allocating failed with error: {0}", error);
345  } else {
346  addr = reinterpret_cast<addr_t>(result);
347  }
348  return error;
349 }
350 
351 Status ProcessDebugger::DeallocateMemory(lldb::addr_t vm_addr) {
352  Status result;
353 
354  Log *log = GetLog(WindowsLog::Memory);
355  llvm::sys::ScopedLock lock(m_mutex);
356  LLDB_LOG(log, "attempting to deallocate bytes at address {0}", vm_addr);
357 
358  if (!m_session_data) {
359  result.SetErrorString(
360  "cannot deallocate, there is no active debugger connection");
361  LLDB_LOG(log, "error: {0}", result);
362  return result;
363  }
364 
365  HostProcess process = m_session_data->m_debugger->GetProcess();
366  lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
367  if (!::VirtualFreeEx(handle, reinterpret_cast<LPVOID>(vm_addr), 0,
368  MEM_RELEASE)) {
369  result.SetError(GetLastError(), eErrorTypeWin32);
370  LLDB_LOG(log, "deallocating failed with error: {0}", result);
371  }
372 
373  return result;
374 }
375 
376 Status ProcessDebugger::GetMemoryRegionInfo(lldb::addr_t vm_addr,
377  MemoryRegionInfo &info) {
378  Log *log = GetLog(WindowsLog::Memory);
379  Status error;
380  llvm::sys::ScopedLock lock(m_mutex);
381  info.Clear();
382 
383  if (!m_session_data) {
384  error.SetErrorString(
385  "GetMemoryRegionInfo called with no debugging session.");
386  LLDB_LOG(log, "error: {0}", error);
387  return error;
388  }
389  HostProcess process = m_session_data->m_debugger->GetProcess();
390  lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
391  if (handle == nullptr || handle == LLDB_INVALID_PROCESS) {
392  error.SetErrorString(
393  "GetMemoryRegionInfo called with an invalid target process.");
394  LLDB_LOG(log, "error: {0}", error);
395  return error;
396  }
397 
398  LLDB_LOG(log, "getting info for address {0:x}", vm_addr);
399 
400  void *addr = reinterpret_cast<void *>(vm_addr);
401  MEMORY_BASIC_INFORMATION mem_info = {};
402  SIZE_T result = ::VirtualQueryEx(handle, addr, &mem_info, sizeof(mem_info));
403  if (result == 0) {
404  DWORD last_error = ::GetLastError();
405  if (last_error == ERROR_INVALID_PARAMETER) {
406  // ERROR_INVALID_PARAMETER is returned if VirtualQueryEx is called with
407  // an address past the highest accessible address. We should return a
408  // range from the vm_addr to LLDB_INVALID_ADDRESS
409  info.GetRange().SetRangeBase(vm_addr);
411  info.SetReadable(MemoryRegionInfo::eNo);
412  info.SetExecutable(MemoryRegionInfo::eNo);
413  info.SetWritable(MemoryRegionInfo::eNo);
414  info.SetMapped(MemoryRegionInfo::eNo);
415  return error;
416  } else {
417  error.SetError(last_error, eErrorTypeWin32);
418  LLDB_LOG(log,
419  "VirtualQueryEx returned error {0} while getting memory "
420  "region info for address {1:x}",
421  error, vm_addr);
422  return error;
423  }
424  }
425 
426  // Protect bits are only valid for MEM_COMMIT regions.
427  if (mem_info.State == MEM_COMMIT) {
428  const bool readable = IsPageReadable(mem_info.Protect);
429  const bool executable = IsPageExecutable(mem_info.Protect);
430  const bool writable = IsPageWritable(mem_info.Protect);
431  info.SetReadable(readable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
432  info.SetExecutable(executable ? MemoryRegionInfo::eYes
433  : MemoryRegionInfo::eNo);
434  info.SetWritable(writable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
435  } else {
436  info.SetReadable(MemoryRegionInfo::eNo);
437  info.SetExecutable(MemoryRegionInfo::eNo);
438  info.SetWritable(MemoryRegionInfo::eNo);
439  }
440 
441  // AllocationBase is defined for MEM_COMMIT and MEM_RESERVE but not MEM_FREE.
442  if (mem_info.State != MEM_FREE) {
443  info.GetRange().SetRangeBase(
444  reinterpret_cast<addr_t>(mem_info.BaseAddress));
445  info.GetRange().SetRangeEnd(reinterpret_cast<addr_t>(mem_info.BaseAddress) +
446  mem_info.RegionSize);
447  info.SetMapped(MemoryRegionInfo::eYes);
448  } else {
449  // In the unmapped case we need to return the distance to the next block of
450  // memory. VirtualQueryEx nearly does that except that it gives the
451  // distance from the start of the page containing vm_addr.
452  SYSTEM_INFO data;
453  ::GetSystemInfo(&data);
454  DWORD page_offset = vm_addr % data.dwPageSize;
455  info.GetRange().SetRangeBase(vm_addr);
456  info.GetRange().SetByteSize(mem_info.RegionSize - page_offset);
457  info.SetMapped(MemoryRegionInfo::eNo);
458  }
459 
460  LLDB_LOGV(log,
461  "Memory region info for address {0}: readable={1}, "
462  "executable={2}, writable={3}",
463  vm_addr, info.GetReadable(), info.GetExecutable(),
464  info.GetWritable());
465  return error;
466 }
467 
468 void ProcessDebugger::OnExitProcess(uint32_t exit_code) {
469  // If the process exits before any initial stop then notify the debugger
470  // of the error otherwise WaitForDebuggerConnection() will be blocked.
471  // An example of this issue is when a process fails to load a dependent DLL.
472  if (m_session_data && !m_session_data->m_initial_stop_received) {
473  Status error(exit_code, eErrorTypeWin32);
474  OnDebuggerError(error, 0);
475  }
476 }
477 
478 void ProcessDebugger::OnDebuggerConnected(lldb::addr_t image_base) {}
479 
481 ProcessDebugger::OnDebugException(bool first_chance,
482  const ExceptionRecord &record) {
483  Log *log = GetLog(WindowsLog::Exception);
484  llvm::sys::ScopedLock lock(m_mutex);
485  // FIXME: Without this check, occasionally when running the test suite
486  // there is an issue where m_session_data can be null. It's not clear how
487  // this could happen but it only surfaces while running the test suite. In
488  // order to properly diagnose this, we probably need to first figure allow the
489  // test suite to print out full lldb logs, and then add logging to the process
490  // plugin.
491  if (!m_session_data) {
492  LLDB_LOG(log,
493  "Debugger thread reported exception {0:x} at address {1:x}, but "
494  "there is no session.",
495  record.GetExceptionCode(), record.GetExceptionAddress());
497  }
498 
500  if ((record.GetExceptionCode() == EXCEPTION_BREAKPOINT ||
501  record.GetExceptionCode() ==
502  0x4000001FL /*WOW64 STATUS_WX86_BREAKPOINT*/) &&
503  !m_session_data->m_initial_stop_received) {
504  // Handle breakpoints at the first chance.
506  LLDB_LOG(
507  log,
508  "Hit loader breakpoint at address {0:x}, setting initial stop event.",
509  record.GetExceptionAddress());
510  m_session_data->m_initial_stop_received = true;
511  ::SetEvent(m_session_data->m_initial_stop_event);
512  }
513  return result;
514 }
515 
516 void ProcessDebugger::OnCreateThread(const HostThread &thread) {
517  // Do nothing by default
518 }
519 
520 void ProcessDebugger::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) {
521  // Do nothing by default
522 }
523 
524 void ProcessDebugger::OnLoadDll(const ModuleSpec &module_spec,
525  lldb::addr_t module_addr) {
526  // Do nothing by default
527 }
528 
529 void ProcessDebugger::OnUnloadDll(lldb::addr_t module_addr) {
530  // Do nothing by default
531 }
532 
533 void ProcessDebugger::OnDebugString(const std::string &string) {}
534 
535 void ProcessDebugger::OnDebuggerError(const Status &error, uint32_t type) {
536  llvm::sys::ScopedLock lock(m_mutex);
537  Log *log = GetLog(WindowsLog::Process);
538 
539  if (m_session_data->m_initial_stop_received) {
540  // This happened while debugging. Do we shutdown the debugging session,
541  // try to continue, or do something else?
542  LLDB_LOG(log,
543  "Error {0} occurred during debugging. Unexpected behavior "
544  "may result. {1}",
545  error.GetError(), error);
546  } else {
547  // If we haven't actually launched the process yet, this was an error
548  // launching the process. Set the internal error and signal the initial
549  // stop event so that the DoLaunch method wakes up and returns a failure.
550  m_session_data->m_launch_error = error;
551  ::SetEvent(m_session_data->m_initial_stop_event);
552  LLDB_LOG(log,
553  "Error {0} occurred launching the process before the initial "
554  "stop. {1}",
555  error.GetError(), error);
556  return;
557  }
558 }
559 
560 Status ProcessDebugger::WaitForDebuggerConnection(DebuggerThreadSP debugger,
561  HostProcess &process) {
562  Status result;
563  Log *log = GetLog(WindowsLog::Process | WindowsLog::Breakpoints);
564  LLDB_LOG(log, "Waiting for loader breakpoint.");
565 
566  // Block this function until we receive the initial stop from the process.
567  if (::WaitForSingleObject(m_session_data->m_initial_stop_event, INFINITE) ==
568  WAIT_OBJECT_0) {
569  LLDB_LOG(log, "hit loader breakpoint, returning.");
570 
571  process = debugger->GetProcess();
572  return m_session_data->m_launch_error;
573  } else
574  return Status(::GetLastError(), eErrorTypeWin32);
575 }
576 
577 } // namespace lldb_private
lldb_private::HostProcess
Definition: HostProcess.h:33
lldb_private::Status::SetError
int void SetError(ValueType err, lldb::ErrorType type)
Set accessor with an error value and type.
Definition: Status.cpp:216
ExceptionResult::BreakInDebugger
@ BreakInDebugger
FileSystem.h
LLDB_INVALID_PROCESS_ID
#define LLDB_INVALID_PROCESS_ID
Definition: lldb-defines.h:81
lldb_private::HostThread
Definition: HostThread.h:29
lldb_private::ProcessAttachInfo::GetContinueOnceAttached
bool GetContinueOnceAttached() const
Definition: Process.h:141
ProcessLaunchInfo.h
HostProcess.h
lldb_private::DebuggerThreadSP
std::shared_ptr< DebuggerThread > DebuggerThreadSP
Definition: ForwardDecl.h:36
lldb_private::MemoryRegionInfo::Clear
void Clear()
Definition: MemoryRegionInfo.h:40
lldb_private::Flags::Test
bool Test(ValueType bit) const
Test a single flag bit.
Definition: Flags.h:96
lldb_private::MemoryRegionInfo
Definition: MemoryRegionInfo.h:21
lldb_private::ProcessLaunchInfo::GetFlags
Flags & GetFlags()
Definition: ProcessLaunchInfo.h:64
lldb_private::ProcessInfo::SetProcessID
void SetProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:68
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::MemoryRegionInfo::SetReadable
void SetReadable(OptionalBool val)
Definition: MemoryRegionInfo.h:58
LLDB_LOGV
#define LLDB_LOGV(log,...)
Definition: Log.h:351
lldb::eErrorTypeWin32
@ eErrorTypeWin32
Standard Win32 error codes.
Definition: lldb-enumerations.h:313
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb::eStateExited
@ eStateExited
Process has exited and can't be examined.
Definition: lldb-enumerations.h:91
Process.h
ProcessWindowsLog.h
lldb_private::MemoryRegionInfo::GetWritable
OptionalBool GetWritable() const
Definition: MemoryRegionInfo.h:46
lldb_private::FileSpec
Definition: FileSpec.h:55
ConvertLldbToWinApiProtect
static DWORD ConvertLldbToWinApiProtect(uint32_t protect)
Definition: ProcessDebugger.cpp:32
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::Range::SetRangeEnd
void SetRangeEnd(BaseType end)
Definition: RangeMap.h:80
HostThread.h
lldb_private::MemoryRegionInfo::GetExecutable
OptionalBool GetExecutable() const
Definition: MemoryRegionInfo.h:48
lldb_private::ProcessLaunchInfo
Definition: ProcessLaunchInfo.h:31
MemoryRegionInfo.h
HostNativeProcessBase.h
lldb_private::MemoryRegionInfo::SetExecutable
void SetExecutable(OptionalBool val)
Definition: MemoryRegionInfo.h:62
lldb_private::Status::Fail
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
lldb_private::Status::SetErrorStringWithFormat
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
ExceptionResult
ExceptionResult
Definition: ForwardDecl.h:16
lldb_private::ExceptionRecord::GetExceptionCode
DWORD GetExceptionCode() const
Definition: ExceptionRecord.h:56
lldb_private::StreamString
Definition: StreamString.h:23
LLDB_INVALID_PROCESS
#define LLDB_INVALID_PROCESS
Definition: lldb-types.h:78
lldb::eStateDetached
@ eStateDetached
Process has been detached and can't be examined.
Definition: lldb-enumerations.h:90
ExceptionResult::SendToApplication
@ SendToApplication
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::ProcessLaunchInfo::GetWorkingDirectory
const FileSpec & GetWorkingDirectory() const
Definition: ProcessLaunchInfo.cpp:123
lldb_private::HostProcess::GetProcessId
lldb::pid_t GetProcessId() const
Definition: HostProcess.cpp:25
ExceptionRecord.h
IsPageExecutable
static bool IsPageExecutable(uint32_t protect)
Definition: ProcessDebugger.cpp:59
IsPageReadable
static bool IsPageReadable(uint32_t protect)
Definition: ProcessDebugger.cpp:50
lldb_private::HostProcess::GetNativeProcess
HostNativeProcessBase & GetNativeProcess()
Definition: HostProcess.cpp:36
IsPageWritable
static bool IsPageWritable(uint32_t protect)
Definition: ProcessDebugger.cpp:54
lldb_private::ProcessAttachInfo
Definition: Process.h:113
lldb_private::ExceptionRecord::GetExceptionAddress
lldb::addr_t GetExceptionAddress() const
Definition: ExceptionRecord.h:58
DebuggerThread.h
lldb_private::MemoryRegionInfo::SetWritable
void SetWritable(OptionalBool val)
Definition: MemoryRegionInfo.h:60
lldb_private::DebuggerThread
Definition: DebuggerThread.h:27
lldb_private::ModuleSpec
Definition: ModuleSpec.h:27
lldb_private::Status
Definition: Status.h:44
message
message(FATAL_ERROR "invalid libipt include path provided") endif() include_directories($
Definition: Plugins/Trace/intel-pt/CMakeLists.txt:6
uint32_t
lldb::pid_t
uint64_t pid_t
Definition: lldb-types.h:85
lldb_private::MemoryRegionInfo::SetMapped
void SetMapped(OptionalBool val)
Definition: MemoryRegionInfo.h:66
lldb::process_t
uint64_t process_t
Definition: lldb-types.h:57
lldb_private::Status::SetErrorString
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
lldb_private::Range::SetRangeBase
void SetRangeBase(BaseType b)
Definition: RangeMap.h:48
lldb_private::ProcessWindowsData
Definition: ProcessDebugger.h:30
lldb_private::Range::SetByteSize
void SetByteSize(SizeType s)
Definition: RangeMap.h:89
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:337
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::MemoryRegionInfo::GetRange
RangeType & GetRange()
Definition: MemoryRegionInfo.h:38
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::ProcessInfo::GetExecutableFile
FileSpec & GetExecutableFile()
Definition: ProcessInfo.h:41
ProcessDebugger.h
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:74
lldb_private::Log
Definition: Log.h:115
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:364
lldb_private::HostNativeProcessBase::GetSystemHandle
lldb::process_t GetSystemHandle() const
Definition: HostNativeProcessBase.h:37
ReadProcessMemory
static int ReadProcessMemory(uint8_t *buffer, size_t size, const pt_asid *, uint64_t pc, void *context)
Callback used by libipt for reading the process memory.
Definition: LibiptDecoder.cpp:72
lldb
Definition: SBAddress.h:15
lldb_private::ExceptionRecord
Definition: ExceptionRecord.h:25
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86
lldb_private::MemoryRegionInfo::GetReadable
OptionalBool GetReadable() const
Definition: MemoryRegionInfo.h:44