Added arguments to NaCl scons to allow custom toolchain directories.

site_scons/site_tools/naclsdk.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.
 
 """NaCl SDK tool SCons."""
 
 import __builtin__
 import re
 import os
@@ skipping 40 matching lines @@
 
   Args:
     env: The SCons environment in question.
   """
   assert(env.Bit('built_elsewhere'))
   env.Replace(CC='true', CXX='true', LINK='true', AR='true',
               RANLIB='true', AS='true', ASPP='true', LD='true',
               STRIP='true')
 
 
-def _GetNaClSdkRoot(env, sdk_mode, psdk_mode):
-  """Return the path to the sdk.
-
-  Args:
-    env: The SCons environment in question.
-    sdk_mode: A string indicating which location to select the tools from.
-  Returns:
-    The path to the sdk.
-  """
-
-  # Allow pnacl to override its path separately.  See comments for why
-  # psdk_mode is separate from sdk_mode.
-  if env.Bit('bitcode') and psdk_mode.startswith('custom:'):
-    return os.path.abspath(psdk_mode[len('custom:'):])
-
-  if sdk_mode == 'local':
-    if env['PLATFORM'] in ['win32', 'cygwin']:
-      # Try to use cygpath under the assumption we are running thru cygwin.
-      # If this is not the case, then 'local' doesn't really make any sense,
-      # so then we should complain.
-      try:
-        path = subprocess.Popen(
-            ['cygpath', '-m', '/usr/local/nacl-sdk'],
-            shell=True,
-            stdout=subprocess.PIPE).communicate()[0].replace('\n', '')
-      except WindowsError:
-        raise NotImplementedError(
-            'Not able to decide where /usr/local/nacl-sdk is on this platform,'
-            'use naclsdk_mode=custom:...')
-      return path
-    else:
-      return '/usr/local/nacl-sdk'
-
-  elif sdk_mode == 'download':
-    return env.GetToolchainDir()
-  elif sdk_mode.startswith('custom:'):
-    return os.path.abspath(sdk_mode[len('custom:'):])
-
-  elif sdk_mode == 'manual':
-    return None
-
-  else:
-    raise Exception('Unknown sdk mode: %r' % sdk_mode)
-
-
 def _SetEnvForNativeSdk(env, sdk_path):
   """Initialize environment according to target architecture."""
 
   bin_path = os.path.join(sdk_path, 'bin')
   # NOTE: attempts to eliminate this PATH setting and use
   #       absolute path have been futile
   env.PrependENVPath('PATH', bin_path)
 
   tool_prefix = None
   tool_map = NACL_TOOL_MAP[env['TARGET_ARCHITECTURE']]
@@ skipping 217 matching lines @@
   if env.Bit('built_elsewhere'):
     def FakeInstall(dest, source, env):
       print 'Not installing', dest
     _StubOutEnvToolsForBuiltElsewhere(env)
     env.Replace(INSTALL=FakeInstall)
     if env.Bit('translate_in_build_step'):
       env.Replace(TRANSLATE='true')
     env.Replace(PNACLFINALIZE='true')
 
 
-def _SetEnvForSdkManually(env):
-  def GetEnvOrDummy(v):
-    return os.getenv('NACL_SDK_' + v, 'MISSING_SDK_' + v)
-
-  env.Replace(# Replace header and lib paths.
-              NACL_SDK_INCLUDE=GetEnvOrDummy('INCLUDE'),
-              NACL_SDK_LIB=GetEnvOrDummy('LIB'),
-              # Replace the normal unix tools with the NaCl ones.
-              CC=GetEnvOrDummy('CC'),
-              CXX=GetEnvOrDummy('CXX'),
-              AR=GetEnvOrDummy('AR'),
-              # NOTE: use g++ for linking so we can handle c AND c++
-              LINK=GetEnvOrDummy('LINK'),
-              RANLIB=GetEnvOrDummy('RANLIB'),
-              )
-
 def PNaClForceNative(env):
   assert(env.Bit('bitcode'))
   if env.Bit('pnacl_generate_pexe'):
     env.Replace(CC='NO-NATIVE-CC-INVOCATION-ALLOWED',
                 CXX='NO-NATIVE-CXX-INVOCATION-ALLOWED')
     return
 
   env.Replace(OBJSUFFIX='.o',
               SHLIBSUFFIX='.so')
   arch_flag = ' -arch ${TARGET_FULLARCH}'
@@ skipping 275 matching lines @@
 
   NOTE: SCons requires the use of this name, which fails lint.
   """
 
   # make these methods to the top level scons file
   env.AddMethod(ValidateSdk)
   env.AddMethod(AddBiasForPNaCl)
   env.AddMethod(PNaClForceNative)
   env.AddMethod(PNaClGetNNaClEnv)
 
