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

src/trusted/service_runtime/arch/x86_64/nacl_syscall_64.S

 /*
  * 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.
  */
 
 /*
  * The MacOS assembler has a macro facility that is pretty close
  * to GNU as macros, but not quite the same.
  */
@@ skipping 23 matching lines @@
  * syscall trampoline code, and this code is responsible for figuring
  * out the identity of the thread, saving the user registers, finish
  * restoring the segment registers (and getting out of the sandbox),
  * and actually invoking the C system call handler code.
  */
 
 #include "native_client/src/trusted/service_runtime/arch/x86_64/sel_rt_64.h"
 #include "native_client/src/trusted/service_runtime/nacl_config.h"
 
 /*
- * This macro gets the thread index from the nacl_thread_index TLS variable
- * in Windows or Linux, or the corresponding pthread_getspecific(...) TSD
- * data in OSX and puts it in %eax.
+ * This macro gets the NaClThreadContext from the nacl_current_thread
+ * TLS variable in Windows or Linux, or the corresponding
+ * pthread_getspecific(...) TSD data in OSX and puts it in %rdx.
  *
- * May clobber two registers %rcx and %rdx (windows only).
+ * May clobber two registers, %rax and %rcx.
  *
- * If %rax contains 0, then this is an invalid thread.
+ * If %rdx contains 0, then this is an invalid thread.
  */
 MACRO(get_tls)
         /*
          * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
          *
          * Open coded TLS (or TSD) access, for all of our target host
          * OS/toolchains.  If the compiler / runtime conventions for
          * how to access TLS or TSD changes, this code will break
          * mysteriously.
          *
          * Any changes/fixes for this must be mirrored in nacl_test_capture.S
          *
          * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
          */
 #if NACL_LINUX
         /*
          * Linux uses TLS.
          * We use "@GOTTPOFF" rather than "@TPOFF" in order to be PIC-friendly.
          */
-        movq    nacl_thread_index@GOTTPOFF(%rip), %rax
-        movl    %fs:(%rax), %eax
+        movq    nacl_current_thread@GOTTPOFF(%rip), %rax
+        movq    %fs:(%rax), %rdx
 #elif NACL_OSX
         /*
          * This assumes a particular implementation of OS X's
          * pthread_getspecific(), which we check for in NaClTlsInit().
          */
-        movl    _nacl_thread_index_tls_offset(%rip), %eax
-        movl    %gs:(%rax), %eax
+        movl    _nacl_current_thread_tls_offset(%rip), %eax
+        movq    %gs:(%rax), %rdx
 #elif NACL_WINDOWS
         /*
          * NOTE: This code should match the code in platform/win/test_tls.S!
          * If you change this code, please update that file as well.
          *
          * The following two lines generate this instruction:
-         *   ba XX XX XX XX    movl $nacl_thread_index@SECREL, %edx
+         *   ba XX XX XX XX    movl $nacl_current_thread@SECREL, %edx
          *
          * SECREL is a relocation type which gives the offset of
-         * nacl_thread_index within the TLS template section.  GNU
+         * nacl_current_thread within the TLS template section.  GNU
          * binutils' assembler does not have a syntax for generating
          * this relocation as part of an instruction.  It only has the
          * .secrel32 syntax for generating the relocated value as a
          * 32-bit literal.  We use this here for generating the
          * instruction by hand.
          *
          * For background, see:
          * http://code.google.com/p/nativeclient/issues/detail?id=2155
          *
          * because of the need to do .byte, we cannot simply name the
          * scratch registers via macro arguments.
          */
         .byte 0xba
-        .secrel32 nacl_thread_index
+        .secrel32 nacl_current_thread
 
         mov _tls_index(%rip), %ecx
         movq %gs:0x58, %rax
         /* Get the address of this module (executable/DLL)'s TLS area. */
         movq (%rax,%rcx,8), %rax
-        /* Get the value of nacl_thread_index from the TLS area. */
-        movl (%rdx,%rax), %eax
+        /* Get the value of nacl_current_thread from the TLS area. */
+        movq (%rdx,%rax), %rdx
 #else
 # error "What OS/compiler is the service runtime being compiled with?"
 #endif
 ENDMACRO
 
 /*
  * On untrusted stack:
  *      return-addr-to-caller-of-trampoline
  *      return-addr-to-trampoline (essentially syscall number)
  *
@@ skipping 10 matching lines @@
         movl %r9d, -0x04(%rsp)
         movl %r8d, -0x08(%rsp)
         movl %ecx, -0x0c(%rsp)
         movl %edx, -0x10(%rsp)
         movl %esi, -0x14(%rsp)
         movl %edi, -0x18(%rsp)
 
         /* rax, rdi, rsi, rdx, rcx, r8, r9 are usable for scratch */
 
         get_tls
-
-        leaq    IDENTIFIER(nacl_user)(%rip), %rdx
-        movq    (%rdx,%rax,8), %rdx
         /*
          * Code below will segfault if %rdx is the NULL pointer, since
          * the zero page is unmapped.
          */
 
         /* only save the callee saved registers */
 DEFINE_GLOBAL_HIDDEN_IDENTIFIER(NaClSyscallThreadCaptureFault):
         movq    %rbx, NACL_THREAD_CONTEXT_OFFSET_RBX(%rdx)
         movq    %rbp, NACL_THREAD_CONTEXT_OFFSET_RBP(%rdx)
         /*
@@ skipping 70 matching lines @@
          * 0x10 -0x08 r8
          * 0x0c -0x0c rcx
          * 0x08 -0x10 rdx
          * 0x04 -0x14 rsi
          * 0x00 -0x18 rdi
          */
 
 MACRO(tls_syscall)
 MACROENTRY
         get_tls
-        leaq    IDENTIFIER(nacl_user)(%rip), %rdx
-        movq    (%rdx,%rax,8), %rdx
         movl    MACROARG2(%rdx), %eax
         /* sandbox the return, straight off the untrusted stack */
         movq    0x8(%rsp), %rcx
         addq    DOLLAR 0x10, %rsp
         addl    DOLLAR 31, %ecx
         andl    DOLLAR 0xffffffe0, %ecx
         addq    %r15, %rcx
         /*
          * Set %rdx to zero so that we do not leak the address of the
          * NaClThreadContext struct.  This also resets flags.
          * Resetting flags to fixed values by doing this last
          * simplifies testing that we do not leak any information via
          * flags.
          */
         xorl    %edx, %edx
         jmp     *%rcx
 ENDMACRO
 
         tls_syscall NaClGetTlsFastPath1, NACL_THREAD_CONTEXT_OFFSET_TLS_VALUE1
         tls_syscall NaClGetTlsFastPath2, NACL_THREAD_CONTEXT_OFFSET_TLS_VALUE2