[MIPS] Adding validator for MIPS architecture.

SConstruct

 #! -*- 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 atexit
 import glob
 import os
 import platform
 import shutil
@@ skipping 860 matching lines @@
 #.
 # We have "build" and "target" platforms for the non nacl environments
 # which govern service runtime, validator, etc.
 #
 # "build" means the  platform the code is running on
 # "target" means the platform the validator is checking for.
 # Typically they are the same but testing it useful to have flexibility.
 #
 # Various variables in the scons environment are related to this, e.g.
 #
-# BUILD_ARCH: (arm, x86)
+# BUILD_ARCH: (arm, mips, x86)
 # BUILD_SUBARCH: (32, 64)
 #
 # The settings can be controlled using scons command line variables:
 #
 #
 # buildplatform=: controls the build platform
 # targetplatform=: controls the target platform
 # platform=: controls both
 #
 # This dictionary is used to translate from a platform name to a
 # (arch, subarch) pair
 AVAILABLE_PLATFORMS = {
     'x86-32'      : { 'arch' : 'x86' , 'subarch' : '32' },
     'x86-64'      : { 'arch' : 'x86' , 'subarch' : '64' },
+    'mips32'      : { 'arch' : 'mips', 'subarch' : '32' },
     'arm'         : { 'arch' : 'arm' , 'subarch' : '32' },
     'arm-thumb2'  : { 'arch' : 'arm' , 'subarch' : '32' }
     }
 
 # Look up the platform name from the command line arguments,
 # defaulting to 'platform' if needed.
 def GetPlatform(name):
   platform = ARGUMENTS.get(name)
   if platform is None:
     return ARGUMENTS.get('platform', 'x86-32')
   elif ARGUMENTS.get('platform') is None:
     return platform
   else:
     raise Exception('Can\'t specify both %s and %s on the command line'
                     % ('platform', name))
 
 
 # Decode platform into list [ ARCHITECTURE , EXEC_MODE ].
 def DecodePlatform(platform):
   if platform in AVAILABLE_PLATFORMS:
     return AVAILABLE_PLATFORMS[platform]
   raise Exception('Unrecognized platform: %s' % platform)
 
 
 DeclareBit('build_x86_32', 'Building binaries for the x86-32 architecture',
            exclusive_groups='build_arch')
 DeclareBit('build_x86_64', 'Building binaries for the x86-64 architecture',
            exclusive_groups='build_arch')
+DeclareBit('build_mips32', 'Building binaries for the MIPS architecture',
+           exclusive_groups='build_arch')
 DeclareBit('build_arm_arm', 'Building binaries for the ARM architecture',
            exclusive_groups='build_arch')
 DeclareBit('build_arm_thumb2',
            'Building binaries for the ARM architecture (thumb2 ISA)',
            exclusive_groups='build_arch')
 DeclareBit('target_x86_32', 'Tools being built will process x86-32 binaries',
            exclusive_groups='target_arch')
 DeclareBit('target_x86_64', 'Tools being built will process x86-36 binaries',
            exclusive_groups='target_arch')
+DeclareBit('target_mips32', 'Tools being built will process MIPS binaries',
+           exclusive_groups='target_arch')
 DeclareBit('target_arm_arm', 'Tools being built will process ARM binaries',
            exclusive_groups='target_arch')
 DeclareBit('target_arm_thumb2',
            'Tools being built will process ARM binaries (thumb2 ISA)',
            exclusive_groups='target_arch')
 
 # Shorthand for either the 32 or 64 bit version of x86.
 DeclareBit('build_x86', 'Building binaries for the x86 architecture')
 DeclareBit('target_x86', 'Tools being built will process x86 binaries')
 
@@ skipping 26 matching lines @@
   if env.Bit('build_arm_arm') or env.Bit('build_arm_thumb2'):
     env.SetBits('build_arm')
 
   if env.Bit('target_x86_32') or env.Bit('target_x86_64'):
     env.SetBits('target_x86')
   if env.Bit('target_arm_arm') or env.Bit('target_arm_thumb2'):
     env.SetBits('target_arm')
 
   env.Replace(BUILD_ISA_NAME=GetPlatform('buildplatform'))
 
-  if env.Bit('target_arm') and not env.Bit('native_code'):
-    # This has always been a silent default on ARM.
-    env.SetBits('bitcode')
+  if env.Bit('target_arm') or env.Bit('target_mips32'):
+    if not env.Bit('native_code'):
+      # This is a silent default on ARM and MIPS.
+      env.SetBits('bitcode')
 
   # If it's not bitcode, it's native code.
   if not env.Bit('bitcode'):
     env.SetBits('native_code')
 
   # Determine where the object files go
   if BUILD_NAME == TARGET_NAME:
     BUILD_TARGET_NAME = TARGET_NAME
   else:
     BUILD_TARGET_NAME = '%s-to-%s' % (BUILD_NAME, TARGET_NAME)
@@ skipping 125 matching lines @@
 
 
 def GetValidator(env, validator):
   # NOTE: that the variable TRUSTED_ENV is set by ExportSpecialFamilyVars()
   if 'TRUSTED_ENV' not in env:
     return None
 
   if validator is None:
     if env.Bit('build_arm'):
       validator = 'arm-ncval-core'