-  # Get configuration option for getting the naclsdk.  Default is download.
-  # We have a separate flag for pnacl "psdk_mode" since even with PNaCl,
-  # the native nacl-gcc toolchain is used to build some parts like
-  # the irt-core.
-  sdk_mode = SCons.Script.ARGUMENTS.get('naclsdk_mode', 'download')
-  psdk_mode = SCons.Script.ARGUMENTS.get('pnaclsdk_mode', 'default')
-  if psdk_mode != 'default' and not psdk_mode.startswith('custom:'):
-    raise Exception(
-      'pnaclsdk_mode only supports "default" or "custom:path", not %s' %
-      psdk_mode)
-
   # Invoke the various unix tools that the NativeClient SDK resembles.
   env.Tool('g++')
   env.Tool('gcc')
   env.Tool('gnulink')
   env.Tool('ar')
   env.Tool('as')
 
   if env.Bit('pnacl_generate_pexe'):
     suffix = '.nonfinal.pexe'
   else:
@@ skipping 48 matching lines @@
   # Windows has a small limit on the command line size.  The linking and AR
   # commands can get quite large.  So bring in the SCons machinery to put
   # most of a command line into a temporary file and pass it with
   # @filename, which works with gcc.
   if env['PLATFORM'] in ['win32', 'cygwin']:
     env['TEMPFILE'] = NaClTempFileMunge
     for com in ['LINKCOM', 'SHLINKCOM', 'ARCOM']:
       env[com] = "${TEMPFILE('%s')}" % env[com]
 
   # Get root of the SDK.
-  root = _GetNaClSdkRoot(env, sdk_mode, psdk_mode)
+  root = env.GetToolchainDir()
 
-  # Determine where to get the SDK from.
-  if sdk_mode == 'manual':
-    _SetEnvForSdkManually(env)
+  # if bitcode=1 use pnacl toolchain
+  if env.Bit('bitcode'):
+    _SetEnvForPnacl(env, root)
+
+    # Get GDB from the nacl-gcc toolchain even when using PNaCl.
+    # TODO(mseaborn): We really want the nacl-gdb binary to be in a
+    # separate tarball from the nacl-gcc toolchain, then this step
+    # will not be necessary.
+    # See http://code.google.com/p/nativeclient/issues/detail?id=2773
+    if env.Bit('target_x86'):
+      temp_env = env.Clone()
+      temp_env.ClearBits('bitcode')
+      temp_root = temp_env.GetToolchainDir()
+      _SetEnvForNativeSdk(temp_env, temp_root)
+      env.Replace(GDB=temp_env['GDB'])
+  elif env.Bit('built_elsewhere'):
+    _StubOutEnvToolsForBuiltElsewhere(env)
   else:
-    # if bitcode=1 use pnacl toolchain
-    if env.Bit('bitcode'):
-      _SetEnvForPnacl(env, root)
-
-      # Get GDB from the nacl-gcc toolchain even when using PNaCl.
-      # TODO(mseaborn): We really want the nacl-gdb binary to be in a
-      # separate tarball from the nacl-gcc toolchain, then this step
-      # will not be necessary.
-      # See http://code.google.com/p/nativeclient/issues/detail?id=2773
-      if env.Bit('target_x86'):
-        temp_env = env.Clone()
-        temp_env.ClearBits('bitcode')
-        temp_root = _GetNaClSdkRoot(temp_env, sdk_mode, psdk_mode)
-        _SetEnvForNativeSdk(temp_env, temp_root)
-        env.Replace(GDB=temp_env['GDB'])
-    elif env.Bit('built_elsewhere'):
-      _StubOutEnvToolsForBuiltElsewhere(env)
-    else:
-      _SetEnvForNativeSdk(env, root)
+    _SetEnvForNativeSdk(env, root)
 
   env.Prepend(LIBPATH='${NACL_SDK_LIB}')
 
   # Install our scanner for (potential) linker scripts.
   # It applies to "source" files ending in .a or .so.
   # Dependency files it produces are to be found in ${LIBPATH}.
   # It is applied recursively to those dependencies in case
   # some of them are linker scripts too.
   ldscript_scanner = SCons.Scanner.Base(
       function=ScanLinkerScript,
       skeys=['.a', '.so', '.pso'],
       path_function=SCons.Scanner.FindPathDirs('LIBPATH'),
       recursive=True
       )
   env.Append(SCANNERS=ldscript_scanner)
 
   # Scons tests can check this version number to decide whether to
   # enable tests for toolchain bug fixes or new features.  See
   # description in pnacl/build.sh.
   if 'toolchain_feature_version' in SCons.Script.ARGUMENTS:
     version = int(SCons.Script.ARGUMENTS['toolchain_feature_version'])
   else:
     version_file = os.path.join(root, 'FEATURE_VERSION')
     if os.path.exists(version_file):
       with open(version_file, 'r') as fh:
         version = int(fh.read())
     else:
       version = 0
   env.Replace(TOOLCHAIN_FEATURE_VERSION=version)