[MIPS] Add remaining parts for building tests for MIPS

tests/common/register_set.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 "native_client/tests/common/register_set.h"
 
 #include <assert.h>
 #include <stddef.h>
@@ skipping 69 matching lines @@
   DEFINE_REG(r7),
   DEFINE_REG(r8),
   DEFINE_REG(r9),
   DEFINE_REG(r10),
   DEFINE_REG(r11),
   DEFINE_REG(r12),
   DEFINE_REG(stack_ptr),
   DEFINE_REG(lr),
   DEFINE_REG(prog_ctr),
   DEFINE_REG(cpsr)
+#elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips
+  DEFINE_REG(zero),
+  DEFINE_REG(at),
+  DEFINE_REG(v0),
+  DEFINE_REG(v1),
+  DEFINE_REG(a0),
+  DEFINE_REG(a1),
+  DEFINE_REG(a2),
+  DEFINE_REG(a3),
+  DEFINE_REG(t0),
+  DEFINE_REG(t1),
+  DEFINE_REG(t2),
+  DEFINE_REG(t3),
+  DEFINE_REG(t4),
+  DEFINE_REG(t5),
+  DEFINE_REG(t6),
+  DEFINE_REG(t7),
+  DEFINE_REG(s0),
+  DEFINE_REG(s1),
+  DEFINE_REG(s2),
+  DEFINE_REG(s3),
+  DEFINE_REG(s4),
+  DEFINE_REG(s5),
+  DEFINE_REG(s6),
+  DEFINE_REG(s7),
+  DEFINE_REG(t8),
+  DEFINE_REG(t9),
+  DEFINE_REG(k0),
+  DEFINE_REG(k1),
+  DEFINE_REG(global_ptr),
+  DEFINE_REG(stack_ptr),
+  DEFINE_REG(frame_ptr),
+  DEFINE_REG(return_addr),
+  DEFINE_REG(prog_ctr)
 #else
 # error Unsupported architecture
 #endif
 };
 
 #undef DEFINE_REG
 
 /* Flags readable and writable by untrusted code. */
 const uint8_t kX86FlagBits[5] = { 0, 2, 6, 7, 11 };
 /*
@@ skipping 52 matching lines @@
     fprintf(stderr, "  %s=0x%llx (%lld)\n",
             kRegs[regnum].reg_name, value, value);
   }
 }
 
 static void RegsNormalizeFlags(struct NaClSignalContext *regs) {
 #if NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86
   regs->flags &= kX86KnownFlagsMask;
 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm
   regs->cpsr &= REGS_ARM_USER_CPSR_FLAGS_MASK;
+#elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips
+  /* No flags field on MIPS. */
+  UNREFERENCED_PARAMETER(regs);
 #endif
 }
 
 void RegsAssertEqual(const struct NaClSignalContext *actual,
                      const struct NaClSignalContext *expected) {
   int match = 1;
   unsigned int regnum;
 
   /* Make a copy so that we can ignore some of the x86/ARM flags. */
   struct NaClSignalContext copy_actual = *actual;
   struct NaClSignalContext copy_expected = *expected;
   RegsNormalizeFlags(&copy_actual);
   RegsNormalizeFlags(&copy_expected);
 
 #if NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm
   /*
    * We skip comparison of r9 because it is not supposed to be
    * settable or readable by untrusted code.  However, for debugging
    * purposes we still include r9 in register dumps printed by
    * RegsDump(), so r9 remains listed in kRegs[].
    */
   copy_expected.r9 = copy_actual.r9;
+#elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips
+  /*
+   * For t6 and t7 we expect to hold control flow masks. For t8, which holds TLS

[Mark Seaborn, 2013/03/11 15:54:38]

How about: "The registers below are all read-only, so we skip their comparison. 
We expect t6 and t7 to hold control flow and data masks..."

+   * index, we skip comparison. Zero register holds zero allways. All of the

[Mark Seaborn, 2013/03/11 15:54:38]

"always"

+   * above named registers are not settable by untrusted code. We also skip
+   * comparison for k0 and k1 registers because those are registers reserved for
+   * use by interrupt/trap handler and therefore volatile.

[Mark Seaborn, 2013/03/11 15:54:38]

Does this mean untrusted code can read the values of k0/k1 left behind by
interrupt/trap handlers?  Isn't that a trusted->untrusted information leak? 
What sort of handlers are you referring to?  Userland signal handlers, or
something in the kernel?

+   * However, for debugging purposes we still include those in register dumps
+   * printed by RegsDump(), so they remain listed in kRegs[].
+   */
+  copy_expected.zero = 0;
+  copy_expected.t6 = NACL_CONTROL_FLOW_MASK;
+  copy_expected.t7 = NACL_DATA_FLOW_MASK;
+  copy_expected.t8 = copy_actual.t8;
+  copy_expected.k0 = copy_actual.k0;
+  copy_expected.k1 = copy_actual.k1;
 #endif
 
   for (regnum = 0; regnum < NACL_ARRAY_SIZE(kRegs); regnum++) {
     if (RegsGetRegValue(&copy_actual, regnum) !=
         RegsGetRegValue(&copy_expected, regnum)) {
       fprintf(stderr, "Mismatch in register %s\n", kRegs[regnum].reg_name);
       match = 0;
     }
   }
   if (!match) {
@@ skipping 39 matching lines @@
   regs->r11 = 0;
   regs->flags = 0;
 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm
   regs->r0 = 0;
   regs->r1 = 0;
   regs->r2 = 0;
   regs->r3 = 0;
   regs->r12 = 0;
   regs->lr = 0;
   regs->cpsr = 0;
+#elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips
+  regs->zero = 0;
+  regs->at = 0;
+  regs->v0 = 0;
+  regs->v1 = 0;
+  regs->a0 = 0;
+  regs->a1 = 0;
+  regs->a2 = 0;
+  regs->a3 = 0;
+  regs->t0 = 0;
+  regs->t1 = 0;
+  regs->t2 = 0;
+  regs->t3 = 0;
+  regs->t4 = 0;
+  regs->t5 = 0;
+  regs->t9 = 0;
+  regs->k0 = 0;
+  regs->k1 = 0;
+  regs->global_ptr  = 0;
+  regs->return_addr = 0;
 #else
 # error Unsupported architecture
 #endif
 }
 
 #if defined(__native_client__)
 #if NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86 && NACL_BUILD_SUBARCH == 32
 
 uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) {
   return ((uint32_t *) regs->stack_ptr)[1];
 }
 
 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86 && NACL_BUILD_SUBARCH == 64
 
 uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) {
   return regs->rdi;
 }
 
 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm
 
 uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) {
   return regs->r0;
 }
 
+#elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips
+
+uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) {
+  return regs->a0;
+}
+
 #else
 # error Unsupported architecture
 #endif
 #endif