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

src/trusted/service_runtime/arch/x86_64/nacl_tls_64.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.
  */
 
 #if NACL_OSX
 # include <pthread.h>
 #endif
 
@@ skipping 125 matching lines @@
 uint32_t NaClTlsGetTlsValue2(struct NaClAppThread *natp) {
   return natp->user.tls_value2;
 }
 
 uint32_t NaClGetThreadIdx(struct NaClAppThread *natp) {
   return natp->user.tls_idx;
 }
 
 #if NACL_OSX
 
-pthread_key_t nacl_thread_info_key;
-uint32_t nacl_thread_index_tls_offset;
+static pthread_key_t nacl_thread_info_key;
+uint32_t nacl_current_thread_tls_offset;
 
 int NaClTlsInit(void) {
   int errnum;
 
   /*
    * Unlike Linux and Windows, Mac OS X does not provide TLS variables
    * that can be accessed via a TLS register without a function call,
    * which we need in order to restore the thread's trusted stack in
    * nacl_syscall_64.S.
    *
@@ skipping 32 matching lines @@
     return 0;
   }
 
   errnum = pthread_key_create(&nacl_thread_info_key, (void (*)(void *)) 0);
   if (0 != errnum) {
     NaClLog(LOG_WARNING,
             "NaClTlsInit: pthread_key_create failed for thread info key, %d\n",
             errnum);
     return 0;
   }
-  nacl_thread_index_tls_offset = pthread_tsd_offset + 8 * nacl_thread_info_key;
+  nacl_current_thread_tls_offset =
+      pthread_tsd_offset + 8 * nacl_thread_info_key;
 
   return 1;
 }
 
 void NaClTlsFini(void) {
   int errnum = pthread_key_delete(nacl_thread_info_key);
   if (0 != errnum) {
     NaClLog(LOG_FATAL,
             "NaClTlsInit: pthread_key_delete failed for thread info key, %d\n",
             errnum);
   }
   NaClThreadIdxFini();
   return;
 }
 
-void NaClTlsSetIdx(uint32_t tls_idx) {
-  uint32_t tls_idx_check;
+void NaClTlsSetCurrentThread(struct NaClAppThread *natp) {
+  struct NaClThreadContext *ntcp_check;
 
 #if 1  /* PARANOIA */
   if (NULL != pthread_getspecific(nacl_thread_info_key)) {
     NaClLog(LOG_WARNING,
             "NaClSetThreadInfo invoked twice for the same thread\n");
   }
 #endif
-  pthread_setspecific(nacl_thread_info_key, (void *) (uintptr_t) tls_idx);
+  if (pthread_setspecific(nacl_thread_info_key, &natp->user) != 0) {
+    NaClLog(LOG_FATAL, "NaClTlsSetCurrentThread: "
+            "pthread_setspecific() failed\n");
+  }
 
   /*
    * Sanity check:  Make sure that reading back the value using our
    * knowledge of Mac OS X's TLS internals gives us the correct value.
    * This checks that we inferred _PTHREAD_TSD_OFFSET correctly earlier.
    */
-  __asm__("movl %%gs:(%1), %0"
-          : "=r"(tls_idx_check)
-          : "r"(nacl_thread_index_tls_offset));
-  if (tls_idx_check != tls_idx) {
-    NaClLog(LOG_FATAL, "NaClTlsSetIdx: Sanity check failed: "
+  __asm__("movq %%gs:(%1), %0"
+          : "=r"(ntcp_check)
+          : "r"(nacl_current_thread_tls_offset));
+  if (ntcp_check != &natp->user) {
+    NaClLog(LOG_FATAL, "NaClTlsSetCurrentThread: Sanity check failed: "
             "TLS offset must be wrong\n");
   }
 }
 
 /*
  * May be called from asm (or have compiler-generated code copied into
  * asm)!  We assume that register state is amenable to the use of
  * pthread_getspecific.  For both x86-32 and x86-64 OSX, this compiles
  * to just a memory load using the %gs or %fs segment prefixes, and
  * for x86-64 we do not change %fs.  (However, we are unlikely to use
  * this for x86-32 on OSX, since that's handled by NaCl "Classic"
  * where %gs gets swapped, and we use %gs >> 3 in the asm code.)
  */
-uint32_t NaClTlsGetIdx(void) {
-  return (intptr_t) pthread_getspecific(nacl_thread_info_key);
+struct NaClAppThread *NaClTlsGetCurrentThread(void) {
+  struct NaClThreadContext *ntcp = pthread_getspecific(nacl_thread_info_key);
+  return NaClAppThreadFromThreadContext(ntcp);
 }
 
 #elif NACL_LINUX || NACL_WINDOWS
 
-THREAD uint32_t nacl_thread_index;
-/* encoded index; 0 is used to indicate error */
+/* May be NULL if the current thread does not host a NaClAppThread. */
+THREAD struct NaClThreadContext *nacl_current_thread;
 
 int NaClTlsInit(void) {
-
   NaClThreadStartupCheck();
 
   if (!NaClThreadIdxInit()) {
     return 0;
   }
   return 1;
 }
 
 void NaClTlsFini(void) {
   NaClThreadIdxFini();
 }
 
 /*
  * On x86-64, we must avoid using segment registers since Windows
  * Vista 64, Windows 7 64, etc do not permit user code to create LDT
  * entries.  The sandboxing scheme reserves %r15 for the base of the
  * NaCl app's 4G address space, but does not reserve any additional
  * registers for thread identity.  This reduces additional register
  * pressure, but implies that we have to figure out the thread
  * identity in some other way -- we use TLS (or TSD, see below) to do
  * so, and on context switch we must access the TLS variable in order
  * to determine where to save the user register context.
  */
-void NaClTlsSetIdx(uint32_t tls_idx) {
-  nacl_thread_index = tls_idx;
+void NaClTlsSetCurrentThread(struct NaClAppThread *natp) {
+  nacl_current_thread = &natp->user;
 }
 
-uint32_t NaClTlsGetIdx(void) {
-  return nacl_thread_index;
+struct NaClAppThread *NaClTlsGetCurrentThread(void) {
+  return NaClAppThreadFromThreadContext(nacl_current_thread);
 }
 
 #else
 # error "Woe to the service runtime.  What OS is it being compiled for?!?"
 #endif