[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 893 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' },
+    'mips'        : { 'arch' : 'mips', 'subarch' : '32' },

[Mark Seaborn, 2012/04/04 21:04:22]

Should this be called "mips32"?

     '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_mips', '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_mips', '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 30 matching lines @@
     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('bitcode'):
     # This has always been a silent default on ARM.
     env.SetBits('bitcode')
 
+  if env.Bit('target_mips') and not env.Bit('bitcode'):
+    # This is a silent default on MIPS.
+    env.SetBits('bitcode')
+
   # 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)
   env.Replace(BUILD_TARGET_NAME=BUILD_TARGET_NAME)
   # This may be changed later; see target_variant_map, below.
   env.Replace(TARGET_VARIANT='')
   env.Replace(TARGET_ROOT=
       '${DESTINATION_ROOT}/${BUILD_TYPE}-${BUILD_TARGET_NAME}${TARGET_VARIANT}')
@@ 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_mips'):
+      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 555 matching lines @@
   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.
 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_mips'))

[Mark Seaborn, 2012/04/04 21:04:22]

Nit: Indent by 1 more to line up with '('

 
 pre_base_env.AddMethod(PPAPIBrowserTesterIsBroken)
 
 # 3D is disabled everywhere
 def PPAPIGraphics3DIsBroken(env):
   return True
 
 pre_base_env.AddMethod(PPAPIGraphics3DIsBroken)
 
 
@@ skipping 192 matching lines @@
 
   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():
     sel_universal_flags.append('--command_prefix')
     sel_universal_flags.append(GetEmulator(env))
 
+  if env.Bit('target_mips') and env.UsingEmulator():

[Mark Seaborn, 2012/04/04 21:04:22]

This is a duplicate of the previous block, right?  You could just remove the
env.Bit('target_arm') conditional on the previous block, because it's redundant.

+    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)
   if sel_ldr is None:
     print 'WARNING: no sel_ldr found. Skipping test %s' % name
     return []
@@ skipping 581 matching lines @@
     )
 
   base_env.AddMethod(SDKInstallBin)
 
   # The ARM validator 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',
         ])
+    if base_env.Bit('target_mips'):

[Mark Seaborn, 2012/04/04 21:04:22]

Please make this unconditional: I want to ensure that the MIPS validator builds
OK everywhere (and the tests should pass everywhere too).  For background, see
http://code.google.com/p/nativeclient/issues/detail?id=574.

+      base_env.Append(
+        BUILD_SCONSCRIPTS = [
+          'src/trusted/validator_mips/build.scons',
+        ])
 
   base_env.Replace(
       NACL_BUILD_FAMILY = 'TRUSTED',
 
       SDL_HERMETIC_LINUX_DIR='${MAIN_DIR}/../third_party/sdl/linux/v1_2_13',
       SDL_HERMETIC_MAC_DIR='${MAIN_DIR}/../third_party/sdl/osx/v1_2_13',
       SDL_HERMETIC_WINDOWS_DIR='${MAIN_DIR}/../third_party/sdl/win/v1_2_13',
   )
 
   # Add optional scons files if present in the directory tree.
@@ skipping 416 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_mips'):
+    print 'placeholder for MIPS'

[Mark Seaborn, 2012/04/04 21:04:22]

You can just replace this with "pass".  No need to print anything.

   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 940 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:')