old mode 100755
new mode 100644

old mode 100755
new mode 100644

old mode 100755
new mode 100644

old mode 100755
new mode 100644

old mode 100755
new mode 100644

old mode 100755
new mode 100644

old mode 100755
new mode 100644

old mode 100755
new mode 100644

old mode 100755
new mode 100644

old mode 100755
new mode 100644

--- a/toolkit/crashreporter/google-breakpad/src/client/linux/handler/exception_handler.cc
+++ b/toolkit/crashreporter/google-breakpad/src/client/linux/handler/exception_handler.cc
@@ -113,17 +113,19 @@ ExceptionHandler::~ExceptionHandler() {
     // clean up the handler stack.
     delete handler_stack_;
     handler_stack_ = NULL;
   }
   pthread_mutex_unlock(&handler_stack_mutex_);
 }
 
 bool ExceptionHandler::WriteMinidump() {
-  return InternalWriteMinidump(0, 0, NULL);
+  bool success = InternalWriteMinidump(0, 0, NULL);
+  UpdateNextID();
+  return success;
 }
 
 // static
 bool ExceptionHandler::WriteMinidump(const string &dump_path,
                    MinidumpCallback callback,
                    void *callback_context) {
   ExceptionHandler handler(dump_path, NULL, callback,
                            callback_context, false);
@@ -221,46 +223,54 @@ void ExceptionHandler::HandleException(i
 }
 
 bool ExceptionHandler::InternalWriteMinidump(int signo,
                                              uintptr_t sighandler_ebp,
                                              struct sigcontext **sig_ctx) {
   if (filter_ && !filter_(callback_context_))
     return false;
 
+  bool success = false;
+  // Block all the signals we want to process when writting minidump.
+  // We don't want it to be interrupted.
+  sigset_t sig_blocked, sig_old;
+  bool blocked = true;
+  sigfillset(&sig_blocked);
+  for (size_t i = 0; i < sizeof(SigTable) / sizeof(SigTable[0]); ++i)
+    sigdelset(&sig_blocked, SigTable[i]);
+  if (sigprocmask(SIG_BLOCK, &sig_blocked, &sig_old) != 0) {
+    blocked = false;
+    fprintf(stderr, "google_breakpad::ExceptionHandler::HandleException: "
+                    "failed to block signals.\n");
+  }
+
+  success = minidump_generator_.WriteMinidumpToFile(
+                     next_minidump_path_c_, signo, sighandler_ebp, sig_ctx);
+
+  // Unblock the signals.
+  if (blocked) {
+    sigprocmask(SIG_SETMASK, &sig_old, &sig_old);
+  }
+
+  if (callback_)
+    success = callback_(dump_path_c_, next_minidump_id_c_,
+                          callback_context_, success);
+  return success;
+}
+
+void ExceptionHandler::UpdateNextID() {
   GUID guid;
-  bool success = false;;
   char guid_str[kGUIDStringLength + 1];
   if (CreateGUID(&guid) && GUIDToString(&guid, guid_str, sizeof(guid_str))) {
+    next_minidump_id_ = guid_str;
+    next_minidump_id_c_ = next_minidump_id_.c_str();
+
     char minidump_path[PATH_MAX];
     snprintf(minidump_path, sizeof(minidump_path), "%s/%s.dmp",
              dump_path_c_,
              guid_str);
 
-    // Block all the signals we want to process when writting minidump.
-    // We don't want it to be interrupted.
-    sigset_t sig_blocked, sig_old;
-    bool blocked = true;
-    sigfillset(&sig_blocked);
-    for (size_t i = 0; i < sizeof(SigTable) / sizeof(SigTable[0]); ++i)
-      sigdelset(&sig_blocked, SigTable[i]);
-    if (sigprocmask(SIG_BLOCK, &sig_blocked, &sig_old) != 0) {
-      blocked = false;
-      fprintf(stderr, "google_breakpad::ExceptionHandler::HandleException: "
-                      "failed to block signals.\n");
-    }
-
-    success = minidump_generator_.WriteMinidumpToFile(
-                       minidump_path, signo, sighandler_ebp, sig_ctx);
-
-    // Unblock the signals.
-    if (blocked) {
-      sigprocmask(SIG_SETMASK, &sig_old, &sig_old);
-    }
-
-    if (callback_)
-      success = callback_(dump_path_c_, guid_str,
-                          callback_context_, success);
+    next_minidump_path_ = minidump_path;
+    next_minidump_path_c_ = next_minidump_path_.c_str();
   }
-  return success;
 }
 
 }  // namespace google_breakpad

--- a/toolkit/crashreporter/google-breakpad/src/client/linux/handler/exception_handler.h
+++ b/toolkit/crashreporter/google-breakpad/src/client/linux/handler/exception_handler.h
@@ -121,16 +121,17 @@ class ExceptionHandler {
                    bool install_handler);
   ~ExceptionHandler();
 
   // Get and set the minidump path.
   string dump_path() const { return dump_path_; }
   void set_dump_path(const string &dump_path) {
     dump_path_ = dump_path;
     dump_path_c_ = dump_path_.c_str();
+    UpdateNextID();
   }
 
   // Writes a minidump immediately.  This can be used to capture the
   // execution state independently of a crash.  Returns true on success.
   bool WriteMinidump();
 
   // Convenience form of WriteMinidump which does not require an
   // ExceptionHandler instance.
