NonSFI NaCl: Plumb Exception IRT enough for breakpad.

chrome/test/data/nacl/nonsfi/libc_free.c

 /*
  * Copyright 2014 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * This is a minimal NaCl program without libc. It uses NaCl's stable IRT ABI.
  */
 
 #include <stdint.h>
 
 #include "native_client/src/include/elf_auxv.h"
 #include "native_client/src/untrusted/irt/irt.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_messaging.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_messaging.h"
 #include "ppapi/nacl_irt/public/irt_ppapi.h"
 
 static struct nacl_irt_basic __libnacl_irt_basic;
+static struct nacl_irt_exception_handling __libnacl_irt_exception_handling;
 static struct nacl_irt_random __libnacl_irt_random;
 static TYPE_nacl_irt_query __nacl_irt_query;
 static struct PPP_Instance_1_0 ppp_instance;
 static struct PPP_Messaging_1_0 ppp_messaging;
 static const struct PPB_Messaging_1_0* ppb_messaging;
 static const struct PPB_Var_1_2* ppb_var;
 
 /*
  * To support 64bit binary, we declare Elf_auxv_t by using uintptr_t.
  * See also native_client/src/include/elf32.h.
@@ skipping 148 matching lines @@
     }
   }
   if (num_zeroes > 100) {
     PostStringMessage(instance, "Too many zeros in this random stream.");
     return;
   }
 
   PostStringMessage(instance, "randomsuccess");
 }
 
+static PP_Instance g_instance_for_exception_handler = -1;
+static void MyNaClExceptionHandler(struct NaClExceptionContext *context) {
+  // TODO verify that I have a stack that is set by altstack.
+
+  PostStringMessage(g_instance_for_exception_handler, "exceptionsuccess");
+
+  // Wait until I get killed by testing infrastructure to give chance
+  // to PostMessage to finish asynchronously notifying javascript
+  // instead of crashing immediately.  Doing ppb_console.Log() seems
+  // to also do the job, take your pick.
+  while(1) {
+    __libnacl_irt_basic.sched_yield();
+  }
+}
+
+static void TestException(PP_Instance instance) {
+  // Exception Handling.
+  g_instance_for_exception_handler = instance;
+  if (__libnacl_irt_exception_handling.exception_handler(
+          MyNaClExceptionHandler, NULL)) {
+    PostStringMessage(instance, "Error on registering exception");
+    return;
+  }
+
+  // Crash myself here to invoke the crash handler.
+  *(char*)0 = 0;
+
+  PostStringMessage(instance, "I think I should have crashed already.");
+}
+
 // Handle message from javascript, javascript side will tell me what
 // kind of test it wants, and I will respond accordingly.
 static void HandleMessage(PP_Instance instance, struct PP_Var message) {
   if (!ppb_messaging || !ppb_var || message.type != PP_VARTYPE_STRING) {
     __libnacl_irt_basic.exit(1);
   }
 
   uint32_t message_len;
   const char* message_string = ppb_var->VarToUtf8(message, &message_len);
 
   if (!my_strncmp("Message from Javascript to NaCl",
                   message_string, message_len)) {
     // Reply back with what we received.
     ppb_messaging->PostMessage(instance, message);
   } else if (!my_strncmp("random", message_string, message_len)) {
     TestRandom(instance);
+  } else if (!my_strncmp("exception", message_string, message_len)) {
+    TestException(instance);
   } else {
     // Unknown message came.
     PostStringMessage(instance, "Unknown message type");
   }
 }
 
 void _start(uintptr_t info[]) {
   Elf_auxv_t* auxv = nacl_startup_auxv(info);
   grok_auxv(auxv);
   DO_QUERY(NACL_IRT_BASIC_v0_1, __libnacl_irt_basic);
   DO_QUERY(NACL_IRT_RANDOM_v0_1, __libnacl_irt_random);
+  DO_QUERY(NACL_IRT_EXCEPTION_HANDLING_v0_1, __libnacl_irt_exception_handling);
 
   struct nacl_irt_ppapihook ppapihook;
   DO_QUERY(NACL_IRT_PPAPIHOOK_v0_1, ppapihook);
 
   /* This is local as a workaround to avoid having to apply
    * relocations to global variables. */
   struct PP_StartFunctions start_funcs = {
     MyPPP_InitializeModule,
     MyPPP_ShutdownModule,
     MyPPP_GetInterface,
   };
   /* Similarly, initialise some global variables, avoiding relocations. */
   struct PPP_Instance_1_0 local_ppp_instance = {
     DidCreate,
     DidDestroy,
     DidChangeView,
     DidChangeFocus,
     HandleDocumentLoad,
   };
   ppp_instance = local_ppp_instance;
   struct PPP_Messaging_1_0 local_ppp_messaging = {
     HandleMessage,
   };
   ppp_messaging = local_ppp_messaging;
 
   ppapihook.ppapi_start(&start_funcs);
 
   __libnacl_irt_basic.exit(0);
 }