LLDB  mainline
MachException.cpp
Go to the documentation of this file.
1 //===-- MachException.cpp ---------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Created by Greg Clayton on 6/18/07.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "MachException.h"
14 
15 // C includes
16 #include <errno.h>
17 #include <sys/ptrace.h>
18 #include <sys/types.h>
19 
20 // C++ includes
21 #include <mutex>
22 
23 // LLDB includes
26 #include "lldb/Utility/Log.h"
27 #include "lldb/Utility/Status.h"
28 #include "lldb/Utility/Stream.h"
29 
30 using namespace lldb;
31 using namespace lldb_private;
32 using namespace lldb_private::process_darwin;
33 
34 // Routine mach_exception_raise
35 extern "C" kern_return_t
36 catch_mach_exception_raise(mach_port_t exception_port, mach_port_t thread,
37  mach_port_t task, exception_type_t exception,
38  mach_exception_data_t code,
39  mach_msg_type_number_t codeCnt);
40 
41 extern "C" kern_return_t catch_mach_exception_raise_state(
42  mach_port_t exception_port, exception_type_t exception,
43  const mach_exception_data_t code, mach_msg_type_number_t codeCnt,
44  int *flavor, const thread_state_t old_state,
45  mach_msg_type_number_t old_stateCnt, thread_state_t new_state,
46  mach_msg_type_number_t *new_stateCnt);
47 
48 // Routine mach_exception_raise_state_identity
49 extern "C" kern_return_t catch_mach_exception_raise_state_identity(
50  mach_port_t exception_port, mach_port_t thread, mach_port_t task,
51  exception_type_t exception, mach_exception_data_t code,
52  mach_msg_type_number_t codeCnt, int *flavor, thread_state_t old_state,
53  mach_msg_type_number_t old_stateCnt, thread_state_t new_state,
54  mach_msg_type_number_t *new_stateCnt);
55 
56 extern "C" boolean_t mach_exc_server(mach_msg_header_t *InHeadP,
57  mach_msg_header_t *OutHeadP);
58 
60 
61 extern "C" kern_return_t catch_mach_exception_raise_state(
62  mach_port_t exc_port, exception_type_t exc_type,
63  const mach_exception_data_t exc_data, mach_msg_type_number_t exc_data_count,
64  int *flavor, const thread_state_t old_state,
65  mach_msg_type_number_t old_stateCnt, thread_state_t new_state,
66  mach_msg_type_number_t *new_stateCnt) {
67  // TODO change to LIBLLDB_LOG_EXCEPTION
68  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
69  if (log) {
70  log->Printf("::%s(exc_port = 0x%4.4x, exc_type = %d (%s), "
71  "exc_data = 0x%llx, exc_data_count = %d)",
72  __FUNCTION__, exc_port, exc_type, MachException::Name(exc_type),
73  (uint64_t)exc_data, exc_data_count);
74  }
75  return KERN_FAILURE;
76 }
77 
79  mach_port_t exc_port, mach_port_t thread_port, mach_port_t task_port,
80  exception_type_t exc_type, mach_exception_data_t exc_data,
81  mach_msg_type_number_t exc_data_count, int *flavor,
82  thread_state_t old_state, mach_msg_type_number_t old_stateCnt,
83  thread_state_t new_state, mach_msg_type_number_t *new_stateCnt) {
84  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
85  if (log) {
86  log->Printf("::%s(exc_port = 0x%4.4x, thd_port = 0x%4.4x, "
87  "tsk_port = 0x%4.4x, exc_type = %d (%s), exc_data[%d] = "
88  "{ 0x%llx, 0x%llx })",
89  __FUNCTION__, exc_port, thread_port, task_port, exc_type,
90  MachException::Name(exc_type), exc_data_count,
91  (uint64_t)(exc_data_count > 0 ? exc_data[0] : 0xBADDBADD),
92  (uint64_t)(exc_data_count > 1 ? exc_data[1] : 0xBADDBADD));
93  }
94 
95  return KERN_FAILURE;
96 }
97 
98 extern "C" kern_return_t
99 catch_mach_exception_raise(mach_port_t exc_port, mach_port_t thread_port,
100  mach_port_t task_port, exception_type_t exc_type,
101  mach_exception_data_t exc_data,
102  mach_msg_type_number_t exc_data_count) {
103  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
104  if (log) {
105  log->Printf("::%s(exc_port = 0x%4.4x, thd_port = 0x%4.4x, "
106  "tsk_port = 0x%4.4x, exc_type = %d (%s), exc_data[%d] "
107  "= { 0x%llx, 0x%llx })",
108  __FUNCTION__, exc_port, thread_port, task_port, exc_type,
109  MachException::Name(exc_type), exc_data_count,
110  (uint64_t)(exc_data_count > 0 ? exc_data[0] : 0xBADDBADD),
111  (uint64_t)(exc_data_count > 1 ? exc_data[1] : 0xBADDBADD));
112  }
113 
114  if (task_port == g_message->task_port) {
115  g_message->task_port = task_port;
116  g_message->thread_port = thread_port;
117  g_message->exc_type = exc_type;
118  g_message->exc_data.resize(exc_data_count);
119  ::memcpy(&g_message->exc_data[0], exc_data,
120  g_message->exc_data.size() * sizeof(mach_exception_data_type_t));
121  return KERN_SUCCESS;
122  }
123  return KERN_FAILURE;
124 }
125 
126 bool MachException::Data::GetStopInfo(struct ThreadStopInfo *stop_info,
127  const UnixSignals &signals,
128  Stream &stream) const {
129  if (!stop_info)
130  return false;
131 
132  // Zero out the structure.
133  memset(stop_info, 0, sizeof(struct ThreadStopInfo));
134 
135  if (exc_type == 0) {
136  stop_info->reason = eStopReasonInvalid;
137  return true;
138  }
139 
140  // We always stop with a mach exception.
141  stop_info->reason = eStopReasonException;
142  // Save the EXC_XXXX exception type.
143  stop_info->details.exception.type = exc_type;
144 
145  // Fill in a text description
146  const char *exc_name = MachException::Name(exc_type);
147  if (exc_name)
148  stream.Printf("%s", exc_name);
149  else
150  stream.Printf("%i", exc_type);
151 
152  stop_info->details.exception.data_count = exc_data.size();
153 
154  int soft_signal = SoftSignal();
155  if (soft_signal) {
156  const char *sig_str = signals.GetSignalAsCString(soft_signal);
157  stream.Printf(" EXC_SOFT_SIGNAL( %i ( %s ))", soft_signal,
158  sig_str ? sig_str : "unknown signal");
159  } else {
160  // No special disassembly for exception data, just print it.
161  size_t idx;
162  stream.Printf(" data[%llu] = {",
163  (uint64_t)stop_info->details.exception.data_count);
164 
165  for (idx = 0; idx < stop_info->details.exception.data_count; ++idx) {
166  stream.Printf(
167  "0x%llx%c", (uint64_t)exc_data[idx],
168  ((idx + 1 == stop_info->details.exception.data_count) ? '}' : ','));
169  }
170  }
171 
172  // Copy the exception data
173  for (size_t i = 0; i < stop_info->details.exception.data_count; i++)
174  stop_info->details.exception.data[i] = exc_data[i];
175 
176  return true;
177 }
178 
179 Status MachException::Message::Receive(mach_port_t port,
180  mach_msg_option_t options,
181  mach_msg_timeout_t timeout,
182  mach_port_t notify_port) {
183  Status error;
184  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
185 
186  mach_msg_timeout_t mach_msg_timeout =
187  options & MACH_RCV_TIMEOUT ? timeout : 0;
188  if (log && ((options & MACH_RCV_TIMEOUT) == 0)) {
189  // Dump this log message if we have no timeout in case it never returns
190  log->Printf("::mach_msg(msg->{bits = %#x, size = %u remote_port = %#x, "
191  "local_port = %#x, reserved = 0x%x, id = 0x%x}, "
192  "option = %#x, send_size = 0, rcv_size = %llu, "
193  "rcv_name = %#x, timeout = %u, notify = %#x)",
194  exc_msg.hdr.msgh_bits, exc_msg.hdr.msgh_size,
195  exc_msg.hdr.msgh_remote_port, exc_msg.hdr.msgh_local_port,
196  exc_msg.hdr.msgh_reserved, exc_msg.hdr.msgh_id, options,
197  (uint64_t)sizeof(exc_msg.data), port, mach_msg_timeout,
198  notify_port);
199  }
200 
201  mach_msg_return_t mach_err =
202  ::mach_msg(&exc_msg.hdr,
203  options, // options
204  0, // Send size
205  sizeof(exc_msg.data), // Receive size
206  port, // exception port to watch for
207  // exception on
208  mach_msg_timeout, // timeout in msec (obeyed only
209  // if MACH_RCV_TIMEOUT is ORed
210  // into the options parameter)
211  notify_port);
212  error.SetError(mach_err, eErrorTypeMachKernel);
213 
214  // Dump any errors we get
215  if (error.Fail() && log) {
216  log->Printf("::mach_msg(msg->{bits = %#x, size = %u remote_port = %#x, "
217  "local_port = %#x, reserved = 0x%x, id = 0x%x}, "
218  "option = %#x, send_size = %u, rcv_size = %lu, rcv_name "
219  "= %#x, timeout = %u, notify = %#x) failed: %s",
220  exc_msg.hdr.msgh_bits, exc_msg.hdr.msgh_size,
221  exc_msg.hdr.msgh_remote_port, exc_msg.hdr.msgh_local_port,
222  exc_msg.hdr.msgh_reserved, exc_msg.hdr.msgh_id, options, 0,
223  sizeof(exc_msg.data), port, mach_msg_timeout, notify_port,
224  error.AsCString());
225  }
226  return error;
227 }
228 
229 void MachException::Message::Dump(Stream &stream) const {
230  stream.Printf(" exc_msg { bits = 0x%8.8x size = 0x%8.8x remote-port = "
231  "0x%8.8x local-port = 0x%8.8x reserved = 0x%8.8x id = "
232  "0x%8.8x }\n",
233  exc_msg.hdr.msgh_bits, exc_msg.hdr.msgh_size,
234  exc_msg.hdr.msgh_remote_port, exc_msg.hdr.msgh_local_port,
235  exc_msg.hdr.msgh_reserved, exc_msg.hdr.msgh_id);
236 
237  stream.Printf(" reply_msg { bits = 0x%8.8x size = 0x%8.8x remote-port = "
238  "0x%8.8x local-port = 0x%8.8x reserved = 0x%8.8x id = "
239  "0x%8.8x }",
240  reply_msg.hdr.msgh_bits, reply_msg.hdr.msgh_size,
241  reply_msg.hdr.msgh_remote_port, reply_msg.hdr.msgh_local_port,
242  reply_msg.hdr.msgh_reserved, reply_msg.hdr.msgh_id);
243 }
244 
245 bool MachException::Message::CatchExceptionRaise(task_t task) {
246  bool success = false;
247  state.task_port = task;
248  g_message = &state;
249  // The exc_server function is the MIG generated server handling function to
250  // handle messages from the kernel relating to the occurrence of an exception
251  // in a thread. Such messages are delivered to the exception port set via
252  // thread_set_exception_ports or task_set_exception_ports. When an exception
253  // occurs in a thread, the thread sends an exception message to its exception
254  // port, blocking in the kernel waiting for the receipt of a reply. The
255  // exc_server function performs all necessary argument handling for this
256  // kernel message and calls catch_exception_raise,
257  // catch_exception_raise_state or catch_exception_raise_state_identity, which
258  // should handle the exception. If the called routine returns KERN_SUCCESS, a
259  // reply message will be sent, allowing the thread to continue from the point
260  // of the exception; otherwise, no reply message is sent and the called
261  // routine must have dealt with the exception thread directly.
262  if (mach_exc_server(&exc_msg.hdr, &reply_msg.hdr)) {
263  success = true;
264  } else {
265  Log *log(
266  GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
267  if (log)
268  log->Printf("MachException::Message::%s(): mach_exc_server "
269  "returned zero...",
270  __FUNCTION__);
271  }
272  g_message = NULL;
273  return success;
274 }
275 
276 Status MachException::Message::Reply(::pid_t inferior_pid, task_t inferior_task,
277  int signal) {
278  // Reply to the exception...
279  Status error;
280 
281  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
282 
283  // If we had a soft signal, we need to update the thread first so it can
284  // continue without signaling
285  int soft_signal = state.SoftSignal();
286  if (soft_signal) {
287  int state_pid = -1;
288  if (inferior_task == state.task_port) {
289  // This is our task, so we can update the signal to send to it
290  state_pid = inferior_pid;
291  soft_signal = signal;
292  } else {
293  auto mach_err = ::pid_for_task(state.task_port, &state_pid);
294  if (mach_err) {
295  error.SetError(mach_err, eErrorTypeMachKernel);
296  if (log)
297  log->Printf("MachException::Message::%s(): pid_for_task() "
298  "failed: %s",
299  __FUNCTION__, error.AsCString());
300  return error;
301  }
302  }
303 
304  lldbassert(state_pid != -1);
305  if (state_pid != -1) {
306  errno = 0;
307  caddr_t thread_port_caddr = (caddr_t)(uintptr_t)state.thread_port;
308  if (::ptrace(PT_THUPDATE, state_pid, thread_port_caddr, soft_signal) != 0)
309  error.SetError(errno, eErrorTypePOSIX);
310 
311  if (!error.Success()) {
312  if (log)
313  log->Printf("::ptrace(request = PT_THUPDATE, pid = "
314  "0x%4.4x, tid = 0x%4.4x, signal = %i)",
315  state_pid, state.thread_port, soft_signal);
316  return error;
317  }
318  }
319  }
320 
321  if (log)
322  log->Printf("::mach_msg ( msg->{bits = %#x, size = %u, remote_port "
323  "= %#x, local_port = %#x, reserved = 0x%x, id = 0x%x}, "
324  "option = %#x, send_size = %u, rcv_size = %u, rcv_name "
325  "= %#x, timeout = %u, notify = %#x)",
326  reply_msg.hdr.msgh_bits, reply_msg.hdr.msgh_size,
327  reply_msg.hdr.msgh_remote_port, reply_msg.hdr.msgh_local_port,
328  reply_msg.hdr.msgh_reserved, reply_msg.hdr.msgh_id,
329  MACH_SEND_MSG | MACH_SEND_INTERRUPT, reply_msg.hdr.msgh_size, 0,
330  MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
331 
332  auto mach_err =
333  ::mach_msg(&reply_msg.hdr, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
334  reply_msg.hdr.msgh_size, 0, MACH_PORT_NULL,
335  MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
336  if (mach_err)
337  error.SetError(mach_err, eErrorTypeMachKernel);
338 
339  // Log our error if we have one.
340  if (error.Fail() && log) {
341  if (error.GetError() == MACH_SEND_INTERRUPTED) {
342  log->PutCString("::mach_msg() - send interrupted");
343  // TODO: keep retrying to reply???
344  } else if (state.task_port == inferior_task) {
345  log->Printf("mach_msg(): returned an error when replying "
346  "to a mach exception: error = %u (%s)",
347  error.GetError(), error.AsCString());
348  } else {
349  log->Printf("::mach_msg() - failed (child of task): %u (%s)",
350  error.GetError(), error.AsCString());
351  }
352  }
353 
354  return error;
355 }
356 
357 #define PREV_EXC_MASK_ALL \
358  (EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION | EXC_MASK_ARITHMETIC | \
359  EXC_MASK_EMULATION | EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT | \
360  EXC_MASK_SYSCALL | EXC_MASK_MACH_SYSCALL | EXC_MASK_RPC_ALERT | \
361  EXC_MASK_MACHINE)
362 
363 // Don't listen for EXC_RESOURCE, it should really get handled by the system
364 // handler.
365 
366 #ifndef EXC_RESOURCE
367 #define EXC_RESOURCE 11
368 #endif
369 
370 #ifndef EXC_MASK_RESOURCE
371 #define EXC_MASK_RESOURCE (1 << EXC_RESOURCE)
372 #endif
373 
374 #define LLDB_EXC_MASK (EXC_MASK_ALL & ~EXC_MASK_RESOURCE)
375 
376 Status MachException::PortInfo::Save(task_t task) {
377  Status error;
378  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
379 
380  if (log)
381  log->Printf("MachException::PortInfo::%s(task = 0x%4.4x)", __FUNCTION__,
382  task);
383 
384  // Be careful to be able to have debugserver built on a newer OS than what it
385  // is currently running on by being able to start with all exceptions and
386  // back off to just what is supported on the current system
387  mask = LLDB_EXC_MASK;
388 
389  count = (sizeof(ports) / sizeof(ports[0]));
390  auto mach_err = ::task_get_exception_ports(task, mask, masks, &count, ports,
391  behaviors, flavors);
392  if (mach_err)
393  error.SetError(mach_err, eErrorTypeMachKernel);
394 
395  if (log) {
396  if (error.Success()) {
397  log->Printf("::task_get_exception_ports(task = 0x%4.4x, mask = "
398  "0x%x, maskCnt => %u, ports, behaviors, flavors)",
399  task, mask, count);
400  } else {
401  log->Printf("::task_get_exception_ports(task = 0x%4.4x, mask = 0x%x, "
402  "maskCnt => %u, ports, behaviors, flavors) error: %u (%s)",
403  task, mask, count, error.GetError(), error.AsCString());
404  }
405  }
406 
407  if ((error.GetError() == KERN_INVALID_ARGUMENT) &&
408  (mask != PREV_EXC_MASK_ALL)) {
409  mask = PREV_EXC_MASK_ALL;
410  count = (sizeof(ports) / sizeof(ports[0]));
411  mach_err = ::task_get_exception_ports(task, mask, masks, &count, ports,
412  behaviors, flavors);
413  error.SetError(mach_err, eErrorTypeMachKernel);
414  if (log) {
415  if (error.Success()) {
416  log->Printf("::task_get_exception_ports(task = 0x%4.4x, "
417  "mask = 0x%x, maskCnt => %u, ports, behaviors, "
418  "flavors)",
419  task, mask, count);
420  } else {
421  log->Printf("::task_get_exception_ports(task = 0x%4.4x, mask = "
422  "0x%x, maskCnt => %u, ports, behaviors, flavors) "
423  "error: %u (%s)",
424  task, mask, count, error.GetError(), error.AsCString());
425  }
426  }
427  }
428  if (error.Fail()) {
429  mask = 0;
430  count = 0;
431  }
432  return error;
433 }
434 
435 Status MachException::PortInfo::Restore(task_t task) {
436  Status error;
437 
438  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
439 
440  if (log)
441  log->Printf("MachException::PortInfo::Restore(task = 0x%4.4x)", task);
442 
443  uint32_t i = 0;
444  if (count > 0) {
445  for (i = 0; i < count; i++) {
446  auto mach_err = ::task_set_exception_ports(task, masks[i], ports[i],
447  behaviors[i], flavors[i]);
448  if (mach_err)
449  error.SetError(mach_err, eErrorTypeMachKernel);
450  if (log) {
451  if (error.Success()) {
452  log->Printf("::task_set_exception_ports(task = 0x%4.4x, "
453  "exception_mask = 0x%8.8x, new_port = 0x%4.4x, "
454  "behavior = 0x%8.8x, new_flavor = 0x%8.8x)",
455  task, masks[i], ports[i], behaviors[i], flavors[i]);
456  } else {
457  log->Printf("::task_set_exception_ports(task = 0x%4.4x, "
458  "exception_mask = 0x%8.8x, new_port = 0x%4.4x, "
459  "behavior = 0x%8.8x, new_flavor = 0x%8.8x): "
460  "error %u (%s)",
461  task, masks[i], ports[i], behaviors[i], flavors[i],
462  error.GetError(), error.AsCString());
463  }
464  }
465 
466  // Bail if we encounter any errors
467  if (error.Fail())
468  break;
469  }
470  }
471 
472  count = 0;
473  return error;
474 }
475 
476 const char *MachException::Name(exception_type_t exc_type) {
477  switch (exc_type) {
478  case EXC_BAD_ACCESS:
479  return "EXC_BAD_ACCESS";
480  case EXC_BAD_INSTRUCTION:
481  return "EXC_BAD_INSTRUCTION";
482  case EXC_ARITHMETIC:
483  return "EXC_ARITHMETIC";
484  case EXC_EMULATION:
485  return "EXC_EMULATION";
486  case EXC_SOFTWARE:
487  return "EXC_SOFTWARE";
488  case EXC_BREAKPOINT:
489  return "EXC_BREAKPOINT";
490  case EXC_SYSCALL:
491  return "EXC_SYSCALL";
492  case EXC_MACH_SYSCALL:
493  return "EXC_MACH_SYSCALL";
494  case EXC_RPC_ALERT:
495  return "EXC_RPC_ALERT";
496 #ifdef EXC_CRASH
497  case EXC_CRASH:
498  return "EXC_CRASH";
499 #endif
500  default:
501  break;
502  }
503  return NULL;
504 }
const char * GetSignalAsCString(int32_t signo) const
#define LIBLLDB_LOG_PROCESS
Definition: Logging.h:15
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
#define lldbassert(x)
Definition: LLDBAssert.h:15
kern_return_t catch_mach_exception_raise_state_identity(mach_port_t exception_port, mach_port_t thread, mach_port_t task, exception_type_t exception, mach_exception_data_t code, mach_msg_type_number_t codeCnt, int *flavor, thread_state_t old_state, mach_msg_type_number_t old_stateCnt, thread_state_t new_state, mach_msg_type_number_t *new_stateCnt)
POSIX error codes.
static MachException::Data * g_message
kern_return_t catch_mach_exception_raise(mach_port_t exception_port, mach_port_t thread, mach_port_t task, exception_type_t exception, mach_exception_data_t code, mach_msg_type_number_t codeCnt)
kern_return_t catch_mach_exception_raise_state(mach_port_t exception_port, exception_type_t exception, const mach_exception_data_t code, mach_msg_type_number_t codeCnt, int *flavor, const thread_state_t old_state, mach_msg_type_number_t old_stateCnt, thread_state_t new_state, mach_msg_type_number_t *new_stateCnt)
#define LLDB_EXC_MASK
#define KERN_INVALID_ARGUMENT
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:57
Mach kernel error codes.
struct lldb_private::ThreadStopInfo::@11::@13 exception
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
bool Success() const
Test for success condition.
Definition: Status.cpp:287
lldb::StopReason reason
Definition: Debug.h:134
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
int void SetError(ValueType err, lldb::ErrorType type)
Set accesssor with an error value and type.
Definition: Status.cpp:216
void PutCString(const char *cstr)
Definition: Log.cpp:109
Definition: SBAddress.h:15
uint64_t pid_t
Definition: lldb-types.h:85
#define PREV_EXC_MASK_ALL
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
ValueType GetError() const
Access the error value.
Definition: Status.cpp:174
void Printf(const char *format,...) __attribute__((format(printf
Definition: Log.cpp:113
boolean_t mach_exc_server(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
std::vector< mach_exception_data_type_t > exc_data
Definition: MachException.h:51
#define KERN_SUCCESS
Constants returned by various RegisterContextDarwin_*** functions.
union lldb_private::ThreadStopInfo::@11 details
An error handling class.
Definition: Status.h:44