Remove nacl_user[] array lookup from syscall code path on x86-64 and MIPS

src/trusted/service_runtime/nacl_signal_common.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 <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ skipping 49 matching lines @@
 
 /*
  * Returns, via is_untrusted, whether the signal happened while
  * executing untrusted code.
  *
  * Returns, via result_thread, the NaClAppThread that untrusted code
  * was running in.
  *
  * Note that this should only be called from the thread in which the
  * signal occurred, because on x86-64 it reads a thread-local variable
- * (nacl_thread_index).
+ * (nacl_current_thread).
  */
 void NaClSignalContextGetCurrentThread(const struct NaClSignalContext *sig_ctx,
                                        int *is_untrusted,
                                        struct NaClAppThread **result_thread) {
 #if NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86 && NACL_BUILD_SUBARCH == 32
   /*
    * For x86-32, if %cs does not match, it is untrusted code.
    *
    * Note that this check may not be valid on Mac OS X, because
    * thread_get_state() does not return the value of NaClGetGlobalCs()
    * for a thread suspended inside a syscall.
    * TODO(mseaborn): Don't define this function on Mac OS X.  We can
    * compile this conditionally when NaCl's POSIX signal handler is no
    * longer built for Mac.
    * See https://code.google.com/p/nativeclient/issues/detail?id=2664
    */
   *is_untrusted = (NaClGetGlobalCs() != sig_ctx->cs);
   *result_thread = NaClAppThreadGetFromIndex(sig_ctx->gs >> 3);
 #elif (NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86 && NACL_BUILD_SUBARCH == 64) || \
       NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm || \
       NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips
-  uint32_t current_thread_index = NaClTlsGetIdx();
-  if (NACL_TLS_INDEX_INVALID == current_thread_index) {
+  struct NaClAppThread *natp = NaClTlsGetCurrentThread();
+  if (natp == NULL) {
     *is_untrusted = 0;
     *result_thread = NULL;
   } else {
-    struct NaClAppThread *thread =
-        NaClAppThreadGetFromIndex(current_thread_index);
     /*
      * Get the address of an arbitrary local, stack-allocated variable,
      * just for the purpose of doing a sanity check.
      */
-    void *pointer_into_stack = &thread;
+    void *pointer_into_stack = &natp;
     /*
      * Sanity check: Make sure the stack we are running on is not
      * allocated in untrusted memory.  This checks that the alternate
      * signal stack is correctly set up, because otherwise, if it is
      * not set up, the test case would not detect that.
      *
      * There is little point in doing a CHECK instead of a DCHECK,
      * because if we are running off an untrusted stack, we have already
      * lost.
      *
      * We do not do the check on Windows because Windows does not have
      * an equivalent of sigaltstack() and this signal handler is
      * insecure there.
      */
     if (!NACL_WINDOWS) {
-      DCHECK(!NaClIsUserAddr(thread->nap, (uintptr_t) pointer_into_stack));
+      DCHECK(!NaClIsUserAddr(natp->nap, (uintptr_t) pointer_into_stack));
     }
-    *is_untrusted = NaClIsUserAddr(thread->nap, sig_ctx->prog_ctr);
-    *result_thread = thread;
+    *is_untrusted = NaClIsUserAddr(natp->nap, sig_ctx->prog_ctr);
+    *result_thread = natp;
   }
 #else
 # error Unsupported architecture
 #endif
 
   /*
    * Trusted code could accidentally jump into sandbox address space,
    * so don't rely on prog_ctr on its own for determining whether a
    * crash comes from untrusted code.  We don't want to restore
    * control to an untrusted exception handler if trusted code
@@ skipping 183 matching lines @@
   }
 
   NaClSignalHandlerInitPlatform();
   NaClSignalHandlerAdd(NaClSignalHandleUntrusted);
 }
 
 void NaClSignalHandlerFini(void) {
   /* We try to lock, but since we are shutting down, we ignore failures. */
   NaClSignalHandlerFiniPlatform();
 }