[MIPS] Avoid using LA macro in inline assembly

sandbox/linux/seccomp-bpf/syscall.cc

 // Copyright (c) 2012 The Chromium 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 "sandbox/linux/seccomp-bpf/syscall.h"
 
 #include <errno.h>
 #include <stdint.h>
 
 #include "base/logging.h"
@@ skipping 172 matching lines @@
     "2:ldmfd sp!, {fp, pc}\n"
 #endif
 #if !defined(__native_client_nonsfi__)
     // Do not use .fnstart and .fnend for PNaCl toolchain. See above comment,
     // for more details.
     ".fnend\n"
 #endif
     "9:.size SyscallAsm, 9b-SyscallAsm\n"
 #elif defined(__mips__)
     ".text\n"
+    ".option pic2\n"
     ".align 4\n"
+    ".global SyscallAsm\n"
     ".type SyscallAsm, @function\n"
     "SyscallAsm:.ent SyscallAsm\n"
     ".frame  $sp, 40, $ra\n"
     ".set   push\n"
     ".set   noreorder\n"
+    ".cpload $t9\n"
     "addiu  $sp, $sp, -40\n"
     "sw     $ra, 36($sp)\n"
     // Check if "v0" is negative. If so, do not attempt to make a
     // system call. Instead, compute the return address that is visible
     // to the kernel after we execute "syscall". This address can be
     // used as a marker that BPF code inspects.
     "bgez   $v0, 1f\n"
     " nop\n"
-    "la     $v0, 2f\n"
+    "lw     $v0, %got(2f)($gp)\n"

[mdempsky, 2016/04/28 16:02:13]

Please add a comment so someone doesn't come along and later try to helpfully
clean this up. E.g., explaining that this is equivalent to "la $v0, 2f", but LA
doesn't work with LLVM because of [insert link to LLVM bugzilla bug here].

[lmilko, 2016/05/04 15:13:05]

Done.

+    "addiu  $v0, $v0, %lo(2f)\n"
     "b      2f\n"
     " nop\n"
     // On MIPS first four arguments go to registers a0 - a3 and any
     // argument after that goes to stack. We can go ahead and directly
     // copy the entries from the arguments array into the appropriate
     // CPU registers and on the stack.
     "1:lw     $a3, 28($a0)\n"
     "lw     $a2, 24($a0)\n"
     "lw     $a1, 20($a0)\n"
     "lw     $t0, 16($a0)\n"
@@ skipping 37 matching lines @@
     "2:ret\n"
     ".cfi_endproc\n"
     ".size SyscallAsm, .-SyscallAsm\n"
 #endif
     );  // asm
 
 #if defined(__x86_64__)
 extern "C" {
 intptr_t SyscallAsm(intptr_t nr, const intptr_t args[6]);
 }
+#elif defined(__mips__)
+extern "C" {
+intptr_t SyscallAsm(intptr_t nr, const intptr_t args[8]);
+}
 #endif
 
 }  // namespace
 
 intptr_t Syscall::InvalidCall() {
   // Explicitly pass eight zero arguments just in case.
   return Call(kInvalidSyscallNumber, 0, 0, 0, 0, 0, 0, 0, 0);
 }
 
 intptr_t Syscall::Call(int nr,
@@ skipping 113 matching lines @@
     SECCOMP_PARM4(ctx) = 0;
 #endif
   SECCOMP_RESULT(ctx) = static_cast<greg_t>(ret_val);
 }
 
 #if defined(__mips__)
 intptr_t Syscall::SandboxSyscallRaw(int nr,
                                     const intptr_t* args,
                                     intptr_t* err_ret) {
   register intptr_t ret __asm__("v0") = nr;
+  register intptr_t syscallasm __asm__("t9") = (intptr_t) &SyscallAsm;
   // a3 register becomes non zero on error.
   register intptr_t err_stat __asm__("a3") = 0;
   {
     register const intptr_t* data __asm__("a0") = args;
     asm volatile(
-        "la $t9, SyscallAsm\n"
         "jalr $t9\n"
         " nop\n"
         : "=r"(ret), "=r"(err_stat)
         : "0"(ret),
-          "r"(data)
+          "r"(data),
+          "r"(syscallasm)
           // a2 is in the clober list so inline assembly can not change its
           // value.
-        : "memory", "ra", "t9", "a2");
+        : "memory", "ra", "a2");
   }
 
   // Set an error status so it can be used outside of this function
   *err_ret = err_stat;
 
   return ret;
 }
 #endif  // defined(__mips__)
 
 }  // namespace sandbox