593 lines · cpp
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-exception6//7//===----------------------------------------------------------------------===//8//9// Created by Greg Clayton on 6/18/07.10//11//===----------------------------------------------------------------------===//12 13#include "MachException.h"14#include "DNB.h"15#include "DNBError.h"16#include "DNBLog.h"17#include "MachProcess.h"18#include "SysSignal.h"19#include <cerrno>20#include <inttypes.h>21#include <sys/ptrace.h>22#include <sys/types.h>23 24static void AppendExceptionData(std::vector<mach_exception_data_type_t> &out,25 mach_exception_data_t data,26 mach_msg_type_number_t count) {27 mach_exception_data_type_t buf;28 for (mach_msg_type_number_t i = 0; i < count; ++i) {29 // The input Data we receive need not be aligned correctly.30 // Perform an unaligned copy by pretending we're dealing with31 // a char* buffer. This is required to work around UBSAN/ASAN32 // "misaligned address" errors.33 auto *src = reinterpret_cast<char *>(data + i);34 memcpy(&buf, src, sizeof(mach_exception_data_type_t));35 out.push_back(buf);36 }37}38 39// Routine mach_exception_raise40extern "C" kern_return_t41catch_mach_exception_raise(mach_port_t exception_port, mach_port_t thread,42 mach_port_t task, exception_type_t exception,43 mach_exception_data_t code,44 mach_msg_type_number_t codeCnt);45 46extern "C" kern_return_t catch_mach_exception_raise_state(47 mach_port_t exception_port, exception_type_t exception,48 const mach_exception_data_t code, mach_msg_type_number_t codeCnt,49 int *flavor, const thread_state_t old_state,50 mach_msg_type_number_t old_stateCnt, thread_state_t new_state,51 mach_msg_type_number_t *new_stateCnt);52 53// Routine mach_exception_raise_state_identity54extern "C" kern_return_t catch_mach_exception_raise_state_identity(55 mach_port_t exception_port, mach_port_t thread, mach_port_t task,56 exception_type_t exception, mach_exception_data_t code,57 mach_msg_type_number_t codeCnt, int *flavor, thread_state_t old_state,58 mach_msg_type_number_t old_stateCnt, thread_state_t new_state,59 mach_msg_type_number_t *new_stateCnt);60 61extern "C" boolean_t mach_exc_server(mach_msg_header_t *InHeadP,62 mach_msg_header_t *OutHeadP);63 64// Note: g_message points to the storage allocated to catch the data from65// catching the current exception raise. It's populated when we catch a raised66// exception which can't immediately be replied to.67//68// If it becomes possible to catch exceptions from multiple threads69// simultaneously, accesses to g_message would need to be mutually exclusive.70static MachException::Data *g_message = NULL;71 72extern "C" kern_return_t catch_mach_exception_raise_state(73 mach_port_t exc_port, exception_type_t exc_type,74 const mach_exception_data_t exc_data, mach_msg_type_number_t exc_data_count,75 int *flavor, const thread_state_t old_state,76 mach_msg_type_number_t old_stateCnt, thread_state_t new_state,77 mach_msg_type_number_t *new_stateCnt) {78 if (DNBLogCheckLogBit(LOG_EXCEPTIONS)) {79 DNBLogThreaded("::%s ( exc_port = 0x%4.4x, exc_type = %d ( %s ), exc_data "80 "= 0x%llx, exc_data_count = %d)",81 __FUNCTION__, exc_port, exc_type,82 MachException::Name(exc_type), (uint64_t)exc_data,83 exc_data_count);84 }85 return KERN_FAILURE;86}87 88extern "C" kern_return_t catch_mach_exception_raise_state_identity(89 mach_port_t exc_port, mach_port_t thread_port, mach_port_t task_port,90 exception_type_t exc_type, mach_exception_data_t exc_data,91 mach_msg_type_number_t exc_data_count, int *flavor,92 thread_state_t old_state, mach_msg_type_number_t old_stateCnt,93 thread_state_t new_state, mach_msg_type_number_t *new_stateCnt) {94 if (DNBLogCheckLogBit(LOG_EXCEPTIONS)) {95 DNBLogThreaded("::%s ( exc_port = 0x%4.4x, thd_port = 0x%4.4x, tsk_port = "96 "0x%4.4x, exc_type = %d ( %s ), exc_data[%d] = { 0x%llx, "97 "0x%llx })",98 __FUNCTION__, exc_port, thread_port, task_port, exc_type,99 MachException::Name(exc_type), exc_data_count,100 (uint64_t)(exc_data_count > 0 ? exc_data[0] : 0xBADDBADD),101 (uint64_t)(exc_data_count > 1 ? exc_data[1] : 0xBADDBADD));102 }103 104 return KERN_FAILURE;105}106 107extern "C" kern_return_t108catch_mach_exception_raise(mach_port_t exc_port, mach_port_t thread_port,109 mach_port_t task_port, exception_type_t exc_type,110 mach_exception_data_t exc_data,111 mach_msg_type_number_t exc_data_count) {112 if (DNBLogCheckLogBit(LOG_EXCEPTIONS)) {113 std::vector<mach_exception_data_type_t> exc_datas;114 AppendExceptionData(exc_datas, exc_data, exc_data_count);115 DNBLogThreaded("::%s ( exc_port = 0x%4.4x, thd_port = 0x%4.4x, tsk_port = "116 "0x%4.4x, exc_type = %d ( %s ), exc_data[%d] = { 0x%" PRIx64117 ", "118 "0x%" PRIx64 " })",119 __FUNCTION__, exc_port, thread_port, task_port, exc_type,120 MachException::Name(exc_type), exc_data_count,121 (exc_data_count > 0 ? exc_datas[0] : 0xBADDBADD),122 (exc_data_count > 1 ? exc_datas[1] : 0xBADDBADD));123 }124 g_message->exc_type = 0;125 g_message->exc_data.clear();126 127 if (task_port == g_message->task_port) {128 g_message->task_port = task_port;129 g_message->thread_port = thread_port;130 g_message->exc_type = exc_type;131 AppendExceptionData(g_message->exc_data, exc_data, exc_data_count);132 return KERN_SUCCESS;133 } else if (!MachTask::IsValid(g_message->task_port)) {134 // Our original exception port isn't valid anymore check for a SIGTRAP135 if (exc_type == EXC_SOFTWARE && exc_data_count == 2 &&136 exc_data[0] == EXC_SOFT_SIGNAL && exc_data[1] == SIGTRAP) {137 // We got a SIGTRAP which indicates we might have exec'ed and possibly138 // lost our old task port during the exec, so we just need to switch over139 // to using this new task port140 g_message->task_port = task_port;141 g_message->thread_port = thread_port;142 g_message->exc_type = exc_type;143 AppendExceptionData(g_message->exc_data, exc_data, exc_data_count);144 return KERN_SUCCESS;145 }146 }147 return KERN_FAILURE;148}149 150void MachException::Message::Dump() const {151 DNBLogThreadedIf(LOG_EXCEPTIONS, " exc_msg { bits = 0x%8.8x size = 0x%8.8x "152 "remote-port = 0x%8.8x local-port = 0x%8.8x "153 "reserved = 0x%8.8x id = 0x%8.8x } ",154 exc_msg.hdr.msgh_bits, exc_msg.hdr.msgh_size,155 exc_msg.hdr.msgh_remote_port, exc_msg.hdr.msgh_local_port,156 exc_msg.hdr.msgh_reserved, exc_msg.hdr.msgh_id);157 158 DNBLogThreadedIf(LOG_EXCEPTIONS, "reply_msg { bits = 0x%8.8x size = 0x%8.8x "159 "remote-port = 0x%8.8x local-port = 0x%8.8x "160 "reserved = 0x%8.8x id = 0x%8.8x }",161 reply_msg.hdr.msgh_bits, reply_msg.hdr.msgh_size,162 reply_msg.hdr.msgh_remote_port,163 reply_msg.hdr.msgh_local_port, reply_msg.hdr.msgh_reserved,164 reply_msg.hdr.msgh_id);165 166 state.Dump();167}168 169bool MachException::Data::GetStopInfo(170 struct DNBThreadStopInfo *stop_info) const {171 // Zero out the structure.172 memset(stop_info, 0, sizeof(struct DNBThreadStopInfo));173 174 if (exc_type == 0) {175 stop_info->reason = eStopTypeInvalid;176 return true;177 }178 179#if defined(__arm64__) || defined(__aarch64__)180 if (exc_type == EXC_BREAKPOINT && exc_data[0] == EXC_ARM_DA_DEBUG &&181 exc_data.size() > 1) {182 stop_info->reason = eStopTypeWatchpoint;183 stop_info->details.watchpoint.mach_exception_addr = exc_data[1];184 stop_info->details.watchpoint.addr = INVALID_NUB_ADDRESS;185 if (exc_data.size() > 2) {186 stop_info->details.watchpoint.hw_idx = exc_data[2];187 }188 return true;189 }190#endif191 192 // We always stop with a mach exceptions193 stop_info->reason = eStopTypeException;194 // Save the EXC_XXXX exception type195 stop_info->details.exception.type = exc_type;196 197 // Fill in a text description198 const char *exc_name = MachException::Name(exc_type);199 char *desc = stop_info->description;200 const char *end_desc = desc + DNB_THREAD_STOP_INFO_MAX_DESC_LENGTH;201 if (exc_name)202 desc +=203 snprintf(desc, DNB_THREAD_STOP_INFO_MAX_DESC_LENGTH, "%s", exc_name);204 else205 desc +=206 snprintf(desc, DNB_THREAD_STOP_INFO_MAX_DESC_LENGTH, "%i", exc_type);207 208 stop_info->details.exception.data_count = exc_data.size();209 210 int soft_signal = SoftSignal();211 if (soft_signal) {212 if (desc < end_desc) {213 const char *sig_str = SysSignal::Name(soft_signal);214 snprintf(desc, end_desc - desc, " EXC_SOFT_SIGNAL( %i ( %s ))",215 soft_signal, sig_str ? sig_str : "unknown signal");216 }217 } else {218 // No special disassembly for exception data, just219 size_t idx;220 if (desc < end_desc) {221 desc += snprintf(desc, end_desc - desc, " data[%llu] = {",222 (uint64_t)stop_info->details.exception.data_count);223 224 for (idx = 0;225 desc < end_desc && idx < stop_info->details.exception.data_count;226 ++idx)227 desc += snprintf(228 desc, end_desc - desc, "0x%llx%c", (uint64_t)exc_data[idx],229 ((idx + 1 == stop_info->details.exception.data_count) ? '}' : ','));230 }231 }232 233 // Copy the exception data234 size_t i;235 for (i = 0; i < stop_info->details.exception.data_count; i++)236 stop_info->details.exception.data[i] = exc_data[i];237 238 return true;239}240 241void MachException::Data::DumpStopReason() const {242 int soft_signal = SoftSignal();243 if (soft_signal) {244 const char *signal_str = SysSignal::Name(soft_signal);245 if (signal_str)246 DNBLog("signal(%s)", signal_str);247 else248 DNBLog("signal(%i)", soft_signal);249 return;250 }251 DNBLog("%s", Name(exc_type));252}253 254kern_return_t MachException::Message::Receive(mach_port_t port,255 mach_msg_option_t options,256 mach_msg_timeout_t timeout,257 mach_port_t notify_port) {258 DNBError err;259 const bool log_exceptions = DNBLogCheckLogBit(LOG_EXCEPTIONS);260 mach_msg_timeout_t mach_msg_timeout =261 (options & MACH_RCV_TIMEOUT) ? timeout : 0;262 if (log_exceptions && ((options & MACH_RCV_TIMEOUT) == 0)) {263 // Dump this log message if we have no timeout in case it never returns264 DNBLogThreaded("::mach_msg ( msg->{bits = %#x, size = %u remote_port = "265 "%#x, local_port = %#x, reserved = 0x%x, id = 0x%x}, option "266 "= %#x, send_size = 0, rcv_size = %llu, rcv_name = %#x, "267 "timeout = %u, notify = %#x)",268 exc_msg.hdr.msgh_bits, exc_msg.hdr.msgh_size,269 exc_msg.hdr.msgh_remote_port, exc_msg.hdr.msgh_local_port,270 exc_msg.hdr.msgh_reserved, exc_msg.hdr.msgh_id, options,271 (uint64_t)sizeof(exc_msg.data), port, mach_msg_timeout,272 notify_port);273 }274 275 err = ::mach_msg(&exc_msg.hdr,276 options, // options277 0, // Send size278 sizeof(exc_msg.data), // Receive size279 port, // exception port to watch for exception on280 mach_msg_timeout, // timeout in msec (obeyed only if281 // MACH_RCV_TIMEOUT is ORed into the282 // options parameter)283 notify_port);284 285 // Dump any errors we get286 if (log_exceptions) {287 err.LogThreaded("::mach_msg ( msg->{bits = %#x, size = %u remote_port = "288 "%#x, local_port = %#x, reserved = 0x%x, id = 0x%x}, "289 "option = %#x, send_size = %u, rcv_size = %u, rcv_name = "290 "%#x, timeout = %u, notify = %#x)",291 exc_msg.hdr.msgh_bits, exc_msg.hdr.msgh_size,292 exc_msg.hdr.msgh_remote_port, exc_msg.hdr.msgh_local_port,293 exc_msg.hdr.msgh_reserved, exc_msg.hdr.msgh_id, options, 0,294 sizeof(exc_msg.data), port, mach_msg_timeout, notify_port);295 }296 return err.Status();297}298 299bool MachException::Message::CatchExceptionRaise(task_t task) {300 bool success = false;301 state.task_port = task;302 g_message = &state;303 // The exc_server function is the MIG generated server handling function304 // to handle messages from the kernel relating to the occurrence of an305 // exception in a thread. Such messages are delivered to the exception port306 // set via thread_set_exception_ports or task_set_exception_ports. When an307 // exception occurs in a thread, the thread sends an exception message to308 // its exception port, blocking in the kernel waiting for the receipt of a309 // reply. The exc_server function performs all necessary argument handling310 // for this kernel message and calls catch_exception_raise,311 // catch_exception_raise_state or catch_exception_raise_state_identity,312 // which should handle the exception. If the called routine returns313 // KERN_SUCCESS, a reply message will be sent, allowing the thread to314 // continue from the point of the exception; otherwise, no reply message315 // is sent and the called routine must have dealt with the exception316 // thread directly.317 if (mach_exc_server(&exc_msg.hdr, &reply_msg.hdr)) {318 success = true;319 } else if (DNBLogCheckLogBit(LOG_EXCEPTIONS)) {320 DNBLogThreaded("mach_exc_server returned zero...");321 }322 g_message = NULL;323 return success;324}325 326kern_return_t MachException::Message::Reply(MachProcess *process, int signal) {327 // Reply to the exception...328 DNBError err;329 330 // If we had a soft signal, we need to update the thread first so it can331 // continue without signaling332 int soft_signal = state.SoftSignal();333 if (soft_signal) {334 int state_pid = -1;335 if (process->Task().TaskPort() == state.task_port) {336 // This is our task, so we can update the signal to send to it337 state_pid = process->ProcessID();338 soft_signal = signal;339 } else {340 err = ::pid_for_task(state.task_port, &state_pid);341 }342 343 assert(state_pid != -1);344 if (state_pid != -1) {345 errno = 0;346 if (::ptrace(PT_THUPDATE, state_pid,347 (caddr_t)((uintptr_t)state.thread_port), soft_signal) != 0)348 err.SetError(errno, DNBError::POSIX);349 else350 err.Clear();351 352 if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail())353 err.LogThreaded("::ptrace (request = PT_THUPDATE, pid = 0x%4.4x, tid = "354 "0x%4.4x, signal = %i)",355 state_pid, state.thread_port, soft_signal);356 }357 }358 359 DNBLogThreadedIf(360 LOG_EXCEPTIONS, "::mach_msg ( msg->{bits = %#x, size = %u, remote_port = "361 "%#x, local_port = %#x, reserved = 0x%x, id = 0x%x}, "362 "option = %#x, send_size = %u, rcv_size = %u, rcv_name = "363 "%#x, timeout = %u, notify = %#x)",364 reply_msg.hdr.msgh_bits, reply_msg.hdr.msgh_size,365 reply_msg.hdr.msgh_remote_port, reply_msg.hdr.msgh_local_port,366 reply_msg.hdr.msgh_reserved, reply_msg.hdr.msgh_id,367 MACH_SEND_MSG | MACH_SEND_INTERRUPT, reply_msg.hdr.msgh_size, 0,368 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);369 370 err = ::mach_msg(&reply_msg.hdr, MACH_SEND_MSG | MACH_SEND_INTERRUPT,371 reply_msg.hdr.msgh_size, 0, MACH_PORT_NULL,372 MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);373 374 if (err.Fail()) {375 if (err.Status() == MACH_SEND_INTERRUPTED) {376 if (DNBLogCheckLogBit(LOG_EXCEPTIONS))377 err.LogThreaded("::mach_msg() - send interrupted");378 // TODO: keep retrying to reply???379 } else {380 if (state.task_port == process->Task().TaskPort()) {381 DNBLogThreaded("error: mach_msg() returned an error when replying to a "382 "mach exception: error = %u",383 err.Status());384 } else {385 if (DNBLogCheckLogBit(LOG_EXCEPTIONS))386 err.LogThreaded("::mach_msg() - failed (child of task)");387 }388 }389 }390 391 return err.Status();392}393 394void MachException::Data::Dump() const {395 const char *exc_type_name = MachException::Name(exc_type);396 DNBLogThreadedIf(397 LOG_EXCEPTIONS, " state { task_port = 0x%4.4x, thread_port = "398 "0x%4.4x, exc_type = %i (%s) ...",399 task_port, thread_port, exc_type, exc_type_name ? exc_type_name : "???");400 401 const size_t exc_data_count = exc_data.size();402 // Dump any special exception data contents403 int soft_signal = SoftSignal();404 if (soft_signal != 0) {405 const char *sig_str = SysSignal::Name(soft_signal);406 DNBLogThreadedIf(LOG_EXCEPTIONS,407 " exc_data: EXC_SOFT_SIGNAL (%i (%s))",408 soft_signal, sig_str ? sig_str : "unknown signal");409 } else {410 // No special disassembly for this data, just dump the data411 size_t idx;412 for (idx = 0; idx < exc_data_count; ++idx) {413 DNBLogThreadedIf(LOG_EXCEPTIONS, " exc_data[%llu]: 0x%llx",414 (uint64_t)idx, (uint64_t)exc_data[idx]);415 }416 }417}418 419// The EXC_MASK_ALL value hard-coded here so that lldb can be built420// on a new OS with an older deployment target . The new OS may have421// an addition to its EXC_MASK_ALL that the old OS will not recognize -422// <mach/exception_types.h> doesn't vary the value based on the deployment423// target. So we need a known set of masks that can be assumed to be424// valid when running on an older OS. We'll fall back to trying425// PREV_EXC_MASK_ALL if the EXC_MASK_ALL value lldb was compiled with is426// not recognized.427 428#define PREV_EXC_MASK_ALL (EXC_MASK_BAD_ACCESS | \429 EXC_MASK_BAD_INSTRUCTION | \430 EXC_MASK_ARITHMETIC | \431 EXC_MASK_EMULATION | \432 EXC_MASK_SOFTWARE | \433 EXC_MASK_BREAKPOINT | \434 EXC_MASK_SYSCALL | \435 EXC_MASK_MACH_SYSCALL | \436 EXC_MASK_RPC_ALERT | \437 EXC_MASK_RESOURCE | \438 EXC_MASK_GUARD | \439 EXC_MASK_MACHINE)440 441#define LLDB_EXC_MASK EXC_MASK_ALL442 443kern_return_t MachException::PortInfo::Save(task_t task) {444 DNBLogThreadedIf(LOG_EXCEPTIONS | LOG_VERBOSE,445 "MachException::PortInfo::Save ( task = 0x%4.4x )", task);446 // Be careful to be able to have debugserver built on a newer OS than what447 // it is currently running on by being able to start with all exceptions448 // and back off to just what is supported on the current system449 DNBError err;450 451 mask = LLDB_EXC_MASK;452 453 count = (sizeof(ports) / sizeof(ports[0]));454 err = ::task_get_exception_ports(task, mask, masks, &count, ports, behaviors,455 flavors);456 if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail())457 err.LogThreaded("::task_get_exception_ports ( task = 0x%4.4x, mask = 0x%x, "458 "maskCnt => %u, ports, behaviors, flavors )",459 task, mask, count);460 461 if (err.Status() == KERN_INVALID_ARGUMENT && mask != PREV_EXC_MASK_ALL) {462 mask = PREV_EXC_MASK_ALL;463 count = (sizeof(ports) / sizeof(ports[0]));464 err = ::task_get_exception_ports(task, mask, masks, &count, ports,465 behaviors, flavors);466 if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail())467 err.LogThreaded("::task_get_exception_ports ( task = 0x%4.4x, mask = "468 "0x%x, maskCnt => %u, ports, behaviors, flavors )",469 task, mask, count);470 }471 if (err.Fail()) {472 mask = 0;473 count = 0;474 }475 return err.Status();476}477 478kern_return_t MachException::PortInfo::Restore(task_t task) {479 DNBLogThreadedIf(LOG_EXCEPTIONS | LOG_VERBOSE,480 "MachException::PortInfo::Restore( task = 0x%4.4x )", task);481 uint32_t i = 0;482 DNBError err;483 if (count > 0) {484 for (i = 0; i < count; i++) {485 err = ::task_set_exception_ports(task, masks[i], ports[i], behaviors[i],486 flavors[i]);487 if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail()) {488 err.LogThreaded("::task_set_exception_ports ( task = 0x%4.4x, "489 "exception_mask = 0x%8.8x, new_port = 0x%4.4x, "490 "behavior = 0x%8.8x, new_flavor = 0x%8.8x )",491 task, masks[i], ports[i], behaviors[i], flavors[i]);492 // Bail if we encounter any errors493 }494 495 if (err.Fail())496 break;497 }498 }499 count = 0;500 return err.Status();501}502 503const char *MachException::Name(exception_type_t exc_type) {504 switch (exc_type) {505 case EXC_BAD_ACCESS:506 return "EXC_BAD_ACCESS";507 case EXC_BAD_INSTRUCTION:508 return "EXC_BAD_INSTRUCTION";509 case EXC_ARITHMETIC:510 return "EXC_ARITHMETIC";511 case EXC_EMULATION:512 return "EXC_EMULATION";513 case EXC_SOFTWARE:514 return "EXC_SOFTWARE";515 case EXC_BREAKPOINT:516 return "EXC_BREAKPOINT";517 case EXC_SYSCALL:518 return "EXC_SYSCALL";519 case EXC_MACH_SYSCALL:520 return "EXC_MACH_SYSCALL";521 case EXC_RPC_ALERT:522 return "EXC_RPC_ALERT";523#ifdef EXC_CRASH524 case EXC_CRASH:525 return "EXC_CRASH";526#endif527 case EXC_RESOURCE:528 return "EXC_RESOURCE";529#ifdef EXC_GUARD530 case EXC_GUARD:531 return "EXC_GUARD";532#endif533#ifdef EXC_CORPSE_NOTIFY534 case EXC_CORPSE_NOTIFY:535 return "EXC_CORPSE_NOTIFY";536#endif537#ifdef EXC_CORPSE_VARIANT_BIT538 case EXC_CORPSE_VARIANT_BIT:539 return "EXC_CORPSE_VARIANT_BIT";540#endif541 default:542 break;543 }544 return NULL;545}546 547// Returns the exception mask for a given exception name. 548// 0 is not a legit mask, so we return that in the case of an error.549exception_mask_t MachException::ExceptionMask(const char *name) {550 static const char *exception_prefix = "EXC_";551 static const int prefix_len = strlen(exception_prefix);552 553 // All mach exceptions start with this prefix:554 if (strstr(name, exception_prefix) != name)555 return 0;556 557 name += prefix_len;558 std::string name_str = name;559 if (name_str == "BAD_ACCESS")560 return EXC_MASK_BAD_ACCESS;561 if (name_str == "BAD_INSTRUCTION")562 return EXC_MASK_BAD_INSTRUCTION;563 if (name_str == "ARITHMETIC")564 return EXC_MASK_ARITHMETIC;565 if (name_str == "EMULATION")566 return EXC_MASK_EMULATION;567 if (name_str == "SOFTWARE")568 return EXC_MASK_SOFTWARE;569 if (name_str == "BREAKPOINT")570 return EXC_MASK_BREAKPOINT;571 if (name_str == "SYSCALL")572 return EXC_MASK_SYSCALL;573 if (name_str == "MACH_SYSCALL")574 return EXC_MASK_MACH_SYSCALL;575 if (name_str == "RPC_ALERT")576 return EXC_MASK_RPC_ALERT;577#ifdef EXC_CRASH578 if (name_str == "CRASH")579 return EXC_MASK_CRASH;580#endif581 if (name_str == "RESOURCE")582 return EXC_MASK_RESOURCE;583#ifdef EXC_GUARD584 if (name_str == "GUARD")585 return EXC_MASK_GUARD;586#endif587#ifdef EXC_CORPSE_NOTIFY588 if (name_str == "CORPSE_NOTIFY")589 return EXC_MASK_CORPSE_NOTIFY;590#endif591 return 0;592}593