[MIPS] Add remaining parts for building tests for MIPS

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>
@@ skipping 13 matching lines @@
 
 char stack[4096];
 
 struct NaClSignalContext g_regs_at_crash;
 jmp_buf g_jmp_buf;
 
 char *g_registered_stack;
 size_t g_registered_stack_size;
 
 
+#if defined(__mips__)
+#define STACK_ALIGNMENT 8
+#else
 #define STACK_ALIGNMENT 16
+#endif
 
 #if defined(__i386__)
 const int kReturnAddrSize = 4;
 const int kArgSizeOnStack = 4;
 const int kRedZoneSize = 0;
 #elif defined(__x86_64__)
 const int kReturnAddrSize = 8;
 const int kArgSizeOnStack = 0;
 const int kRedZoneSize = 128;
 #elif defined(__arm__)
 const int kReturnAddrSize = 0;
 const int kArgSizeOnStack = 0;
 const int kRedZoneSize = 0;
+#elif defined(__mips__)
+const int kReturnAddrSize = 0;
+const int kArgSizeOnStack = 16;
+const int kRedZoneSize = 0;
 #else
 # error Unsupported architecture
 #endif
 
 struct AlignedType {
   int blah;
 } __attribute__((aligned(16)));

[Mark Seaborn, 2013/03/14 15:48:00]

Let's just remove check_stack_is_aligned() -- see other comment.

[petarj, 2013/03/15 18:34:07]

Ok, I have removed struct AlignedType and check_pointer_is_aligned too,
since they are not used anywhere else. Are you ok with that?
Double-check.

 
 /*
  * We do this check in a separate function in an attempt to prevent
  * the compiler from optimising away the check for a stack-allocated
  * variable.
  *
  * We test for an alignment that is small enough for the compiler to
  * assume on x86-32, even if sel_ldr sets up a larger alignment.
  */
 __attribute__((noinline))
 void check_pointer_is_aligned(void *pointer) {
+#if defined(__mips__)
+  assert((uintptr_t) pointer % 8 == 0);
+#else
   assert((uintptr_t) pointer % 16 == 0);
+#endif
 }
 
 void check_stack_is_aligned(void) {
   struct AlignedType var;
   check_pointer_is_aligned(&var);
 }
 
 
 void crash_at_known_address(void);
 extern char prog_ctr_at_crash[];
@@ skipping 13 matching lines @@
         ".popsection");
 #elif defined(__arm__)
 __asm__(".pushsection .text, \"ax\", %progbits\n"
         ".p2align 4\n"
         "crash_at_known_address:\n"
         "mov r0, #0\n"
         "bic r0, r0, #0xc0000000\n"
         "prog_ctr_at_crash:\n"
         "str r0, [r0]\n"
         ".popsection\n");
+#elif defined(__mips__)
+__asm__(".pushsection .text, \"ax\", %progbits\n"
+        ".p2align 4\n"
+        "crash_at_known_address:\n"
+        "ori $t0, $zero, 0\n"
+        "and $t0, $t0, $t7\n"
+        "prog_ctr_at_crash:\n"
+        "sw $t0, 0($t0)\n"
+        ".popsection\n");
 #else
 # error Unsupported architecture
 #endif
 
 
 void exception_handler(struct NaClExceptionContext *context);
 REGS_SAVER_FUNC_NOPROTO(exception_handler, exception_handler_wrapped);
 
 void exception_handler_wrapped(struct NaClSignalContext *entry_regs) {
   struct NaClExceptionContext *context =
       (struct NaClExceptionContext *) RegsGetArg1(entry_regs);
 
   printf("handler called\n");
 
   check_stack_is_aligned();
 
   assert(context->stack_ptr == (uint32_t) g_regs_at_crash.stack_ptr);
   assert(context->prog_ctr == (uintptr_t) prog_ctr_at_crash);
 #if defined(__i386__)
   assert(context->frame_ptr == g_regs_at_crash.ebp);
 #elif defined(__x86_64__)
   assert(context->frame_ptr == (uint32_t) g_regs_at_crash.rbp);
 #elif defined(__arm__)
   assert(context->frame_ptr == g_regs_at_crash.r11);
+#elif defined(__mips__)
+  assert(context->frame_ptr == g_regs_at_crash.frame_ptr);
 #else
 # error Unsupported architecture
 #endif
 
   /*
    * Convert the NaClUserRegisterState to a NaClSignalContext so that
    * we can reuse RegsAssertEqual() to compare the register state.
    */
   struct NaClSignalContext reported_regs;
   RegsCopyFromUserRegisterState(&reported_regs, &context->regs);
@@ skipping 53 matching lines @@
   g_registered_stack_size = stack_size;
 
   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;
+#elif defined(__mips__)
+  /* crash_at_known_address clobbers t0. */
+  g_regs_at_crash.t0 = 0;
 #endif
 
   if (!setjmp(g_jmp_buf)) {
     JUMP_WITH_REGS(&g_regs_at_crash, crash_at_known_address);
   }
   /* Clear the jmp_buf to prevent it from being reused accidentally. */
   memset(g_jmp_buf, 0, sizeof(g_jmp_buf));
 }
 
 void test_exceptions_minimally(void) {
@@ skipping 152 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);
 }