[MIPS] Support for building tests for MIPS

run.py

 #!/usr/bin/python
 # 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.
 
 import os
 import platform
 import subprocess
 import sys
 
@@ skipping 24 matching lines @@
   --irt=none             Don't use IRT
   --irt=<path>           Path to IRT nexe
   Default: Uses whichever IRT already exists. Otherwise, builds irt_core.
 
   -n | --dry-run         Just print commands, don't execute them
   -h | --help            Display this information
   -q | --quiet           Don't print anything (nexe output can be redirected
                          with NACL_EXE_STDOUT/STDERR env vars)
   --more                 Display sel_ldr usage
 
-  -arch <arch> | -m32 | -m64 | -marm
+  -arch <arch> | -m32 | -m64 | -marm | -mmips32
                          Specify architecture for PNaCl translation
-                         (arch is one of: x86-32, x86-64 or arm)
+                         (arch is one of: x86-32, x86-64, arm or mips32)
 '''
   print info % name
   print '-' * 80
   sys.exit(0)
 
 def SetupEnvironment():
   # linux, win, or mac
   env.scons_os = GetSconsOS()
 
   # native_client/ directory
   env.nacl_root = FindBaseDir()
 
   # Path to Native NaCl toolchain (glibc)
   env.nnacl_root = os.path.join(env.nacl_root,
                                 'toolchain',
                                 env.scons_os + '_x86')
 
   # Path to PNaCl toolchain
   pnacl_label = 'pnacl_%s_%s' % (GetSconsOS(), GetBuildArch().replace('-','_'))
   env.pnacl_base = os.path.join(env.nacl_root, 'toolchain', pnacl_label)
   env.pnacl_root_newlib = os.path.join(env.pnacl_base, 'newlib')
   env.pnacl_root_glibc = os.path.join(env.pnacl_base, 'glibc')
 
   # QEMU
   env.arm_root = os.path.join(env.nacl_root,
                               'toolchain', 'linux_arm-trusted')
-  env.qemu = os.path.join(env.arm_root, 'run_under_qemu_arm')
+  env.qemu_arm = os.path.join(env.arm_root, 'run_under_qemu_arm')
+
+  env.mips32_root = os.path.join(env.nacl_root,
+                                 'toolchain', 'linux_mips-trusted')
+  env.qemu_mips32 = os.path.join(env.mips32_root, 'run_under_qemu_mips32')
 
   # Path to 'readelf'
   env.readelf = FindReadElf()
 
   # Path to 'scons'
   env.scons = os.path.join(env.nacl_root, 'scons')
 
   # Library path for runnable-ld.so
   env.library_path = []
 
   # Suppress -S -a
   env.paranoid = False
 
   # Only print commands, don't run them
   env.dry_run = False
 
   # Force a specific sel_ldr
   env.force_sel_ldr = None
 
   # Force a specific IRT
   env.force_irt = None
 
   # Don't print anything
   env.quiet = False
 
-  # Arch (x86-32, x86-64, arm)
+  # Arch (x86-32, x86-64, arm, mips32)
   env.arch = None
 
   # Trace in QEMU
   env.trace = False
 
   # Debug the nexe using the debug stub
   env.debug = False
 
 def PrintBanner(output):
   if not env.quiet:
@@ skipping 103 matching lines @@
   sel_ldr_args += [os.path.abspath(nexe)] + nexe_params
 
   # Run sel_ldr!
   RunSelLdr(sel_ldr_args)
   return 0
 
 
 def RunSelLdr(args):
   prefix = []
   if GetBuildArch().find('arm') == -1 and env.arch == 'arm':
-    prefix = [ env.qemu, '-cpu', 'cortex-a8']
+    prefix = [ env.qemu_arm, '-cpu', 'cortex-a8']
     if env.trace:
       prefix += ['-d', 'in_asm,op,exec,cpu']
     args = ['-Q'] + args
+
+  if GetBuildArch().find('mips32') == -1 and env.arch == 'mips32':
+    prefix = [env.qemu_mips32]
+    if env.trace:
+      prefix += ['-d', 'in_asm,op,exec,cpu']
+    args = ['-Q'] + args
 
   # Use the bootstrap loader on linux.
   if env.scons_os == 'linux':
     bootstrap = os.path.join(os.path.dirname(env.sel_ldr),
                              'nacl_helper_bootstrap')
     loader = [bootstrap, env.sel_ldr]
     template_digits = 'X' * 16
     args = ['--r_debug=0x' + template_digits,
             '--reserved_at_zero=0x' + template_digits] + args
   else:
@@ skipping 186 matching lines @@
           Fatal('Missing argument to -L')
       else:
         path = arg[len('-L'):]
       env.library_path.append(path)
     elif arg == '-m32':
       env.arch = 'x86-32'
     elif arg == '-m64':
       env.arch = 'x86-64'
     elif arg == '-marm':
       env.arch = 'arm'
+    elif arg == '-mmips32':
+      env.arch = 'mips32'
     elif arg == '-arch':
       if i+1 < len(argv):
         env.arch = FixArch(argv[i+1])
         skip_one = True
     elif arg == '--paranoid':
       env.paranoid = True
     elif arg.startswith('--loader='):
       env.force_sel_ldr = arg[len('--loader='):]
     elif arg.startswith('--irt='):
       env.force_irt = arg[len('--irt='):]
@@ skipping 20 matching lines @@
 
   nexe_params = argv[i+1:]
 
   return sel_ldr_options, nexe, nexe_params
 
 
 def FixArch(arch):
   x86_32 = 'x86-32 x86_32 x8632 i386 i686 ia32'.split()
   x86_64 = 'amd64 x86_64 x86-64 x8664'.split()
   arm = 'arm armv7'.split()
+  mips32 = 'mips mips32'.split()
 
   if arch in x86_32:
     return 'x86-32'
 
   if arch in x86_64:
     return 'x86-64'
 
   if arch in arm:
     return 'arm'
 
+  if arch in mips32:
+    return 'mips32'
+
   Fatal('Unrecognized arch "%s"!', arch)
 
 
 def Fatal(msg, *args):
   if len(args) > 0:
     msg = msg % args
   print msg
   sys.exit(1)
 
 def Usage2():
   # Try to find any sel_ldr that already exists
-  for arch in ['x86-32','x86-64','arm']:
+  for arch in ['x86-32','x86-64','arm','mips32']:
     SetupArch(arch, allow_build = False)
     if env.sel_ldr:
       break
 
   if not env.sel_ldr:
     # If nothing exists, build it.
     SetupArch('x86-32')
 
   RunSelLdr(['-h'])
 
@@ skipping 41 matching lines @@
 
   if not machine_line:
     Fatal('Script error: readelf output did not make sense!')
 
   if 'Intel 80386' in machine_line:
     arch = 'x86-32'
   elif 'X86-64' in machine_line:
     arch = 'x86-64'
   elif 'ARM' in machine_line:
     arch = 'arm'
+  elif 'MIPS' in machine_line:
+    arch = 'mips32'
   else:
     Fatal('%s: Unknown machine type', f)
 
   return (arch, is_dynamic, is_glibc_static)
 
 
 def GetSconsOS():
   name = platform.system().lower()
   if name == 'linux':
     return 'linux'
@@ skipping 19 matching lines @@
       # We've hit the file system root
       break
 
   if os.path.basename(curdir) != 'native_client':
     Fatal('Unable to find native_client directory!')
   return curdir
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))