NonSFI mode: Enable compiling exception_test for NonSFI NaCl on ARM

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>
 
+#if !TESTS_USE_IRT && NONSFI_MODE
+#include "native_client/src/nonsfi/linux/irt_exception_handling.h"
+#endif
+
 #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"
 
 
 /*
  * This is used for calculating the size of the exception stack frame
@@ skipping 149 matching lines @@
     stack_top = g_registered_stack + g_registered_stack_size;
     assert(g_registered_stack <= &local_var);
     assert(&local_var < stack_top);
   }
 
   /* Check the exception handler's initial stack pointer more exactly. */
   uintptr_t frame_base = entry_regs->stack_ptr + kReturnAddrSize;
   assert(frame_base % STACK_ALIGNMENT == 0);
   char *frame_top = (char *) (frame_base + kArgSizeOnStack +
                               sizeof(struct CombinedContext));
-  /* Check that no more than the stack alignment size is wasted. */
-  assert(stack_top - STACK_ALIGNMENT < frame_top);
+  if (NONSFI_MODE) {
+    /*
+     * Non-SFI mode exception stack will have ucontext_t and
+     * siginfo_t, which would be anywhere from 400 bytes to 1.5k
+     */
+    assert(stack_top - 1500 < frame_top);
+  } else {
+    /* Check that no more than the stack alignment size is wasted. */
+    assert(stack_top - STACK_ALIGNMENT < frame_top);
+  }
   assert(frame_top <= stack_top);
 
 #if defined(__x86_64__)
   /* Check that %rsp and %rbp have safe, %r15-extended values. */
   assert(entry_regs->stack_ptr >> 32 == entry_regs->r15 >> 32);
   assert(entry_regs->rbp >> 32 == entry_regs->r15 >> 32);
 #endif
 
   return_from_exception_handler();
 }
 
 void test_exception_stack_with_size(char *stack, size_t stack_size) {
   if (0 != nacl_exception_set_handler(exception_handler)) {
     printf("failed to set exception handler\n");
     exit(4);
   }
+#if !NONSFI_MODE
+  /* TODO(uekawa): Implement set_stack for Non-SFI mode. */
   if (0 != nacl_exception_set_stack(stack, stack_size)) {
     printf("failed to set alt stack\n");
     exit(5);
   }
   g_registered_stack = stack;
   g_registered_stack_size = stack_size;
+#endif
 
   char crash_stack[0x1000];
   RegsFillTestValues(&g_regs_at_crash, /* seed= */ 0);
   g_regs_at_crash.stack_ptr = (uintptr_t) crash_stack + sizeof(crash_stack);
   g_regs_at_crash.prog_ctr = (uintptr_t) prog_ctr_at_crash;
   RegsApplySandboxConstraints(&g_regs_at_crash);
 #if defined(__arm__)
   /* crash_at_known_address clobbers r0. */
   g_regs_at_crash.r0 = 0;
 #endif
@@ skipping 88 matching lines @@
 void test_catching_various_exception_types(void) {
   int rc = nacl_exception_set_handler(simple_exception_handler);
   assert(rc == 0);
 
   printf("Testing __builtin_trap()...\n");
   if (!setjmp(g_jmp_buf)) {
     __builtin_trap();
     exit(1);
   }
 
-#if defined(__i386__) || defined(__x86_64__)
+#if !NONSFI_MODE && (defined(__i386__) || defined(__x86_64__))
   printf("Testing hlt...\n");
   if (!setjmp(g_jmp_buf)) {
     __asm__("hlt");
     exit(1);
   }
   printf("Testing ud2a (an illegal instruction)...\n");
   if (!setjmp(g_jmp_buf)) {
     __asm__("ud2a");
     exit(1);
   }
   printf("Testing integer division by zero...\n");
   if (!setjmp(g_jmp_buf)) {
     uint32_t result;
     __asm__ volatile("idivb %1"
                      : "=a"(result)
                      : "r"((uint8_t) 0), "a"((uint16_t) 1));
     exit(1);
   }
 #endif
 
   /* Clear the jmp_buf to prevent it from being reused accidentally. */
   memset(g_jmp_buf, 0, sizeof(g_jmp_buf));
 }
 
 
-#if defined(__i386__) || defined(__x86_64__)
+#if !NONSFI_MODE && (defined(__i386__) || defined(__x86_64__))
 
 int get_x86_direction_flag(void);
 
 void test_get_x86_direction_flag(void) {
   /*
    * Sanity check:  Ensure that get_x86_direction_flag() works.  We
    * avoid calling assert() with the flag set, because that might not
    * work.
    */
   assert(get_x86_direction_flag() == 0);
@@ skipping 35 matching lines @@
 
 void run_test(const char *test_name, void (*test_func)(void)) {
   printf("Running %s...\n", test_name);
   test_func();
 }
 
 #define RUN_TEST(test_func) (run_test(#test_func, test_func))
 
 int TestMain(void) {
   RUN_TEST(test_exceptions_minimally);
-  RUN_TEST(test_exception_stack_alignments);
-  RUN_TEST(test_getting_previous_handler);
-  RUN_TEST(test_invalid_handlers);
+  if (!NONSFI_MODE) {
+    /* TODO(uekawa): Implement set_stack for Non-SFI mode. */
+    RUN_TEST(test_exception_stack_alignments);
+    /* NACL_SYSCALL not supported on nonsfi mode */
+    RUN_TEST(test_getting_previous_handler);
+    /* Those handlers are not invalid in NonSFI NaCl. */
+    RUN_TEST(test_invalid_handlers);
+  }
   /* pthread_join() is broken under qemu-arm. */
   if (getenv("UNDER_QEMU_ARM") == NULL)
     RUN_TEST(test_exceptions_on_non_main_thread);
   RUN_TEST(test_catching_various_exception_types);
 
-#if defined(__i386__) || defined(__x86_64__)
+#if !NONSFI_MODE && (defined(__i386__) || defined(__x86_64__))
+  /* TODO(uekawa): Implement for Non-SFI mode. */
   RUN_TEST(test_get_x86_direction_flag);
   RUN_TEST(test_unsetting_x86_direction_flag);
 #endif
 
   fprintf(stderr, "** intended_exit_status=0\n");
   return 0;
 }
 
 int main(void) {
+#if !TESTS_USE_IRT && NONSFI_MODE
+  /*
+   * In Non-SFI mode Non-IRT loading version does not initialize
+   * signal handler.
+   */
+  nonsfi_initialize_signal_handler();

[Junichi Uekawa, 2014/09/29 07:32:30]

I couldn't find a reasonable place to do initialization, this is usually called
from nonsfi_loader during initialization, but for all other cases I'm not sure
when to do that. Discussed with hamaji and we could do it before _start() or
very early in initialization, but I'm not too comfortable doing it that early in
all binaries.

+#endif
   return RunTests(TestMain);
 }