@@ -155,27 +156,42 @@ class ExceptionHandler {
   // that signal handler's frame, and sig_ctx is an out parameter
   // that will be set to point at the sigcontext that was placed
   // on the stack by the kernel.  You can pass zero and NULL
   // for the second and third parameters if you are not calling
   // this from a signal handler.
   bool InternalWriteMinidump(int signo, uintptr_t sighandler_ebp,
                              struct sigcontext **sig_ctx);
 
+  // Generates a new ID and stores it in next_minidump_id, and stores the
+  // path of the next minidump to be written in next_minidump_path_.
+  void UpdateNextID();
+
  private:
   FilterCallback filter_;
   MinidumpCallback callback_;
   void *callback_context_;
 
   // The directory in which a minidump will be written, set by the dump_path
   // argument to the constructor, or set_dump_path.
   string dump_path_;
-  // C style dump path. Keep this when setting dump path, since calling
-  // c_str() of std::string when crashing may not be safe.
+
+  // The basename of the next minidump to be written, without the extension
+  string next_minidump_id_;
+
+  // The full pathname of the next minidump to be written, including the file
+  // extension
+  string next_minidump_path_;
+
+  // Pointers to C-string representations of the above. These are set
+  // when the above are set so we can avoid calling c_str during
+  // an exception.
   const char *dump_path_c_;
+  const char *next_minidump_id_c_;
+  const char *next_minidump_path_c_;
 
   // True if the ExceptionHandler installed an unhandled exception filter
   // when created (with an install_handler parameter set to true).
   bool installed_handler_;
 
   // Keep the previous handlers for the signal.
   typedef void (*sighandler_t)(int);
   std::map<int, sighandler_t> old_handlers_;

new file mode 100644
--- /dev/null
+++ b/toolkit/crashreporter/google-breakpad/src/client/mac/handler/breakpad_exc_server.c
@@ -0,0 +1,1750 @@
+/*
+ * IDENTIFICATION:
+ * stub generated Mon Jun 16 18:08:10 2008
+ * with a MiG generated Tue Feb 19 02:01:43 PST 2008 by root@b75.local
+ * OPTIONS: 
+ */
+
+/* Module exc */
+
+#define	__MIG_check__Request__exc_subsystem__ 1
+#define	__NDR_convert__Request__exc_subsystem__ 1
+
+#include <string.h>
+#include <mach/ndr.h>
+#include <mach/boolean.h>
+#include <mach/kern_return.h>
+#include <mach/notify.h>
+#include <mach/mach_types.h>
+#include <mach/message.h>
+#include <mach/mig_errors.h>
+#include <mach/port.h>
+
+#include <mach/std_types.h>
+#include <mach/mig.h>
+#include <mach/mig.h>
+#include <mach/mach_types.h>
+
+#ifndef	mig_internal
+#define	mig_internal	static __inline__
+#endif	/* mig_internal */
+
+#ifndef	mig_external
+#define mig_external
+#endif	/* mig_external */
+
+#if	!defined(__MigTypeCheck) && defined(TypeCheck)
+#define	__MigTypeCheck		TypeCheck	/* Legacy setting */
+#endif	/* !defined(__MigTypeCheck) */
+
+#if	!defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
+#define	__MigKernelSpecificCode	_MIG_KERNEL_SPECIFIC_CODE_	/* Legacy setting */
+#endif	/* !defined(__MigKernelSpecificCode) */
+
+#ifndef	LimitCheck
+#define	LimitCheck 0
+#endif	/* LimitCheck */
+
+#ifndef	min
+#define	min(a,b)  ( ((a) < (b))? (a): (b) )
+#endif	/* min */
+
+#if !defined(_WALIGN_)
+#define _WALIGN_(x) (((x) + 3) & ~3)
+#endif /* !defined(_WALIGN_) */
+
+#if !defined(_WALIGNSZ_)
+#define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
+#endif /* !defined(_WALIGNSZ_) */
+
+#ifndef	UseStaticTemplates
+#define	UseStaticTemplates	0
+#endif	/* UseStaticTemplates */
+
+#ifndef	__DeclareRcvRpc
+#define	__DeclareRcvRpc(_NUM_, _NAME_)
+#endif	/* __DeclareRcvRpc */
+
+#ifndef	__BeforeRcvRpc
+#define	__BeforeRcvRpc(_NUM_, _NAME_)
+#endif	/* __BeforeRcvRpc */
+
+#ifndef	__AfterRcvRpc
+#define	__AfterRcvRpc(_NUM_, _NAME_)
+#endif	/* __AfterRcvRpc */
+
+#ifndef	__DeclareRcvSimple
+#define	__DeclareRcvSimple(_NUM_, _NAME_)
+#endif	/* __DeclareRcvSimple */
+
+#ifndef	__BeforeRcvSimple
+#define	__BeforeRcvSimple(_NUM_, _NAME_)
+#endif	/* __BeforeRcvSimple */
+
+#ifndef	__AfterRcvSimple
+#define	__AfterRcvSimple(_NUM_, _NAME_)
+#endif	/* __AfterRcvSimple */
+
+#define novalue void
+
+#define msgh_request_port	msgh_local_port
+#define MACH_MSGH_BITS_REQUEST(bits)	MACH_MSGH_BITS_LOCAL(bits)
+#define msgh_reply_port		msgh_remote_port
+#define MACH_MSGH_BITS_REPLY(bits)	MACH_MSGH_BITS_REMOTE(bits)
+
+#define MIG_RETURN_ERROR(X, code)	{\
+				((mig_reply_error_t *)X)->RetCode = code;\
+				((mig_reply_error_t *)X)->NDR = NDR_record;\
+				return;\
+				}
+
+/* typedefs for all requests */
+
+#ifndef __Request__exc_subsystem__defined
+#define __Request__exc_subsystem__defined
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t thread;
+		mach_msg_port_descriptor_t task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+	} __Request__exception_raise_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+		int flavor;
+		mach_msg_type_number_t old_stateCnt;
+		natural_t old_state[144];
+	} __Request__exception_raise_state_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t thread;
+		mach_msg_port_descriptor_t task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+		int flavor;
+		mach_msg_type_number_t old_stateCnt;
+		natural_t old_state[144];
+	} __Request__exception_raise_state_identity_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+#endif /* !__Request__exc_subsystem__defined */
+
+/* typedefs for all replies */
+
+#ifndef __Reply__exc_subsystem__defined
+#define __Reply__exc_subsystem__defined
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+	} __Reply__exception_raise_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		int flavor;
+		mach_msg_type_number_t new_stateCnt;
+		natural_t new_state[144];
+	} __Reply__exception_raise_state_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		int flavor;
+		mach_msg_type_number_t new_stateCnt;
+		natural_t new_state[144];
+	} __Reply__exception_raise_state_identity_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+#endif /* !__Reply__exc_subsystem__defined */
+
+
+/* union of all replies */
+
+#ifndef __ReplyUnion__breakpad_exc_subsystem__defined
+#define __ReplyUnion__breakpad_exc_subsystem__defined
+union __ReplyUnion__breakpad_exc_subsystem {
+	__Reply__exception_raise_t Reply_exception_raise;
+	__Reply__exception_raise_state_t Reply_exception_raise_state;
+	__Reply__exception_raise_state_identity_t Reply_exception_raise_state_identity;
+};
+#endif /* __RequestUnion__breakpad_exc_subsystem__defined */
+/* Forward Declarations */
+
+
+mig_internal novalue _Xexception_raise
+	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+
+mig_internal novalue _Xexception_raise_state
+	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+
+mig_internal novalue _Xexception_raise_state_identity
+	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+
+
+#if ( __MigTypeCheck || __NDR_convert__ )
+#if __MIG_check__Request__exc_subsystem__
+#if !defined(__MIG_check__Request__exception_raise_t__defined)
+#define __MIG_check__Request__exception_raise_t__defined
+#ifndef __NDR_convert__int_rep__Request__exception_raise_t__exception__defined
+#if	defined(__NDR_convert__int_rep__exc__exception_type_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__int_rep__exc__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exception_type_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__int_rep__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exc__int__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__int_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__int_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exc__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__int_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_t__exception__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_t__code__defined
+#if	defined(__NDR_convert__int_rep__exc__exception_data_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__int_rep__exc__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__int_rep__exception_data_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__int_rep__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__int_rep__exc__integer_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__int_rep__exc__integer_t)
+#elif	defined(__NDR_convert__int_rep__integer_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__int_rep__integer_t)
+#elif	defined(__NDR_convert__int_rep__exc__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__int_rep__exc__int32_t)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__int_rep__int32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_t__code__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_t__codeCnt__defined
+#if	defined(__NDR_convert__int_rep__exc__mach_msg_type_number_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__codeCnt__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__codeCnt(a, f) \
+	__NDR_convert__int_rep__exc__mach_msg_type_number_t((mach_msg_type_number_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__mach_msg_type_number_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_t__codeCnt__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_t__codeCnt(a, f) \
+	__NDR_convert__int_rep__mach_msg_type_number_t((mach_msg_type_number_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_t__codeCnt__defined */
+
+#ifndef __NDR_convert__char_rep__Request__exception_raise_t__exception__defined
+#if	defined(__NDR_convert__char_rep__exc__exception_type_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__char_rep__exc__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exception_type_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__char_rep__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exc__int__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__char_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__char_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exc__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__char_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__exception_raise_t__exception__defined */
+
+#ifndef __NDR_convert__char_rep__Request__exception_raise_t__code__defined
+#if	defined(__NDR_convert__char_rep__exc__exception_data_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__char_rep__exc__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__char_rep__exception_data_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__char_rep__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__char_rep__exc__integer_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__char_rep__exc__integer_t)
+#elif	defined(__NDR_convert__char_rep__integer_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__char_rep__integer_t)
+#elif	defined(__NDR_convert__char_rep__exc__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__char_rep__exc__int32_t)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__char_rep__int32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__exception_raise_t__code__defined */
+
+#ifndef __NDR_convert__float_rep__Request__exception_raise_t__exception__defined
+#if	defined(__NDR_convert__float_rep__exc__exception_type_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__float_rep__exc__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exception_type_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__float_rep__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exc__int__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__float_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__float_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exc__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__float_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__exception(a, f) \
+	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__exception_raise_t__exception__defined */
+
+#ifndef __NDR_convert__float_rep__Request__exception_raise_t__code__defined
+#if	defined(__NDR_convert__float_rep__exc__exception_data_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__float_rep__exc__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__float_rep__exception_data_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__float_rep__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__float_rep__exc__integer_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__float_rep__exc__integer_t)
+#elif	defined(__NDR_convert__float_rep__integer_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__float_rep__integer_t)
+#elif	defined(__NDR_convert__float_rep__exc__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__float_rep__exc__int32_t)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__float_rep__int32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__exception_raise_t__code__defined */
+
+
+mig_internal kern_return_t __MIG_check__Request__exception_raise_t(__attribute__((__unused__)) __Request__exception_raise_t *In0P)
+{
+
+	typedef __Request__exception_raise_t __Request;
+#if	__MigTypeCheck
+	unsigned int msgh_size;
+#endif	/* __MigTypeCheck */
+
+#if	__MigTypeCheck
+	msgh_size = In0P->Head.msgh_size;
+	if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+	    (In0P->msgh_body.msgh_descriptor_count != 2) ||
+	    (msgh_size < (mach_msg_size_t)(sizeof(__Request) - 8)) ||  (msgh_size > (mach_msg_size_t)sizeof(__Request))
+)
+		return MIG_BAD_ARGUMENTS;
+#endif	/* __MigTypeCheck */
+
+#if	__MigTypeCheck
+	if (In0P->thread.type != MACH_MSG_PORT_DESCRIPTOR ||
+	    In0P->thread.disposition != 17)
+		return MIG_TYPE_ERROR;
+#endif	/* __MigTypeCheck */
+
+#if	__MigTypeCheck
+	if (In0P->task.type != MACH_MSG_PORT_DESCRIPTOR ||
+	    In0P->task.disposition != 17)
+		return MIG_TYPE_ERROR;
+#endif	/* __MigTypeCheck */
+
+#if defined(__NDR_convert__int_rep__Request__exception_raise_t__codeCnt__defined)
+	if (In0P->NDR.int_rep != NDR_record.int_rep)
+		__NDR_convert__int_rep__Request__exception_raise_t__codeCnt(&In0P->codeCnt, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_t__codeCnt__defined */
+#if	__MigTypeCheck
+	if (msgh_size != (mach_msg_size_t)(sizeof(__Request) - 8) + ((4 * In0P->codeCnt)))
+		return MIG_BAD_ARGUMENTS;
+#endif	/* __MigTypeCheck */
+
+#if	defined(__NDR_convert__int_rep__Request__exception_raise_t__exception__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_t__code__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_t__codeCnt__defined)
+	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+#if defined(__NDR_convert__int_rep__Request__exception_raise_t__exception__defined)
+		__NDR_convert__int_rep__Request__exception_raise_t__exception(&In0P->exception, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_t__exception__defined */
+#if defined(__NDR_convert__int_rep__Request__exception_raise_t__code__defined)
+		__NDR_convert__int_rep__Request__exception_raise_t__code(&In0P->code, In0P->NDR.int_rep, In0P->codeCnt);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_t__code__defined */
+	}
+#endif	/* defined(__NDR_convert__int_rep...) */
+
+#if	defined(__NDR_convert__char_rep__Request__exception_raise_t__exception__defined) || \
+	defined(__NDR_convert__char_rep__Request__exception_raise_t__code__defined) || \
+	0
+	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+#if defined(__NDR_convert__char_rep__Request__exception_raise_t__exception__defined)
+		__NDR_convert__char_rep__Request__exception_raise_t__exception(&In0P->exception, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__exception_raise_t__exception__defined */
+#if defined(__NDR_convert__char_rep__Request__exception_raise_t__code__defined)
+		__NDR_convert__char_rep__Request__exception_raise_t__code(&In0P->code, In0P->NDR.char_rep, In0P->codeCnt);
+#endif	/* __NDR_convert__char_rep__Request__exception_raise_t__code__defined */
+	}
+#endif	/* defined(__NDR_convert__char_rep...) */
+
+#if	defined(__NDR_convert__float_rep__Request__exception_raise_t__exception__defined) || \
+	defined(__NDR_convert__float_rep__Request__exception_raise_t__code__defined) || \
+	0
+	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+#if defined(__NDR_convert__float_rep__Request__exception_raise_t__exception__defined)
+		__NDR_convert__float_rep__Request__exception_raise_t__exception(&In0P->exception, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__exception_raise_t__exception__defined */
+#if defined(__NDR_convert__float_rep__Request__exception_raise_t__code__defined)
+		__NDR_convert__float_rep__Request__exception_raise_t__code(&In0P->code, In0P->NDR.float_rep, In0P->codeCnt);
+#endif	/* __NDR_convert__float_rep__Request__exception_raise_t__code__defined */
+	}
+#endif	/* defined(__NDR_convert__float_rep...) */
+
+	return MACH_MSG_SUCCESS;
+}
+#endif /* !defined(__MIG_check__Request__exception_raise_t__defined) */
+#endif /* __MIG_check__Request__exc_subsystem__ */
+#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+
+
+/* Routine exception_raise */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t breakpad_exception_raise
+(
+	mach_port_t exception_port,
+	mach_port_t thread,
+	mach_port_t task,
+	exception_type_t exception,
+	exception_data_t code,
+	mach_msg_type_number_t codeCnt
+);
+
+/* Routine exception_raise */
+mig_internal novalue _Xexception_raise
+	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+{
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t thread;
+		mach_msg_port_descriptor_t task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+		mach_msg_trailer_t trailer;
+	} Request;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+	typedef __Request__exception_raise_t __Request;
+	typedef __Reply__exception_raise_t Reply;
+
+	/*
+	 * typedef struct {
+	 * 	mach_msg_header_t Head;
+	 * 	NDR_record_t NDR;
+	 * 	kern_return_t RetCode;
+	 * } mig_reply_error_t;
+	 */
+
+	Request *In0P = (Request *) InHeadP;
+	Reply *OutP = (Reply *) OutHeadP;
+#ifdef	__MIG_check__Request__exception_raise_t__defined
+	kern_return_t check_result;
+#endif	/* __MIG_check__Request__exception_raise_t__defined */
+
+	__DeclareRcvRpc(2401, "exception_raise")
+	__BeforeRcvRpc(2401, "exception_raise")
+
+#if	defined(__MIG_check__Request__exception_raise_t__defined)
+	check_result = __MIG_check__Request__exception_raise_t((__Request *)In0P);
+	if (check_result != MACH_MSG_SUCCESS)
+		{ MIG_RETURN_ERROR(OutP, check_result); }
+#endif	/* defined(__MIG_check__Request__exception_raise_t__defined) */
+
+	OutP->RetCode = breakpad_exception_raise(In0P->Head.msgh_request_port, In0P->thread.name, In0P->task.name, In0P->exception, In0P->code, In0P->codeCnt);
+
+	OutP->NDR = NDR_record;
+
+
+	__AfterRcvRpc(2401, "exception_raise")
+}
+
+#if ( __MigTypeCheck || __NDR_convert__ )
+#if __MIG_check__Request__exc_subsystem__
+#if !defined(__MIG_check__Request__exception_raise_state_t__defined)
+#define __MIG_check__Request__exception_raise_state_t__defined
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined
+#if	defined(__NDR_convert__int_rep__exc__exception_type_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__int_rep__exc__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exception_type_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__int_rep__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exc__int__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__int_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__int_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exc__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__int_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_t__code__defined
+#if	defined(__NDR_convert__int_rep__exc__exception_data_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__int_rep__exc__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__int_rep__exception_data_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__int_rep__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__int_rep__exc__integer_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__int_rep__exc__integer_t)
+#elif	defined(__NDR_convert__int_rep__integer_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__int_rep__integer_t)
+#elif	defined(__NDR_convert__int_rep__exc__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__int_rep__exc__int32_t)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__int_rep__int32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_t__code__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_t__codeCnt__defined
+#if	defined(__NDR_convert__int_rep__exc__mach_msg_type_number_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__codeCnt__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__codeCnt(a, f) \
+	__NDR_convert__int_rep__exc__mach_msg_type_number_t((mach_msg_type_number_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__mach_msg_type_number_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__codeCnt__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__codeCnt(a, f) \
+	__NDR_convert__int_rep__mach_msg_type_number_t((mach_msg_type_number_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_t__codeCnt__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_t__flavor__defined
+#if	defined(__NDR_convert__int_rep__exc__int__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__int_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__int_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exc__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__int_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_t__flavor__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined
+#if	defined(__NDR_convert__int_rep__exc__thread_state_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__int_rep__exc__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__int_rep__thread_state_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__int_rep__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__int_rep__exc__natural_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__int_rep__exc__natural_t)
+#elif	defined(__NDR_convert__int_rep__natural_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__int_rep__natural_t)
+#elif	defined(__NDR_convert__int_rep__exc__uint32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__int_rep__exc__uint32_t)
+#elif	defined(__NDR_convert__int_rep__uint32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__int_rep__uint32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_t__old_stateCnt__defined
+#if	defined(__NDR_convert__int_rep__exc__mach_msg_type_number_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_stateCnt__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_stateCnt(a, f) \
+	__NDR_convert__int_rep__exc__mach_msg_type_number_t((mach_msg_type_number_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__mach_msg_type_number_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_stateCnt__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_t__old_stateCnt(a, f) \
+	__NDR_convert__int_rep__mach_msg_type_number_t((mach_msg_type_number_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_t__old_stateCnt__defined */
+
+#ifndef __NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined
+#if	defined(__NDR_convert__char_rep__exc__exception_type_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__char_rep__exc__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exception_type_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__char_rep__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exc__int__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__char_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__char_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exc__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__char_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined */
+
+#ifndef __NDR_convert__char_rep__Request__exception_raise_state_t__code__defined
+#if	defined(__NDR_convert__char_rep__exc__exception_data_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__char_rep__exc__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__char_rep__exception_data_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__char_rep__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__char_rep__exc__integer_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__char_rep__exc__integer_t)
+#elif	defined(__NDR_convert__char_rep__integer_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__char_rep__integer_t)
+#elif	defined(__NDR_convert__char_rep__exc__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__char_rep__exc__int32_t)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__char_rep__int32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__exception_raise_state_t__code__defined */
+
+#ifndef __NDR_convert__char_rep__Request__exception_raise_state_t__flavor__defined
+#if	defined(__NDR_convert__char_rep__exc__int__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__char_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__char_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exc__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__char_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__exception_raise_state_t__flavor__defined */
+
+#ifndef __NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined
+#if	defined(__NDR_convert__char_rep__exc__thread_state_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__char_rep__exc__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__char_rep__thread_state_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__char_rep__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__char_rep__exc__natural_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__char_rep__exc__natural_t)
+#elif	defined(__NDR_convert__char_rep__natural_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__char_rep__natural_t)
+#elif	defined(__NDR_convert__char_rep__exc__uint32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__char_rep__exc__uint32_t)
+#elif	defined(__NDR_convert__char_rep__uint32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__char_rep__uint32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined */
+
+#ifndef __NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined
+#if	defined(__NDR_convert__float_rep__exc__exception_type_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__float_rep__exc__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exception_type_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__float_rep__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exc__int__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__float_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__float_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exc__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__float_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__exception(a, f) \
+	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined */
+
+#ifndef __NDR_convert__float_rep__Request__exception_raise_state_t__code__defined
+#if	defined(__NDR_convert__float_rep__exc__exception_data_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__float_rep__exc__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__float_rep__exception_data_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__float_rep__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__float_rep__exc__integer_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__float_rep__exc__integer_t)
+#elif	defined(__NDR_convert__float_rep__integer_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__float_rep__integer_t)
+#elif	defined(__NDR_convert__float_rep__exc__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__float_rep__exc__int32_t)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__float_rep__int32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__exception_raise_state_t__code__defined */
+
+#ifndef __NDR_convert__float_rep__Request__exception_raise_state_t__flavor__defined
+#if	defined(__NDR_convert__float_rep__exc__int__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__float_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__float_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exc__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__float_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__flavor__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__flavor(a, f) \
+	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__exception_raise_state_t__flavor__defined */
+
+#ifndef __NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined
+#if	defined(__NDR_convert__float_rep__exc__thread_state_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__float_rep__exc__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__float_rep__thread_state_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__float_rep__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__float_rep__exc__natural_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__float_rep__exc__natural_t)
+#elif	defined(__NDR_convert__float_rep__natural_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__float_rep__natural_t)
+#elif	defined(__NDR_convert__float_rep__exc__uint32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__float_rep__exc__uint32_t)
+#elif	defined(__NDR_convert__float_rep__uint32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__float_rep__uint32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined */
+
+
+mig_internal kern_return_t __MIG_check__Request__exception_raise_state_t(__attribute__((__unused__)) __Request__exception_raise_state_t *In0P, __attribute__((__unused__)) __Request__exception_raise_state_t **In1PP)
+{
+
+	typedef __Request__exception_raise_state_t __Request;
+	__Request *In1P;
+#if	__MigTypeCheck
+	unsigned int msgh_size;
+#endif	/* __MigTypeCheck */
+	unsigned int msgh_size_delta;
+
+#if	__MigTypeCheck
+	msgh_size = In0P->Head.msgh_size;
+	if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+	    (msgh_size < (mach_msg_size_t)(sizeof(__Request) - 584)) ||  (msgh_size > (mach_msg_size_t)sizeof(__Request)))
+		return MIG_BAD_ARGUMENTS;
+#endif	/* __MigTypeCheck */
+
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_t__codeCnt__defined)
+	if (In0P->NDR.int_rep != NDR_record.int_rep)
+		__NDR_convert__int_rep__Request__exception_raise_state_t__codeCnt(&In0P->codeCnt, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_t__codeCnt__defined */
+	msgh_size_delta = (4 * In0P->codeCnt);
+#if	__MigTypeCheck
+	if (msgh_size < (mach_msg_size_t)(sizeof(__Request) - 584) + msgh_size_delta)
+		return MIG_BAD_ARGUMENTS;
+	msgh_size -= msgh_size_delta;
+#endif	/* __MigTypeCheck */
+
+	*In1PP = In1P = (__Request *) ((pointer_t) In0P + msgh_size_delta - 8);
+
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_t__old_stateCnt__defined)
+	if (In0P->NDR.int_rep != NDR_record.int_rep)
+		__NDR_convert__int_rep__Request__exception_raise_state_t__old_stateCnt(&In1P->old_stateCnt, In1P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_t__old_stateCnt__defined */
+#if	__MigTypeCheck
+	if (msgh_size != (mach_msg_size_t)(sizeof(__Request) - 584) + ((4 * In1P->old_stateCnt)))
+		return MIG_BAD_ARGUMENTS;
+#endif	/* __MigTypeCheck */
+
+#if	defined(__NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_state_t__code__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_state_t__codeCnt__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_state_t__flavor__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_state_t__old_stateCnt__defined)
+	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined)
+		__NDR_convert__int_rep__Request__exception_raise_state_t__exception(&In0P->exception, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_t__exception__defined */
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_t__code__defined)
+		__NDR_convert__int_rep__Request__exception_raise_state_t__code(&In0P->code, In0P->NDR.int_rep, In0P->codeCnt);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_t__code__defined */
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_t__flavor__defined)
+		__NDR_convert__int_rep__Request__exception_raise_state_t__flavor(&In1P->flavor, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_t__flavor__defined */
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined)
+		__NDR_convert__int_rep__Request__exception_raise_state_t__old_state(&In1P->old_state, In0P->NDR.int_rep, In1P->old_stateCnt);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_t__old_state__defined */
+	}
+#endif	/* defined(__NDR_convert__int_rep...) */
+
+#if	defined(__NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined) || \
+	defined(__NDR_convert__char_rep__Request__exception_raise_state_t__code__defined) || \
+	0 || \
+	defined(__NDR_convert__char_rep__Request__exception_raise_state_t__flavor__defined) || \
+	defined(__NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined) || \
+	0
+	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+#if defined(__NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined)
+		__NDR_convert__char_rep__Request__exception_raise_state_t__exception(&In0P->exception, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__exception_raise_state_t__exception__defined */
+#if defined(__NDR_convert__char_rep__Request__exception_raise_state_t__code__defined)
+		__NDR_convert__char_rep__Request__exception_raise_state_t__code(&In0P->code, In0P->NDR.char_rep, In0P->codeCnt);
+#endif	/* __NDR_convert__char_rep__Request__exception_raise_state_t__code__defined */
+#if defined(__NDR_convert__char_rep__Request__exception_raise_state_t__flavor__defined)
+		__NDR_convert__char_rep__Request__exception_raise_state_t__flavor(&In1P->flavor, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__exception_raise_state_t__flavor__defined */
+#if defined(__NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined)
+		__NDR_convert__char_rep__Request__exception_raise_state_t__old_state(&In1P->old_state, In0P->NDR.char_rep, In1P->old_stateCnt);
+#endif	/* __NDR_convert__char_rep__Request__exception_raise_state_t__old_state__defined */
+	}
+#endif	/* defined(__NDR_convert__char_rep...) */
+
+#if	defined(__NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined) || \
+	defined(__NDR_convert__float_rep__Request__exception_raise_state_t__code__defined) || \
+	0 || \
+	defined(__NDR_convert__float_rep__Request__exception_raise_state_t__flavor__defined) || \
+	defined(__NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined) || \
+	0
+	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+#if defined(__NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined)
+		__NDR_convert__float_rep__Request__exception_raise_state_t__exception(&In0P->exception, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__exception_raise_state_t__exception__defined */
+#if defined(__NDR_convert__float_rep__Request__exception_raise_state_t__code__defined)
+		__NDR_convert__float_rep__Request__exception_raise_state_t__code(&In0P->code, In0P->NDR.float_rep, In0P->codeCnt);
+#endif	/* __NDR_convert__float_rep__Request__exception_raise_state_t__code__defined */
+#if defined(__NDR_convert__float_rep__Request__exception_raise_state_t__flavor__defined)
+		__NDR_convert__float_rep__Request__exception_raise_state_t__flavor(&In1P->flavor, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__exception_raise_state_t__flavor__defined */
+#if defined(__NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined)
+		__NDR_convert__float_rep__Request__exception_raise_state_t__old_state(&In1P->old_state, In0P->NDR.float_rep, In1P->old_stateCnt);
+#endif	/* __NDR_convert__float_rep__Request__exception_raise_state_t__old_state__defined */
+	}
+#endif	/* defined(__NDR_convert__float_rep...) */
+
+	return MACH_MSG_SUCCESS;
+}
+#endif /* !defined(__MIG_check__Request__exception_raise_state_t__defined) */
+#endif /* __MIG_check__Request__exc_subsystem__ */
+#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+
+
+/* Routine exception_raise_state */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t breakpad_exception_raise_state
+(
+	mach_port_t exception_port,
+	exception_type_t exception,
+	const 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
+);
+
+/* Routine exception_raise_state */
+mig_internal novalue _Xexception_raise_state
+	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+{
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+		int flavor;
+		mach_msg_type_number_t old_stateCnt;
+		natural_t old_state[144];
+		mach_msg_trailer_t trailer;
+	} Request;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+	typedef __Request__exception_raise_state_t __Request;
+	typedef __Reply__exception_raise_state_t Reply;
+
+	/*
+	 * typedef struct {
+	 * 	mach_msg_header_t Head;
+	 * 	NDR_record_t NDR;
+	 * 	kern_return_t RetCode;
+	 * } mig_reply_error_t;
+	 */
+
+	Request *In0P = (Request *) InHeadP;
+	Request *In1P;
+	Reply *OutP = (Reply *) OutHeadP;
+#ifdef	__MIG_check__Request__exception_raise_state_t__defined
+	kern_return_t check_result;
+#endif	/* __MIG_check__Request__exception_raise_state_t__defined */
+
+	__DeclareRcvRpc(2402, "exception_raise_state")
+	__BeforeRcvRpc(2402, "exception_raise_state")
+
+#if	defined(__MIG_check__Request__exception_raise_state_t__defined)
+	check_result = __MIG_check__Request__exception_raise_state_t((__Request *)In0P, (__Request **)&In1P);
+	if (check_result != MACH_MSG_SUCCESS)
+		{ MIG_RETURN_ERROR(OutP, check_result); }
+#endif	/* defined(__MIG_check__Request__exception_raise_state_t__defined) */
+
+	OutP->new_stateCnt = 144;
+
+	OutP->RetCode = breakpad_exception_raise_state(In0P->Head.msgh_request_port, In0P->exception, In0P->code, In0P->codeCnt, &In1P->flavor, In1P->old_state, In1P->old_stateCnt, OutP->new_state, &OutP->new_stateCnt);
+	if (OutP->RetCode != KERN_SUCCESS) {
+		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+	}
+
+	OutP->NDR = NDR_record;
+
+
+	OutP->flavor = In1P->flavor;
+	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply) - 576) + (((4 * OutP->new_stateCnt)));
+
+	__AfterRcvRpc(2402, "exception_raise_state")
+}
+
+#if ( __MigTypeCheck || __NDR_convert__ )
+#if __MIG_check__Request__exc_subsystem__
+#if !defined(__MIG_check__Request__exception_raise_state_identity_t__defined)
+#define __MIG_check__Request__exception_raise_state_identity_t__defined
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined
+#if	defined(__NDR_convert__int_rep__exc__exception_type_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__int_rep__exc__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exception_type_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__int_rep__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exc__int__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__int_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__int_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exc__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__int_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined
+#if	defined(__NDR_convert__int_rep__exc__exception_data_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__int_rep__exc__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__int_rep__exception_data_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__int_rep__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__int_rep__exc__integer_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__int_rep__exc__integer_t)
+#elif	defined(__NDR_convert__int_rep__integer_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__int_rep__integer_t)
+#elif	defined(__NDR_convert__int_rep__exc__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__int_rep__exc__int32_t)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__int_rep__int32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_identity_t__codeCnt__defined
+#if	defined(__NDR_convert__int_rep__exc__mach_msg_type_number_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__codeCnt__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__codeCnt(a, f) \
+	__NDR_convert__int_rep__exc__mach_msg_type_number_t((mach_msg_type_number_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__mach_msg_type_number_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__codeCnt__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__codeCnt(a, f) \
+	__NDR_convert__int_rep__mach_msg_type_number_t((mach_msg_type_number_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__codeCnt__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor__defined
+#if	defined(__NDR_convert__int_rep__exc__int__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__int_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__int_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__int_rep__exc__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__int_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__int32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined
+#if	defined(__NDR_convert__int_rep__exc__thread_state_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__int_rep__exc__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__int_rep__thread_state_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__int_rep__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__int_rep__exc__natural_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__int_rep__exc__natural_t)
+#elif	defined(__NDR_convert__int_rep__natural_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__int_rep__natural_t)
+#elif	defined(__NDR_convert__int_rep__exc__uint32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__int_rep__exc__uint32_t)
+#elif	defined(__NDR_convert__int_rep__uint32_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__int_rep__uint32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined */
+
+#ifndef __NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_stateCnt__defined
+#if	defined(__NDR_convert__int_rep__exc__mach_msg_type_number_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_stateCnt__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_stateCnt(a, f) \
+	__NDR_convert__int_rep__exc__mach_msg_type_number_t((mach_msg_type_number_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__mach_msg_type_number_t__defined)
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_stateCnt__defined
+#define	__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_stateCnt(a, f) \
+	__NDR_convert__int_rep__mach_msg_type_number_t((mach_msg_type_number_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_stateCnt__defined */
+
+#ifndef __NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined
+#if	defined(__NDR_convert__char_rep__exc__exception_type_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__char_rep__exc__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exception_type_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__char_rep__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exc__int__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__char_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__char_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exc__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__char_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined */
+
+#ifndef __NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined
+#if	defined(__NDR_convert__char_rep__exc__exception_data_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__char_rep__exc__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__char_rep__exception_data_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__char_rep__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__char_rep__exc__integer_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__char_rep__exc__integer_t)
+#elif	defined(__NDR_convert__char_rep__integer_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__char_rep__integer_t)
+#elif	defined(__NDR_convert__char_rep__exc__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__char_rep__exc__int32_t)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__char_rep__int32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined */
+
+#ifndef __NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor__defined
+#if	defined(__NDR_convert__char_rep__exc__int__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__char_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__char_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__char_rep__exc__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__char_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__int32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor__defined */
+
+#ifndef __NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined
+#if	defined(__NDR_convert__char_rep__exc__thread_state_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__char_rep__exc__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__char_rep__thread_state_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__char_rep__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__char_rep__exc__natural_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__char_rep__exc__natural_t)
+#elif	defined(__NDR_convert__char_rep__natural_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__char_rep__natural_t)
+#elif	defined(__NDR_convert__char_rep__exc__uint32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__char_rep__exc__uint32_t)
+#elif	defined(__NDR_convert__char_rep__uint32_t__defined)
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__char_rep__uint32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined */
+
+#ifndef __NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined
+#if	defined(__NDR_convert__float_rep__exc__exception_type_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__float_rep__exc__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exception_type_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__float_rep__exception_type_t((exception_type_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exc__int__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__float_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__float_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exc__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__float_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception(a, f) \
+	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined */
+
+#ifndef __NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined
+#if	defined(__NDR_convert__float_rep__exc__exception_data_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__float_rep__exc__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__float_rep__exception_data_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__float_rep__exception_data_t((exception_data_t *)(a), f, c)
+#elif	defined(__NDR_convert__float_rep__exc__integer_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__float_rep__exc__integer_t)
+#elif	defined(__NDR_convert__float_rep__integer_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((integer_t *)(a), f, c, __NDR_convert__float_rep__integer_t)
+#elif	defined(__NDR_convert__float_rep__exc__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__float_rep__exc__int32_t)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code(a, f, c) \
+	__NDR_convert__ARRAY((int32_t *)(a), f, c, __NDR_convert__float_rep__int32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined */
+
+#ifndef __NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor__defined
+#if	defined(__NDR_convert__float_rep__exc__int__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__float_rep__exc__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__float_rep__int((int *)(a), f)
+#elif	defined(__NDR_convert__float_rep__exc__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__float_rep__exc__int32_t((int32_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__int32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor(a, f) \
+	__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor__defined */
+
+#ifndef __NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined
+#if	defined(__NDR_convert__float_rep__exc__thread_state_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__float_rep__exc__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__float_rep__thread_state_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__float_rep__thread_state_t((thread_state_t *)(a), f, c)
+#elif	defined(__NDR_convert__float_rep__exc__natural_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__float_rep__exc__natural_t)
+#elif	defined(__NDR_convert__float_rep__natural_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((natural_t *)(a), f, c, __NDR_convert__float_rep__natural_t)
+#elif	defined(__NDR_convert__float_rep__exc__uint32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__float_rep__exc__uint32_t)
+#elif	defined(__NDR_convert__float_rep__uint32_t__defined)
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined
+#define	__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state(a, f, c) \
+	__NDR_convert__ARRAY((uint32_t *)(a), f, c, __NDR_convert__float_rep__uint32_t)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined */
+
+
+mig_internal kern_return_t __MIG_check__Request__exception_raise_state_identity_t(__attribute__((__unused__)) __Request__exception_raise_state_identity_t *In0P, __attribute__((__unused__)) __Request__exception_raise_state_identity_t **In1PP)
+{
+
+	typedef __Request__exception_raise_state_identity_t __Request;
+	__Request *In1P;
+#if	__MigTypeCheck
+	unsigned int msgh_size;
+#endif	/* __MigTypeCheck */
+	unsigned int msgh_size_delta;
+
+#if	__MigTypeCheck
+	msgh_size = In0P->Head.msgh_size;
+	if (!(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
+	    (In0P->msgh_body.msgh_descriptor_count != 2) ||
+	    (msgh_size < (mach_msg_size_t)(sizeof(__Request) - 584)) ||  (msgh_size > (mach_msg_size_t)sizeof(__Request))
+)
+		return MIG_BAD_ARGUMENTS;
+#endif	/* __MigTypeCheck */
+
+#if	__MigTypeCheck
+	if (In0P->thread.type != MACH_MSG_PORT_DESCRIPTOR ||
+	    In0P->thread.disposition != 17)
+		return MIG_TYPE_ERROR;
+#endif	/* __MigTypeCheck */
+
+#if	__MigTypeCheck
+	if (In0P->task.type != MACH_MSG_PORT_DESCRIPTOR ||
+	    In0P->task.disposition != 17)
+		return MIG_TYPE_ERROR;
+#endif	/* __MigTypeCheck */
+
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__codeCnt__defined)
+	if (In0P->NDR.int_rep != NDR_record.int_rep)
+		__NDR_convert__int_rep__Request__exception_raise_state_identity_t__codeCnt(&In0P->codeCnt, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__codeCnt__defined */
+	msgh_size_delta = (4 * In0P->codeCnt);
+#if	__MigTypeCheck
+	if (msgh_size < (mach_msg_size_t)(sizeof(__Request) - 584) + msgh_size_delta)
+		return MIG_BAD_ARGUMENTS;
+	msgh_size -= msgh_size_delta;
+#endif	/* __MigTypeCheck */
+
+	*In1PP = In1P = (__Request *) ((pointer_t) In0P + msgh_size_delta - 8);
+
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_stateCnt__defined)
+	if (In0P->NDR.int_rep != NDR_record.int_rep)
+		__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_stateCnt(&In1P->old_stateCnt, In1P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_stateCnt__defined */
+#if	__MigTypeCheck
+	if (msgh_size != (mach_msg_size_t)(sizeof(__Request) - 584) + ((4 * In1P->old_stateCnt)))
+		return MIG_BAD_ARGUMENTS;
+#endif	/* __MigTypeCheck */
+
+#if	defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__codeCnt__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined) || \
+	defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_stateCnt__defined)
+	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined)
+		__NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception(&In0P->exception, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__exception__defined */
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined)
+		__NDR_convert__int_rep__Request__exception_raise_state_identity_t__code(&In0P->code, In0P->NDR.int_rep, In0P->codeCnt);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__code__defined */
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor__defined)
+		__NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor(&In1P->flavor, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__flavor__defined */
+#if defined(__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined)
+		__NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state(&In1P->old_state, In0P->NDR.int_rep, In1P->old_stateCnt);
+#endif	/* __NDR_convert__int_rep__Request__exception_raise_state_identity_t__old_state__defined */
+	}
+#endif	/* defined(__NDR_convert__int_rep...) */
+
+#if	defined(__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined) || \
+	defined(__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined) || \
+	0 || \
+	defined(__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor__defined) || \
+	defined(__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined) || \
+	0
+	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+#if defined(__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined)
+		__NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception(&In0P->exception, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__exception_raise_state_identity_t__exception__defined */
+#if defined(__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined)
+		__NDR_convert__char_rep__Request__exception_raise_state_identity_t__code(&In0P->code, In0P->NDR.char_rep, In0P->codeCnt);
+#endif	/* __NDR_convert__char_rep__Request__exception_raise_state_identity_t__code__defined */
+#if defined(__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor__defined)
+		__NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor(&In1P->flavor, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__exception_raise_state_identity_t__flavor__defined */
+#if defined(__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined)
+		__NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state(&In1P->old_state, In0P->NDR.char_rep, In1P->old_stateCnt);
+#endif	/* __NDR_convert__char_rep__Request__exception_raise_state_identity_t__old_state__defined */
+	}
+#endif	/* defined(__NDR_convert__char_rep...) */
+
+#if	defined(__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined) || \
+	defined(__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined) || \
+	0 || \
+	defined(__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor__defined) || \
+	defined(__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined) || \
+	0
+	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+#if defined(__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined)
+		__NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception(&In0P->exception, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__exception_raise_state_identity_t__exception__defined */
+#if defined(__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined)
+		__NDR_convert__float_rep__Request__exception_raise_state_identity_t__code(&In0P->code, In0P->NDR.float_rep, In0P->codeCnt);
+#endif	/* __NDR_convert__float_rep__Request__exception_raise_state_identity_t__code__defined */
+#if defined(__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor__defined)
+		__NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor(&In1P->flavor, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__exception_raise_state_identity_t__flavor__defined */
+#if defined(__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined)
+		__NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state(&In1P->old_state, In0P->NDR.float_rep, In1P->old_stateCnt);
+#endif	/* __NDR_convert__float_rep__Request__exception_raise_state_identity_t__old_state__defined */
+	}
+#endif	/* defined(__NDR_convert__float_rep...) */
+
+	return MACH_MSG_SUCCESS;
+}
+#endif /* !defined(__MIG_check__Request__exception_raise_state_identity_t__defined) */
+#endif /* __MIG_check__Request__exc_subsystem__ */
+#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+
+
+/* Routine exception_raise_state_identity */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t breakpad_exception_raise_state_identity
+(
+	mach_port_t exception_port,
+	mach_port_t thread,
+	mach_port_t task,
+	exception_type_t exception,
+	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
+);
+
+/* Routine exception_raise_state_identity */
+mig_internal novalue _Xexception_raise_state_identity
+	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+{
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t thread;
+		mach_msg_port_descriptor_t task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+		int flavor;
+		mach_msg_type_number_t old_stateCnt;
+		natural_t old_state[144];
+		mach_msg_trailer_t trailer;
+	} Request;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+	typedef __Request__exception_raise_state_identity_t __Request;
+	typedef __Reply__exception_raise_state_identity_t Reply;
+
+	/*
+	 * typedef struct {
+	 * 	mach_msg_header_t Head;
+	 * 	NDR_record_t NDR;
+	 * 	kern_return_t RetCode;
+	 * } mig_reply_error_t;
+	 */
+
+	Request *In0P = (Request *) InHeadP;
+	Request *In1P;
+	Reply *OutP = (Reply *) OutHeadP;
+#ifdef	__MIG_check__Request__exception_raise_state_identity_t__defined
+	kern_return_t check_result;
+#endif	/* __MIG_check__Request__exception_raise_state_identity_t__defined */
+
+	__DeclareRcvRpc(2403, "exception_raise_state_identity")
+	__BeforeRcvRpc(2403, "exception_raise_state_identity")
+
+#if	defined(__MIG_check__Request__exception_raise_state_identity_t__defined)
+	check_result = __MIG_check__Request__exception_raise_state_identity_t((__Request *)In0P, (__Request **)&In1P);
+	if (check_result != MACH_MSG_SUCCESS)
+		{ MIG_RETURN_ERROR(OutP, check_result); }
+#endif	/* defined(__MIG_check__Request__exception_raise_state_identity_t__defined) */
+
+	OutP->new_stateCnt = 144;
+
+	OutP->RetCode = breakpad_exception_raise_state_identity(In0P->Head.msgh_request_port, In0P->thread.name, In0P->task.name, In0P->exception, In0P->code, In0P->codeCnt, &In1P->flavor, In1P->old_state, In1P->old_stateCnt, OutP->new_state, &OutP->new_stateCnt);
+	if (OutP->RetCode != KERN_SUCCESS) {
+		MIG_RETURN_ERROR(OutP, OutP->RetCode);
+	}
+
+	OutP->NDR = NDR_record;
+
+
+	OutP->flavor = In1P->flavor;
+	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply) - 576) + (((4 * OutP->new_stateCnt)));
+
+	__AfterRcvRpc(2403, "exception_raise_state_identity")
+}
+
+
+extern boolean_t exc_server(
+		mach_msg_header_t *InHeadP,
+		mach_msg_header_t *OutHeadP);
+
+extern mig_routine_t exc_server_routine(
+		mach_msg_header_t *InHeadP);
+
+
+/* Description of this subsystem, for use in direct RPC */
+const struct breakpad_exc_subsystem {
+	mig_server_routine_t 	server;	/* Server routine */
+	mach_msg_id_t	start;	/* Min routine number */
+	mach_msg_id_t	end;	/* Max routine number + 1 */
+	unsigned int	maxsize;	/* Max msg size */
+	vm_address_t	reserved;	/* Reserved */
+	struct routine_descriptor	/*Array of routine descriptors */
+		routine[3];
+} breakpad_exc_subsystem = {
+	exc_server_routine,
+	2401,
+	2404,
+	(mach_msg_size_t)sizeof(union __ReplyUnion__breakpad_exc_subsystem),
+	(vm_address_t)0,
+	{
+          { (mig_impl_routine_t) 0,
+            (mig_stub_routine_t) _Xexception_raise, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__exception_raise_t)},
+          { (mig_impl_routine_t) 0,
+            (mig_stub_routine_t) _Xexception_raise_state, 9, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__exception_raise_state_t)},
+          { (mig_impl_routine_t) 0,
+            (mig_stub_routine_t) _Xexception_raise_state_identity, 11, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__exception_raise_state_identity_t)},
+	}
+};
+
+mig_external boolean_t exc_server
+	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
+{
+	/*
+	 * typedef struct {
+	 * 	mach_msg_header_t Head;
+	 * 	NDR_record_t NDR;
+	 * 	kern_return_t RetCode;
+	 * } mig_reply_error_t;
+	 */
+
+	register mig_routine_t routine;
+
+	OutHeadP->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(InHeadP->msgh_bits), 0);
+	OutHeadP->msgh_remote_port = InHeadP->msgh_reply_port;
+	/* Minimal size: routine() will update it if different */
+	OutHeadP->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
+	OutHeadP->msgh_local_port = MACH_PORT_NULL;
+	OutHeadP->msgh_id = InHeadP->msgh_id + 100;
+
+	if ((InHeadP->msgh_id > 2403) || (InHeadP->msgh_id < 2401) ||
+	    ((routine = breakpad_exc_subsystem.routine[InHeadP->msgh_id - 2401].stub_routine) == 0)) {
+		((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;
+		((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;
+		return FALSE;
+	}
+	(*routine) (InHeadP, OutHeadP);
+	return TRUE;
+}
+
+mig_external mig_routine_t exc_server_routine
+	(mach_msg_header_t *InHeadP)
+{
+	register int msgh_id;
+
+	msgh_id = InHeadP->msgh_id - 2401;
+
+	if ((msgh_id > 2) || (msgh_id < 0))
+		return 0;
+
+	return breakpad_exc_subsystem.routine[msgh_id].stub_routine;
+}

new file mode 100644
--- /dev/null
+++ b/toolkit/crashreporter/google-breakpad/src/client/mac/handler/breakpad_exc_server.h
@@ -0,0 +1,258 @@
+#ifndef	_exc_user_
+#define	_exc_user_
+
+/* Module exc */
+
+#include <string.h>
+#include <mach/ndr.h>
+#include <mach/boolean.h>
+#include <mach/kern_return.h>
+#include <mach/notify.h>
+#include <mach/mach_types.h>
+#include <mach/message.h>
+#include <mach/mig_errors.h>
+#include <mach/port.h>
+
+#ifdef AUTOTEST
+#ifndef FUNCTION_PTR_T
+#define FUNCTION_PTR_T
+typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
+typedef struct {
+        char            *name;
+        function_ptr_t  function;
+} function_table_entry;
+typedef function_table_entry 	*function_table_t;
+#endif /* FUNCTION_PTR_T */
+#endif /* AUTOTEST */
+
+#ifndef	exc_MSG_COUNT
+#define	exc_MSG_COUNT	3
+#endif	/* exc_MSG_COUNT */
+
+#include <mach/std_types.h>
+#include <mach/mig.h>
+#include <mach/mig.h>
+#include <mach/mach_types.h>
+
+#ifdef __BeforeMigUserHeader
+__BeforeMigUserHeader
+#endif /* __BeforeMigUserHeader */
+
+#include <sys/cdefs.h>
+__BEGIN_DECLS
+
+
+/* Routine exception_raise */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t exception_raise
+(
+	mach_port_t exception_port,
+	mach_port_t thread,
+	mach_port_t task,
+	exception_type_t exception,
+	exception_data_t code,
+	mach_msg_type_number_t codeCnt
+);
+
+/* Routine exception_raise_state */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t exception_raise_state
+(
+	mach_port_t exception_port,
+	exception_type_t exception,
+	const 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
+);
+
+/* Routine exception_raise_state_identity */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t exception_raise_state_identity
+(
+	mach_port_t exception_port,
+	mach_port_t thread,
+	mach_port_t task,
+	exception_type_t exception,
+	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
+);
+
+__END_DECLS
+
+/********************** Caution **************************/
+/* The following data types should be used to calculate  */
+/* maximum message sizes only. The actual message may be */
+/* smaller, and the position of the arguments within the */
+/* message layout may vary from what is presented here.  */
+/* For example, if any of the arguments are variable-    */
+/* sized, and less than the maximum is sent, the data    */
+/* will be packed tight in the actual message to reduce  */
+/* the presence of holes.                                */
+/********************** Caution **************************/
+
+/* typedefs for all requests */
+
+#ifndef __Request__exc_subsystem__defined
+#define __Request__exc_subsystem__defined
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t thread;
+		mach_msg_port_descriptor_t task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+	} __Request__exception_raise_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+		int flavor;
+		mach_msg_type_number_t old_stateCnt;
+		natural_t old_state[144];
+	} __Request__exception_raise_state_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t thread;
+		mach_msg_port_descriptor_t task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+		int flavor;
+		mach_msg_type_number_t old_stateCnt;
+		natural_t old_state[144];
+	} __Request__exception_raise_state_identity_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+#endif /* !__Request__exc_subsystem__defined */
+
+/* union of all requests */
+
+#ifndef __RequestUnion__exc_subsystem__defined
+#define __RequestUnion__exc_subsystem__defined
+union __RequestUnion__exc_subsystem {
+	__Request__exception_raise_t Request_exception_raise;
+	__Request__exception_raise_state_t Request_exception_raise_state;
+	__Request__exception_raise_state_identity_t Request_exception_raise_state_identity;
+};
+#endif /* !__RequestUnion__exc_subsystem__defined */
+/* typedefs for all replies */
+
+#ifndef __Reply__exc_subsystem__defined
+#define __Reply__exc_subsystem__defined
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+	} __Reply__exception_raise_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		int flavor;
+		mach_msg_type_number_t new_stateCnt;
+		natural_t new_state[144];
+	} __Reply__exception_raise_state_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		int flavor;
+		mach_msg_type_number_t new_stateCnt;
+		natural_t new_state[144];
+	} __Reply__exception_raise_state_identity_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+#endif /* !__Reply__exc_subsystem__defined */
+
+/* union of all replies */
+
+#ifndef __ReplyUnion__exc_subsystem__defined
+#define __ReplyUnion__exc_subsystem__defined
+union __ReplyUnion__exc_subsystem {
+	__Reply__exception_raise_t Reply_exception_raise;
+	__Reply__exception_raise_state_t Reply_exception_raise_state;
+	__Reply__exception_raise_state_identity_t Reply_exception_raise_state_identity;
+};
+#endif /* !__RequestUnion__exc_subsystem__defined */
+
+#ifndef subsystem_to_name_map_exc
+#define subsystem_to_name_map_exc \
+    { "exception_raise", 2401 },\
+    { "exception_raise_state", 2402 },\
+    { "exception_raise_state_identity", 2403 }
+#endif
+
+#ifdef __AfterMigUserHeader
+__AfterMigUserHeader
+#endif /* __AfterMigUserHeader */
+
+#endif	 /* _exc_user_ */

new file mode 100644
--- /dev/null
+++ b/toolkit/crashreporter/google-breakpad/src/client/mac/handler/breakpad_nlist_64.cc
@@ -0,0 +1,381 @@
+/*
+ * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ */
+/*
+ * Copyright (c) 1989, 1993
+ * The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+/* nealsid:
+ * This file was copied from libc/gen/nlist.c from Darwin's source code       
+ * The version of nlist used as a base is from 10.5.2, libc-498               
+ * http://www.opensource.apple.com/darwinsource/10.5.2/Libc-498/gen/nlist.c   
+ *                                                                            
+ * The full tarball is at:                                                    
+ * http://www.opensource.apple.com/darwinsource/tarballs/apsl/Libc-498.tar.gz 
+ *                                                                            
+ * I've modified it to be compatible with 64-bit images. However,
+ * 32-bit compatibility has not been retained. 
+*/
+
+#ifdef __LP64__
+
+#include <mach-o/nlist.h>
+#include <mach-o/loader.h>
+#include <mach-o/fat.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include "breakpad_nlist_64.h"
+#include <TargetConditionals.h>
+#include <stdio.h>
+#include <mach/mach.h>
+
+/* Stuff lifted from <a.out.h> and <sys/exec.h> since they are gone */
+/*
+ * Header prepended to each a.out file.
+ */
+struct exec {
+  unsigned short  a_machtype;     /* machine type */
+  unsigned short  a_magic;        /* magic number */
+  unsigned long a_text;         /* size of text segment */
+  unsigned long a_data;         /* size of initialized data */
+  unsigned long a_bss;          /* size of uninitialized data */
+  unsigned long a_syms;         /* size of symbol table */
+  unsigned long a_entry;        /* entry point */
+  unsigned long a_trsize;       /* size of text relocation */
+  unsigned long a_drsize;       /* size of data relocation */
+};
+
+#define OMAGIC  0407            /* old impure format */
+#define NMAGIC  0410            /* read-only text */
+#define ZMAGIC  0413            /* demand load format */
+
+#define N_BADMAG(x)                                                     \
+  (((x).a_magic)!=OMAGIC && ((x).a_magic)!=NMAGIC && ((x).a_magic)!=ZMAGIC)
+#define N_TXTOFF(x)                                     \
+  ((x).a_magic==ZMAGIC ? 0 : sizeof (struct exec))
+#define N_SYMOFF(x)                                                     \
+  (N_TXTOFF(x) + (x).a_text+(x).a_data + (x).a_trsize+(x).a_drsize)
+
+int
+__breakpad_fdnlist_64(int fd, breakpad_nlist *list, const char **symbolNames);
+
+/*
+ * nlist - retreive attributes from name list (string table version)
+ */
+
+int
+breakpad_nlist_64(const char *name,
+                  breakpad_nlist *list,
+                  const char **symbolNames) {
+  int fd, n;
+
+  fd = open(name, O_RDONLY, 0);
+  if (fd < 0)
+    return (-1);
+  n = __breakpad_fdnlist_64(fd, list, symbolNames);
+  (void)close(fd);
+  return (n);
+}
+
+/* Note: __fdnlist() is called from kvm_nlist in libkvm's kvm.c */
+
+int
+__breakpad_fdnlist_64(int fd, breakpad_nlist *list, const char **symbolNames) {
+  register breakpad_nlist *p, *q;
+  breakpad_nlist space[BUFSIZ/sizeof (breakpad_nlist)];
+
+  const register char *s1, *s2;
+  register int n, m;
+  int maxlen, nreq;
+  off_t sa;             /* symbol address */
+  off_t ss;             /* start of strings */
+  struct exec buf;
+  unsigned  arch_offset = 0;
+
+  maxlen = 500;
+  for (q = list, nreq = 0;
+       symbolNames[q-list] && symbolNames[q-list][0];
+       q++, nreq++) {
+
+    q->n_type = 0;
+    q->n_value = 0;
+    q->n_desc = 0;
+    q->n_sect = 0;
+    q->n_un.n_strx = 0;
+  }
+
+  if (read(fd, (char *)&buf, sizeof(buf)) != sizeof(buf) ||
+      (N_BADMAG(buf) && *((long *)&buf) != MH_MAGIC &&
+       NXSwapBigLongToHost(*((long *)&buf)) != FAT_MAGIC) &&
+      /* nealsid: The following is the big-endian ppc64 check */
+      (*((uint32_t*)&buf)) != FAT_MAGIC) {
+    return (-1);
+  }
+
+  /* Deal with fat file if necessary */
+  if (NXSwapBigLongToHost(*((long *)&buf)) == FAT_MAGIC ||
+      /* nealsid: The following is the big-endian ppc64 check */
+      *((int*)&buf) == FAT_MAGIC) {
+    struct host_basic_info hbi;
+    struct fat_header fh;
+    struct fat_arch *fat_archs, *fap;
+    unsigned i;
+    host_t host;
+
+    /* Get our host info */
+    host = mach_host_self();
+    i = HOST_BASIC_INFO_COUNT;
+    kern_return_t kr;
+    if ((kr=host_info(host, HOST_BASIC_INFO,
+                      (host_info_t)(&hbi), &i)) != KERN_SUCCESS) {
+      return (-1);
+    }
+    mach_port_deallocate(mach_task_self(), host);
+
+    /* Read in the fat header */
+    lseek(fd, 0, SEEK_SET);
+    if (read(fd, (char *)&fh, sizeof(fh)) != sizeof(fh)) {
+      return (-1);
+    }
+
+    /* Convert fat_narchs to host byte order */
+    fh.nfat_arch = NXSwapBigLongToHost(fh.nfat_arch);
+
+    /* Read in the fat archs */
+    fat_archs = (struct fat_arch *)malloc(fh.nfat_arch *
+                                          sizeof(struct fat_arch));
+    if (fat_archs == NULL) {
+      return (-1);
+    }
+    if (read(fd, (char *)fat_archs,
+             sizeof(struct fat_arch) * fh.nfat_arch) !=
+        sizeof(struct fat_arch) * fh.nfat_arch) {
+      free(fat_archs);
+      return (-1);
+    }
+
+    /*
+     * Convert archs to host byte ordering (a constraint of
+     * cpusubtype_getbestarch()
+     */
+    for (i = 0; i < fh.nfat_arch; i++) {
+      fat_archs[i].cputype =
+        NXSwapBigLongToHost(fat_archs[i].cputype);
+      fat_archs[i].cpusubtype =
+        NXSwapBigLongToHost(fat_archs[i].cpusubtype);
+      fat_archs[i].offset =
+        NXSwapBigLongToHost(fat_archs[i].offset);
+      fat_archs[i].size =
+        NXSwapBigLongToHost(fat_archs[i].size);
+      fat_archs[i].align =
+        NXSwapBigLongToHost(fat_archs[i].align);
+    }
+
+    fap = NULL;
+    for (i = 0; i < fh.nfat_arch; i++) {
+      /* nealsid: Although the original Apple code uses host_info */
+      /* to retrieve the CPU type, the host_info will still return */
+      /* CPU_TYPE_X86 even if running as an x86_64 binary. Given that */
+      /* this code isn't necessary on i386, I've decided to hardcode */
+      /* looking for a 64-bit binary */
+#if TARGET_CPU_X86_64
+      if (fat_archs[i].cputype == CPU_TYPE_X86_64) {
+#elif TARGET_CPU_PPC64
+      if (fat_archs[i].cputype == CPU_TYPE_POWERPC64) {
+#else
+#error undefined cpu!
+        {
+#endif
+          fap = &fat_archs[i];
+          break;
+        }
+      }
+
+      if (!fap) {
+        free(fat_archs);
+        return (-1);
+      }
+      arch_offset = fap->offset;
+      free(fat_archs);
+
+      /* Read in the beginning of the architecture-specific file */
+      lseek(fd, arch_offset, SEEK_SET);
+      if (read(fd, (char *)&buf, sizeof(buf)) != sizeof(buf)) {
+        return (-1);
+      }
+    }
+
+    if (*((int *)&buf) == MH_MAGIC_64) {
+      struct mach_header_64 mh;
+      struct load_command *load_commands, *lcp;
+      struct symtab_command *stp;
+      long i;
+
+      lseek(fd, arch_offset, SEEK_SET);
+      if (read(fd, (char *)&mh, sizeof(mh)) != sizeof(mh)) {
+        return (-1);
+      }
+      load_commands = (struct load_command *)malloc(mh.sizeofcmds);
+      if (load_commands == NULL) {
+        return (-1);
+      }
+      if (read(fd, (char *)load_commands, mh.sizeofcmds) !=
+          mh.sizeofcmds) {
+        free(load_commands);
+        return (-1);
+      }
+      stp = NULL;
+      lcp = load_commands;
+      // nealsid:iterate through all load commands, looking for
+      // LC_SYMTAB load command
+      for (i = 0; i < mh.ncmds; i++) {
+        if (lcp->cmdsize % sizeof(long) != 0 ||
+            lcp->cmdsize <= 0 ||
+            (char *)lcp + lcp->cmdsize >
+            (char *)load_commands + mh.sizeofcmds) {
+          free(load_commands);
+          return (-1);
+        }
+        if (lcp->cmd == LC_SYMTAB) {
+          if (lcp->cmdsize !=
+              sizeof(struct symtab_command)) {
+            free(load_commands);
+            return (-1);
+          }
+          stp = (struct symtab_command *)lcp;
+          break;
+        }
+        lcp = (struct load_command *)
+          ((char *)lcp + lcp->cmdsize);
+      }
+      if (stp == NULL) {
+        free(load_commands);
+        return (-1);
+      }
+      // sa points to the beginning of the symbol table
+      sa = stp->symoff + arch_offset;
+      // ss points to the beginning of the string table
+      ss = stp->stroff + arch_offset;
+      // n is the number of bytes in the symbol table
+      // each symbol table entry is an nlist structure
+      n = stp->nsyms * sizeof(breakpad_nlist);
+      free(load_commands);
+    }
+    else {
+      sa = N_SYMOFF(buf) + arch_offset;
+      ss = sa + buf.a_syms + arch_offset;
+      n = buf.a_syms;
+    }
+
+    lseek(fd, sa, SEEK_SET);
+
+    // the algorithm here is to read the nlist entries in m-sized
+    // chunks into q.  q is then iterated over. for each entry in q,
+    // use the string table index(q->n_un.n_strx) to read the symbol 
+    // name, then scan the nlist entries passed in by the user(via p),
+    // and look for a match
+    while (n) {
+      long savpos;
+
+      m = sizeof (space);
+      if (n < m)
+        m = n;
+      if (read(fd, (char *)space, m) != m)
+        break;
+      n -= m;
+      savpos = lseek(fd, 0, SEEK_CUR);
+      for (q = space; (m -= sizeof(breakpad_nlist)) >= 0; q++) {
+        char nambuf[BUFSIZ];
+
+        if (q->n_un.n_strx == 0 || q->n_type & N_STAB)
+          continue;
+
+        // seek to the location in the binary where the symbol
+        // name is stored & read it into memory
+        lseek(fd, ss+q->n_un.n_strx, SEEK_SET);
+        read(fd, nambuf, maxlen+1);
+        s2 = nambuf;
+        for (p = list; 
+             symbolNames[p-list] && 
+               symbolNames[p-list][0]; 
+             p++) {
+          // get the symbol name the user has passed in that 
+          // corresponds to the nlist entry that we're looking at
+          s1 = symbolNames[p - list];
+          while (*s1) {
+            if (*s1++ != *s2++)
+              goto cont;
+          }
+          if (*s2)
+            goto cont;
+
+          p->n_value = q->n_value;
+          p->n_type = q->n_type;
+          p->n_desc = q->n_desc;
+          p->n_sect = q->n_sect;
+          p->n_un.n_strx = q->n_un.n_strx;
+          if (--nreq == 0)
+            return (nreq);
+
+          break;
+        cont:           ;
+        }
+      }
+      lseek(fd, savpos, SEEK_SET);
+    }
+    return (nreq);
+  }
+
+#endif  /* __LP64__ */

new file mode 100644
--- /dev/null
+++ b/toolkit/crashreporter/google-breakpad/src/client/mac/handler/breakpad_nlist_64.h
@@ -0,0 +1,43 @@
+// Copyright (c) 2008, Google Inc.
+// All rights reserved
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// breakpad_nlist.h
+//
+// This file is meant to provide a header for clients of the modified
+// nlist function implemented to work on 64-bit.
+
+#ifndef CLIENT_MAC_HANDLER_BREAKPAD_NLIST_H__
+
+typedef struct nlist_64 breakpad_nlist;
+
+int
+breakpad_nlist_64(const char *name,
+                  breakpad_nlist *list,
+                  const char **symbolNames);
+
+#endif  /* CLIENT_MAC_HANDLER_BREAKPAD_NLIST_H__ */

--- a/toolkit/crashreporter/google-breakpad/src/client/mac/handler/dynamic_images.cc
+++ b/toolkit/crashreporter/google-breakpad/src/client/mac/handler/dynamic_images.cc
@@ -28,305 +28,410 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 extern "C" { // needed to compile on Leopard
   #include <mach-o/nlist.h>
   #include <stdlib.h>
   #include <stdio.h>
 }
 
+#include "breakpad_nlist_64.h"
+#include <dlfcn.h>
+#include <mach/mach_vm.h>
 #include <algorithm>
 #include "client/mac/handler/dynamic_images.h"
 
 namespace google_breakpad {
-  
+
 //==============================================================================
 // Returns the size of the memory region containing |address| and the
 // number of bytes from |address| to the end of the region.
 // We potentially, will extend the size of the original
 // region by the size of the following region if it's contiguous with the
 // first in order to handle cases when we're reading strings and they
 // straddle two vm regions.
 //
-static vm_size_t GetMemoryRegionSize(task_port_t target_task,
-                                     const void* address,
-                                     vm_size_t *size_to_end) {
-  vm_address_t region_base = (vm_address_t)address;
-  vm_size_t region_size;
+static mach_vm_size_t GetMemoryRegionSize(task_port_t target_task,
+                                          const void* address,
+                                          mach_vm_size_t *size_to_end) {
+  mach_vm_address_t region_base = (mach_vm_address_t)address;
+  mach_vm_size_t region_size;
   natural_t nesting_level = 0;
-  vm_region_submap_info submap_info;
-  mach_msg_type_number_t info_count = VM_REGION_SUBMAP_INFO_COUNT;
-  
+  vm_region_submap_info_64 submap_info;
+  mach_msg_type_number_t info_count = VM_REGION_SUBMAP_INFO_COUNT_64;
+
   // Get information about the vm region containing |address|
-  kern_return_t result = 
-    vm_region_recurse(target_task,
-                      &region_base,
-                      &region_size,
-                      &nesting_level, 
-                      reinterpret_cast<vm_region_recurse_info_t>(&submap_info),
-                      &info_count);
-  
+  vm_region_recurse_info_t region_info;
+  region_info = reinterpret_cast<vm_region_recurse_info_t>(&submap_info);
+
+  kern_return_t result =
+    mach_vm_region_recurse(target_task,
+                           &region_base,
+                           &region_size,
+                           &nesting_level,
+                           region_info,
+                           &info_count);
+
   if (result == KERN_SUCCESS) {
     // Get distance from |address| to the end of this region
-    *size_to_end = region_base + region_size -(vm_address_t)address;
+    *size_to_end = region_base + region_size -(mach_vm_address_t)address;
 
     // If we want to handle strings as long as 4096 characters we may need
     // to check if there's a vm region immediately following the first one.
     // If so, we need to extend |*size_to_end| to go all the way to the end
     // of the second region.
     if (*size_to_end < 4096) {
       // Second region starts where the first one ends
-      vm_address_t region_base2 =
-        (vm_address_t)(region_base + region_size);
-      vm_size_t region_size2;
+      mach_vm_address_t region_base2 =
+        (mach_vm_address_t)(region_base + region_size);
+      mach_vm_size_t region_size2;
 
       // Get information about the following vm region
-      result = 
-        vm_region_recurse(
-                      target_task,
-                      &region_base2,
-                      &region_size2,
-                      &nesting_level, 
-                      reinterpret_cast<vm_region_recurse_info_t>(&submap_info),
-                      &info_count);
-      
+      result =
+        mach_vm_region_recurse(target_task,
+                               &region_base2,
+                               &region_size2,
+                               &nesting_level,
+                               region_info,
+                               &info_count);
+
       // Extend region_size to go all the way to the end of the 2nd region
       if (result == KERN_SUCCESS
           && region_base2 == region_base + region_size) {
         region_size += region_size2;
       }
     }
 
-    *size_to_end = region_base + region_size -(vm_address_t)address;
+    *size_to_end = region_base + region_size -(mach_vm_address_t)address;
   } else {
     region_size = 0;
     *size_to_end = 0;
   }
-  
-  return region_size;   
+
+  return region_size;
 }
 
 #define kMaxStringLength 8192
 //==============================================================================
 // Reads a NULL-terminated string from another task.
 //
 // Warning!  This will not read any strings longer than kMaxStringLength-1
 //
 static void* ReadTaskString(task_port_t target_task,
                             const void* address) {
   // The problem is we don't know how much to read until we know how long
   // the string is. And we don't know how long the string is, until we've read
   // the memory!  So, we'll try to read kMaxStringLength bytes
-  // (or as many bytes as we can until we reach the end of the vm region).  
-  vm_size_t size_to_end;
+  // (or as many bytes as we can until we reach the end of the vm region).
+  mach_vm_size_t size_to_end;
   GetMemoryRegionSize(target_task, address, &size_to_end);
-  
+
   if (size_to_end > 0) {
-    vm_size_t size_to_read =
+    mach_vm_size_t size_to_read =
       size_to_end > kMaxStringLength ? kMaxStringLength : size_to_end;
 
-    return ReadTaskMemory(target_task, address, size_to_read);
+    kern_return_t kr;
+    return ReadTaskMemory(target_task, address, size_to_read, &kr);
   }
-  
+
   return NULL;
 }
 
 //==============================================================================
 // Reads an address range from another task.  A block of memory is malloced
 // and should be freed by the caller.
 void* ReadTaskMemory(task_port_t target_task,
                      const void* address,
-                     size_t length) {
+                     size_t length,
+                     kern_return_t *kr) {
   void* result = NULL;
-  vm_address_t page_address = reinterpret_cast<vm_address_t>(address) & (-4096);
-  vm_address_t last_page_address =
-    (reinterpret_cast<vm_address_t>(address) + length + 4095) & (-4096);
-  vm_size_t page_size = last_page_address - page_address;
+  int systemPageSize = getpagesize();
+
+  // use the negative of the page size for the mask to find the page address
+  mach_vm_address_t page_address =
+      reinterpret_cast<mach_vm_address_t>(address) & (-systemPageSize);
+
+  mach_vm_address_t last_page_address =
+      (reinterpret_cast<mach_vm_address_t>(address) + length +
+       (systemPageSize - 1)) & (-systemPageSize);
+
+  mach_vm_size_t page_size = last_page_address - page_address;
   uint8_t* local_start;
   uint32_t local_length;
 
-  kern_return_t r = vm_read(target_task,
-                            page_address,
-                            page_size,
-                            reinterpret_cast<vm_offset_t*>(&local_start),
-                            &local_length);
+  kern_return_t r;
+
+  r = mach_vm_read(target_task,
+                   page_address,
+                   page_size,
+                   reinterpret_cast<vm_offset_t*>(&local_start),
+                   &local_length);
+
+
+  if (kr != NULL) {
+    *kr = r;
+  }
 
   if (r == KERN_SUCCESS) {
     result = malloc(length);
     if (result != NULL) {
-      memcpy(result, &local_start[(uint32_t)address - page_address], length);
+      memcpy(result,
+             &local_start[(mach_vm_address_t)address - page_address],
+             length);
     }
-    vm_deallocate(mach_task_self(), (uintptr_t)local_start, local_length);
+    mach_vm_deallocate(mach_task_self(), (uintptr_t)local_start, local_length);
   }
-  
+
   return result;
 }
 
 #pragma mark -
 
 //==============================================================================
 // Initializes vmaddr_, vmsize_, and slide_
-void DynamicImage::CalculateMemoryInfo() {
-  mach_header *header = GetMachHeader();
+void DynamicImage::CalculateMemoryAndVersionInfo() {
+  breakpad_mach_header *header = GetMachHeader();
+
+  // unless we can process the header, ensure that calls to
+  // IsValid() will return false
+  vmaddr_ = 0;
+  vmsize_ = 0;
+  slide_ = 0;
+  version_ = 0;
+
+  bool foundTextSection = false;
+  bool foundDylibIDCommand = false;
+  
+#if __LP64__
+  if(header->magic != MH_MAGIC_64) {
+    return;
+  }
+#else
+  if(header->magic != MH_MAGIC) {
+    return;
+  }
+#endif
+
+#ifdef __LP64__
+  const uint32_t segmentLoadCommand = LC_SEGMENT_64;
+#else
+  const uint32_t segmentLoadCommand = LC_SEGMENT;
+#endif
 
   const struct load_command *cmd =
     reinterpret_cast<const struct load_command *>(header + 1);
 
   for (unsigned int i = 0; cmd && (i < header->ncmds); ++i) {
-    if (cmd->cmd == LC_SEGMENT) {
-      const struct segment_command *seg =
-        reinterpret_cast<const struct segment_command *>(cmd);
+    if (!foundTextSection) {
+      if (cmd->cmd == segmentLoadCommand) {
+        const breakpad_mach_segment_command *seg =
+            reinterpret_cast<const breakpad_mach_segment_command *>(cmd);
+
+        if (!strcmp(seg->segname, "__TEXT")) {
+          vmaddr_ = seg->vmaddr;
+          vmsize_ = seg->vmsize;
+          slide_ = 0;
 
-      if (!strcmp(seg->segname, "__TEXT")) {
-        vmaddr_ = seg->vmaddr;
-        vmsize_ = seg->vmsize;
-        slide_ = 0;
-        
-        if (seg->fileoff == 0  &&  seg->filesize != 0) {
-          slide_ = (uintptr_t)GetLoadAddress() - (uintptr_t)seg->vmaddr;
+          if (seg->fileoff == 0  &&  seg->filesize != 0) {
+            slide_ = (uintptr_t)GetLoadAddress() - (uintptr_t)seg->vmaddr;
+          }
+          foundTextSection = true;
         }
-        return;
       }
     }
 
+    if (!foundDylibIDCommand) {
+      if (cmd->cmd == LC_ID_DYLIB) {
+        const struct dylib_command *dc =
+            reinterpret_cast<const struct dylib_command *>(cmd);
+
+        version_ = dc->dylib.current_version;
+        foundDylibIDCommand = true;
+      }
+    }
+
+    if (foundDylibIDCommand && foundTextSection) {
+      return;
+    }
+
     cmd = reinterpret_cast<const struct load_command *>
       (reinterpret_cast<const char *>(cmd) + cmd->cmdsize);
   }
-  
-  // we failed - a call to IsValid() will return false
-  vmaddr_ = 0;
-  vmsize_ = 0;
-  slide_ = 0;
+
 }
 
 void DynamicImage::Print() {
   const char *path = GetFilePath();
   if (!path) {
     path = "(unknown)";
   }
   printf("%p: %s\n", GetLoadAddress(), path);
-  mach_header *header = GetMachHeader();
+  breakpad_mach_header *header = GetMachHeader();
   MachHeader(*header).Print();
   printf("vmaddr\t\t: %p\n", reinterpret_cast<void*>(GetVMAddr()));
-  printf("vmsize\t\t: %d\n", GetVMSize());
-  printf("slide\t\t: %d\n", GetVMAddrSlide());
+  printf("vmsize\t\t: %llu\n", GetVMSize());
+  printf("slide\t\t: %td\n", GetVMAddrSlide());
 }
 
 #pragma mark -
 
 //==============================================================================
 // Loads information about dynamically loaded code in the given task.
 DynamicImages::DynamicImages(mach_port_t task)
   : task_(task) {
   ReadImageInfoForTask();
 }
 
-//==============================================================================
-// This code was written using dyld_debug.c (from Darwin) as a guide.
-void DynamicImages::ReadImageInfoForTask() {
+void* DynamicImages::GetDyldAllImageInfosPointer()
+{
+
+  const char *imageSymbolName = "_dyld_all_image_infos";
+  const char *dyldPath = "/usr/lib/dyld";
+#ifndef __LP64__
   struct nlist l[8];
   memset(l, 0, sizeof(l) );
 
   // First we lookup the address of the "_dyld_all_image_infos" struct
   // which lives in "dyld".  This structure contains information about all
   // of the loaded dynamic images.
   struct nlist &list = l[0];
-  list.n_un.n_name = const_cast<char *>("_dyld_all_image_infos");
-  nlist("/usr/lib/dyld", &list);
-  
-  if (list.n_value) {
+  list.n_un.n_name = const_cast<char *>(imageSymbolName);
+  nlist(dyldPath,&list);
+  if(list.n_value) {
+    return reinterpret_cast<void*>(list.n_value);
+  }
+
+  return NULL;
+#else
+  struct nlist_64 l[8];
+  struct nlist_64 &list = l[0];
+
+  memset(l, 0, sizeof(l) );
+
+  const char *symbolNames[2] = { imageSymbolName, "\0" };
+
+  int invalidEntriesCount = breakpad_nlist_64(dyldPath,&list,symbolNames);
+
+  if(invalidEntriesCount != 0) {
+    return NULL;
+  }
+  assert(list.n_value);
+  return reinterpret_cast<void*>(list.n_value);
+#endif
+
+}
+//==============================================================================
+// This code was written using dyld_debug.c (from Darwin) as a guide.
+void DynamicImages::ReadImageInfoForTask() {
+  void *imageList = GetDyldAllImageInfosPointer();
+
+  if (imageList) {
+    kern_return_t kr;
     // Read the structure inside of dyld that contains information about
     // loaded images.  We're reading from the desired task's address space.
 
     // Here we make the assumption that dyld loaded at the same address in
     // the crashed process vs. this one.  This is an assumption made in
     // "dyld_debug.c" and is said to be nearly always valid.
     dyld_all_image_infos *dyldInfo = reinterpret_cast<dyld_all_image_infos*>
       (ReadTaskMemory(task_,
-                      reinterpret_cast<void*>(list.n_value),
-                      sizeof(dyld_all_image_infos)));
+                      reinterpret_cast<void*>(imageList),
+                      sizeof(dyld_all_image_infos), &kr));
 
     if (dyldInfo) {
       // number of loaded images
       int count = dyldInfo->infoArrayCount;
 
       // Read an array of dyld_image_info structures each containing
       // information about a loaded image.
       dyld_image_info *infoArray = reinterpret_cast<dyld_image_info*>
         (ReadTaskMemory(task_,
                         dyldInfo->infoArray,
-                        count*sizeof(dyld_image_info)));
+                        count*sizeof(dyld_image_info), &kr));
 
       image_list_.reserve(count);
 
       for (int i = 0; i < count; ++i) {
         dyld_image_info &info = infoArray[i];
 
         // First read just the mach_header from the image in the task.
-        mach_header *header = reinterpret_cast<mach_header*>
-          (ReadTaskMemory(task_, info.load_address_, sizeof(mach_header)));
+        breakpad_mach_header *header = reinterpret_cast<breakpad_mach_header*>
+          (ReadTaskMemory(task_,
+                          info.load_address_,
+                          sizeof(breakpad_mach_header), &kr));
 
         if (!header)
           break;   // bail on this dynamic image
-		
+
         // Now determine the total amount we really want to read based on the
-        // size of the load commands.  We need the header plus all of the 
+        // size of the load commands.  We need the header plus all of the
         // load commands.
-        unsigned int header_size = sizeof(mach_header) + header->sizeofcmds;
+        unsigned int header_size =
+            sizeof(breakpad_mach_header) + header->sizeofcmds;
+
         free(header);
 
-        header = reinterpret_cast<mach_header*>
-          (ReadTaskMemory(task_, info.load_address_, header_size));
+        header = reinterpret_cast<breakpad_mach_header*>
+          (ReadTaskMemory(task_, info.load_address_, header_size, &kr));
 
         // Read the file name from the task's memory space.
         char *file_path = NULL;
         if (info.file_path_) {
           // Although we're reading kMaxStringLength bytes, it's copied in the
           // the DynamicImage constructor below with the correct string length,
           // so it's not really wasting memory.
           file_path = reinterpret_cast<char*>
             (ReadTaskString(task_, info.file_path_));
         }
- 
+
         // Create an object representing this image and add it to our list.
-        DynamicImage *new_image = new DynamicImage(header,
-                                                   header_size,
-                                                   info.load_address_,
-                                                   file_path,
-                                                   info.file_mod_date_,
-                                                   task_);
+        DynamicImage *new_image;
+        new_image = new DynamicImage(header,
+                                     header_size,
+                                     (breakpad_mach_header*)info.load_address_,
+                                     file_path,
+                                     info.file_mod_date_,
+                                     task_);
 
         if (new_image->IsValid()) {
           image_list_.push_back(DynamicImageRef(new_image));
         } else {
           delete new_image;
         }
-        
+
         if (file_path) {
           free(file_path);
         }
       }
-      
+
       free(dyldInfo);
       free(infoArray);
-      
+
       // sorts based on loading address
       sort(image_list_.begin(), image_list_.end() );
+      // remove duplicates - this happens in certain strange cases
+      // You can see it in DashboardClient when Google Gadgets plugin
+      // is installed.  Apple's crash reporter log and gdb "info shared"
+      // both show the same library multiple times at the same address
+
+      vector<DynamicImageRef>::iterator it = unique(image_list_.begin(),
+                                                    image_list_.end() );
+      image_list_.erase(it, image_list_.end());
     }
-  }  
+  }
 }
 
 //==============================================================================
 DynamicImage  *DynamicImages::GetExecutableImage() {
   int executable_index = GetExecutableImageIndex();
-  
+
   if (executable_index >= 0) {
     return GetImage(executable_index);
   }
-  
+
   return NULL;
 }
 
 //==============================================================================
 // returns -1 if failure to find executable
 int DynamicImages::GetExecutableImageIndex() {
   int image_count = GetImageCount();
 

--- a/toolkit/crashreporter/google-breakpad/src/client/mac/handler/dynamic_images.h
+++ b/toolkit/crashreporter/google-breakpad/src/client/mac/handler/dynamic_images.h
@@ -63,89 +63,99 @@ typedef struct dyld_image_info {
 typedef struct dyld_all_image_infos {
   uint32_t                      version;  // == 1 in Mac OS X 10.4
   uint32_t                      infoArrayCount;
   const struct dyld_image_info  *infoArray;
   void*                         notification;
   bool                          processDetachedFromSharedRegion;
 } dyld_all_image_infos;
 
+// some typedefs to isolate 64/32 bit differences
+#ifdef __LP64__
+typedef mach_header_64 breakpad_mach_header;
+typedef segment_command_64 breakpad_mach_segment_command;
+#else
+typedef mach_header breakpad_mach_header;
+typedef segment_command breakpad_mach_segment_command;
+#endif
+
 //==============================================================================
 // A simple wrapper for a mach_header
 //
 // This could be fleshed out with some more interesting methods.
 class MachHeader {
  public:
-  explicit MachHeader(const mach_header &header) : header_(header) {}
+  explicit MachHeader(const breakpad_mach_header &header) : header_(header) {}
 
   void Print() {
     printf("magic\t\t: %4x\n", header_.magic);
     printf("cputype\t\t: %d\n", header_.cputype);
     printf("cpusubtype\t: %d\n", header_.cpusubtype);
     printf("filetype\t: %d\n", header_.filetype);
     printf("ncmds\t\t: %d\n", header_.ncmds);
     printf("sizeofcmds\t: %d\n", header_.sizeofcmds);
     printf("flags\t\t: %d\n", header_.flags);
   }
 
-  mach_header   header_;
+  breakpad_mach_header   header_;
 };
 
 //==============================================================================
 // Represents a single dynamically loaded mach-o image
 class DynamicImage {
  public:
-  DynamicImage(mach_header *header,       // we take ownership
-               int header_size,           // includes load commands
-               mach_header *load_address,
+  DynamicImage(breakpad_mach_header *header, // we take ownership
+               int header_size,              // includes load commands
+               breakpad_mach_header *load_address,
                char *inFilePath,
                uintptr_t image_mod_date,
                mach_port_t task)
     : header_(header),
       header_size_(header_size),
       load_address_(load_address),
       file_mod_date_(image_mod_date),
       task_(task) {
     InitializeFilePath(inFilePath);
-    CalculateMemoryInfo();
+    CalculateMemoryAndVersionInfo();
   }
 
   ~DynamicImage() {
     if (file_path_) {
       free(file_path_);
     }
     free(header_);
   }
 
   // Returns pointer to a local copy of the mach_header plus load commands
-  mach_header *GetMachHeader() {return header_;}
+  breakpad_mach_header *GetMachHeader() {return header_;}
 
   // Size of mach_header plus load commands
   int GetHeaderSize() const {return header_size_;}
 
   // Full path to mach-o binary
   char *GetFilePath() {return file_path_;}
 
   uintptr_t GetModDate() const {return file_mod_date_;}
 
   // Actual address where the image was loaded
-  mach_header *GetLoadAddress() const {return load_address_;}
+  breakpad_mach_header *GetLoadAddress() const {return load_address_;}
 
   // Address where the image should be loaded
-  uint32_t GetVMAddr() const {return vmaddr_;}
+  mach_vm_address_t GetVMAddr() const {return vmaddr_;}
 
   // Difference between GetLoadAddress() and GetVMAddr()
   ptrdiff_t GetVMAddrSlide() const {return slide_;}
 
   // Size of the image
-  uint32_t GetVMSize() const {return vmsize_;}
+  mach_vm_size_t GetVMSize() const {return vmsize_;}
 
   // Task owning this loaded image
   mach_port_t GetTask() {return task_;}
 
+  uint32_t GetVersion() {return version_;}
   // For sorting
   bool operator<(const DynamicImage &inInfo) {
     return GetLoadAddress() < inInfo.GetLoadAddress();
   }
 
   // Debugging
   void Print();
  
@@ -162,67 +172,53 @@ class DynamicImage {
       file_path_ = reinterpret_cast<char*>(malloc(path_size));
       strlcpy(file_path_, inFilePath, path_size);
     } else {
       file_path_ = NULL;
     }
   }
 
   // Initializes vmaddr_, vmsize_, and slide_
-  void CalculateMemoryInfo();
-
-#if 0   // currently not needed
-  // Copy constructor: we don't want this to be invoked,
-  // but here's the code in case we need to make it public some day.
-  DynamicImage(DynamicImage &inInfo)
-    : load_address_(inInfo.load_address_),
-      vmaddr_(inInfo.vmaddr_),
-      vmsize_(inInfo.vmsize_),
-      slide_(inInfo.slide_),
-      file_mod_date_(inInfo.file_mod_date_),
-      task_(inInfo.task_) {
-    // copy file path string
-    InitializeFilePath(inInfo.GetFilePath());
+  void CalculateMemoryAndVersionInfo();
 
-    // copy mach_header and load commands
-    header_ = reinterpret_cast<mach_header*>(malloc(inInfo.header_size_));
-    memcpy(header_, inInfo.header_, inInfo.header_size_);
-    header_size_ = inInfo.header_size_;
-  }
-#endif
+  breakpad_mach_header    *header_;        // our local copy of the header
+  int                     header_size_;    // mach_header plus load commands
+  breakpad_mach_header    *load_address_;  // base address image is mapped into
+  mach_vm_address_t       vmaddr_;
+  mach_vm_size_t          vmsize_;
+  ptrdiff_t               slide_;
+  uint32_t                version_;        // Dylib version
+  char                    *file_path_;     // path dyld used to load the image
+  uintptr_t               file_mod_date_;  // time_t of image file
 
-  mach_header          *header_;        // our local copy of the header
-  int                   header_size_;    // mach_header plus load commands
-  mach_header          *load_address_;  // base address image is mapped into
-  uint32_t             vmaddr_;
-  uint32_t             vmsize_;
-  ptrdiff_t            slide_;
-
-  char                 *file_path_;     // path dyld used to load the image
-  uintptr_t            file_mod_date_;  // time_t of image file
-
-  mach_port_t          task_;
+  mach_port_t             task_;
 };
 
 //==============================================================================
 // DynamicImageRef is just a simple wrapper for a pointer to
 // DynamicImage.  The reason we use it instead of a simple typedef is so
 // that we can use stl::sort() on a vector of DynamicImageRefs
 // and simple class pointers can't implement operator<().
 //
 class DynamicImageRef {
  public:
   explicit DynamicImageRef(DynamicImage *inP) : p(inP) {}
-  DynamicImageRef(const DynamicImageRef &inRef) : p(inRef.p) {}  // STL required
+  // The copy constructor is required by STL
+  DynamicImageRef(const DynamicImageRef &inRef) : p(inRef.p) {}
 
   bool operator<(const DynamicImageRef &inRef) const {
     return (*const_cast<DynamicImageRef*>(this)->p)
       < (*const_cast<DynamicImageRef&>(inRef).p);
   }
 
+  bool operator==(const DynamicImageRef &inInfo) const {
+    return (*const_cast<DynamicImageRef*>(this)->p).GetLoadAddress() ==
+        (*const_cast<DynamicImageRef&>(inInfo)).GetLoadAddress();
+  }
+
   // Be just like DynamicImage*
   DynamicImage  *operator->() {return p;}
   operator DynamicImage*() {return p;}
 
  private:
   DynamicImage  *p;
 };
 
@@ -261,33 +257,41 @@ class DynamicImages {
   // Debugging
   void Print() {
     for (int i = 0; i < (int)image_list_.size(); ++i) {
       image_list_[i]->Print();
     }
   }
 
   void TestPrint() {
+    const breakpad_mach_header *header;
     for (int i = 0; i < (int)image_list_.size(); ++i) {
       printf("dyld: %p: name = %s\n", _dyld_get_image_header(i),
-        _dyld_get_image_name(i) );
-      const mach_header *header = _dyld_get_image_header(i);
+             _dyld_get_image_name(i) );
+
+      const void *imageHeader = _dyld_get_image_header(i);
+      header = reinterpret_cast<const breakpad_mach_header*>(imageHeader);
+
       MachHeader(*header).Print();
     }
   }
 
  private:
   bool IsOurTask() {return task_ == mach_task_self();}
 
   // Initialization
   void ReadImageInfoForTask();
+  void* GetDyldAllImageInfosPointer();
 
   mach_port_t              task_;
   vector<DynamicImageRef>  image_list_;
 };
 
 // Returns a malloced block containing the contents of memory at a particular
 // location in another task.
-void* ReadTaskMemory(task_port_t target_task, const void* address, size_t len);
+void* ReadTaskMemory(task_port_t target_task,
+                     const void* address,
+                     size_t len,
+                     kern_return_t *kr);
 
 }   // namespace google_breakpad
 
 #endif // CLIENT_MAC_HANDLER_DYNAMIC_IMAGES_H__