Add wrapper library for the nacl_irt_exception_handling IRT interface

tests/exception_test/exception_test.c

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <assert.h>
 #include <errno.h>
 #include <pthread.h>
 #include <setjmp.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "native_client/src/include/elf_constants.h"
 #include "native_client/src/include/nacl/nacl_exception.h"
 #include "native_client/src/trusted/service_runtime/include/sys/nacl_syscalls.h"
 #include "native_client/src/untrusted/nacl/syscall_bindings_trampoline.h"
 #include "native_client/tests/common/register_set.h"
 #include "native_client/tests/inbrowser_test_runner/test_runner.h"
 
 
-typedef void (*handler_func_t)(struct NaClExceptionContext *context);
-
 /*
  * This is used for calculating the size of the exception stack frame
  * when alignment is taken into account.
  */
 struct CombinedContext {
   struct NaClExceptionContext c1;
   struct NaClExceptionPortableContext c2;
 };
 
 char stack[0x10000];
@@ skipping 197 matching lines @@
    * different addresses modulo the stack alignment size.
    */
   int diff;
   for (diff = 0; diff <= STACK_ALIGNMENT * 2; diff++) {
     test_exception_stack_with_size(stack, sizeof(stack) - diff);
   }
 }
 
 void test_getting_previous_handler(void) {
   int rc;
-  handler_func_t prev_handler;
+  nacl_exception_handler_t prev_handler;
 
   rc = NACL_SYSCALL(exception_handler)(exception_handler, NULL);
   assert(rc == 0);
 
   rc = NACL_SYSCALL(exception_handler)(NULL, &prev_handler);
   assert(rc == 0);
   assert(prev_handler == exception_handler);
 
   rc = NACL_SYSCALL(exception_handler)(NULL, &prev_handler);
   assert(rc == 0);
   assert(prev_handler == NULL);
 }
 
 void test_invalid_handlers(void) {
   int rc;
-  handler_func_t unaligned_func_ptr =
-    (handler_func_t) ((uintptr_t) exception_handler + 1);
+  nacl_exception_handler_t unaligned_func_ptr =
+    (nacl_exception_handler_t) ((uintptr_t) exception_handler + 1);
   const char *ptr_in_rodata_segment = "";
 
   /* An alignment check is required for safety in all NaCl sandboxes. */
   rc = NACL_SYSCALL(exception_handler)(unaligned_func_ptr, NULL);
   assert(rc == -EFAULT);
 
   /* A range check is required for safety in the NaCl ARM sandbox. */
   rc = NACL_SYSCALL(exception_handler)(
-      (handler_func_t) (uintptr_t) ptr_in_rodata_segment, NULL);
+      (nacl_exception_handler_t) (uintptr_t) ptr_in_rodata_segment, NULL);
   assert(rc == -EFAULT);
 }
 
 
 void *thread_func(void *unused_arg) {
   /*
    * This tests that the exception handler gets the correct
    * NaClAppThread for this thread.  If it gets the wrong thread, the
    * handler will detect that the stack it is running on does not
    * match the stack that was registered.
@@ skipping 88 matching lines @@
   RUN_TEST(test_unsetting_x86_direction_flag);
 #endif
 
   fprintf(stderr, "** intended_exit_status=0\n");
   return 0;
 }
 
 int main(void) {
   return RunTests(TestMain);
 }