+    elif env.Bit('build_mips32'):
+      validator = 'mips-ncval-core'
     else:
       validator = 'ncval'
 
   trusted_env = env['TRUSTED_ENV']
   return trusted_env.File('${STAGING_DIR}/${PROGPREFIX}%s${PROGSUFFIX}' %
                     validator)
 
 
 # Perform os.path.abspath rooted at the directory SConstruct resides in.
 def SConstructAbsPath(env, path):
@@ skipping 612 matching lines @@
     env.SideEffect(side_effect, node)
   # We can't check output if the test is not run.
   if not env.Bit('do_not_run_tests'):
     for action in post_actions:
       env.AddPostAction(node, action)
   return node
 
 pre_base_env.AddMethod(PPAPIBrowserTester)
 
 
-# Disabled for ARM because Chrome binaries for ARM are not available.
+# Disabled for ARM and MIPS because Chrome binaries for ARM and MIPS are not
+# available.
 def PPAPIBrowserTesterIsBroken(env):
-  return env.Bit('target_arm') or env.Bit('target_arm_thumb2')
+  return (env.Bit('target_arm') or env.Bit('target_arm_thumb2')
+          or env.Bit('target_mips32'))
 
 pre_base_env.AddMethod(PPAPIBrowserTesterIsBroken)
 
 # 3D is disabled everywhere
 def PPAPIGraphics3DIsBroken(env):
   return True
 
 pre_base_env.AddMethod(PPAPIGraphics3DIsBroken)
 
 
@@ skipping 191 matching lines @@
   # TODO(mseaborn): Fix by retrying the connection or by adding an
   # option to ld.so to disable its argv-over-IPC feature.
   if env.Bit('nacl_glibc') and not env.Bit('nacl_static_link'):
     return []
 
   if sel_universal_flags is None:
     sel_universal_flags = []
 
   # When run under qemu, sel_universal must sneak in qemu to the execv
   # call that spawns sel_ldr.
-  if env.Bit('target_arm') and env.UsingEmulator():
+  if env.UsingEmulator():
     sel_universal_flags.append('--command_prefix')
     sel_universal_flags.append(GetEmulator(env))
 
   if 'TRUSTED_ENV' not in env:
     return []
   sel_universal = env['TRUSTED_ENV'].File(
       '${STAGING_DIR}/${PROGPREFIX}sel_universal${PROGSUFFIX}')
 
   # Point to sel_ldr using an environment variable.
   sel_ldr = GetSelLdr(env)
@@ skipping 623 matching lines @@
       'tests/unittests/shared/platform/build.scons',
       'tests/unittests/trusted/asan/build.scons',
       'tests/unittests/trusted/platform_qualify/build.scons',
       'tests/unittests/trusted/service_runtime/build.scons',
       'installer/build.scons'
       ], ppapi_scons_files['trusted_scons_files'])
     )
 
   base_env.AddMethod(SDKInstallBin)
 
-  # The ARM validator can be built for any target that doesn't use ELFCLASS64.
+  # The ARM and MIPS validators can be built for any target that doesn't use
+  # ELFCLASS64.
   if not base_env.Bit('target_x86_64'):
     base_env.Append(
         BUILD_SCONSCRIPTS = [
           'src/trusted/validator_arm/build.scons',
+          'src/trusted/validator_mips/build.scons',
         ])
 
   base_env.Replace(
       NACL_BUILD_FAMILY = 'TRUSTED',
   )
 
   # Add optional scons files if present in the directory tree.
   if os.path.exists(pre_base_env.subst('${MAIN_DIR}/supplement/build.scons')):
     base_env.Append(BUILD_SCONSCRIPTS=['${MAIN_DIR}/supplement/build.scons'])
 
@@ skipping 361 matching lines @@
                                  '-isystem',
                                  jail + '/usr/include',
                                 ])
       # /usr/lib makes sense for most configuration except this one
       # No ARM compatible libs can be found there.
       # So this just makes the command lines longer and sometimes results
       # in linker warnings referring to this directory.
       linux_env.FilterOut(LIBPATH=['/usr/lib'])
      # This appears to be needed for sel_universal
     linux_env.Append(LIBS=['dl'])
+  elif linux_env.Bit('build_mips32'):
+    # TODO(petarj): Add support for MIPS.
+    pass
   else:
     Banner('Strange platform: %s' % BUILD_NAME)
 
   # These are desireable options for every Linux platform:
   # _FORTIFY_SOURCE: general paranoia "hardening" option for library functions
   # -fPIE/-pie: create a position-independent executable
   # relro/now: "hardening" options for linking
   # noexecstack: ensure that the executable does not get a PT_GNU_STACK
   #              header that causes the kernel to set the READ_IMPLIES_EXEC
   #              personality flag, which disables NX page protection.
@@ skipping 905 matching lines @@
   nacl_env.ValidateSdk()
 
 if BROKEN_TEST_COUNT > 0:
   msg = "There are %d broken tests." % BROKEN_TEST_COUNT
   if GetOption('brief_comstr'):
     msg += " Add --verbose to the command line for more information."
   print msg
 
 # separate warnings from actual build output
 Banner('B U I L D - O U T P U T:')