Rename PNaCl

site_scons/site_tools/naclsdk.py

 #!/usr/bin/python2.4
 # Copyright 2009, Google Inc.
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
@@ skipping 47 matching lines @@
         'x86': {
             '32': ['win_x86'],
             '64': ['win_x86'],
         },
     },
     'linux': {
         'x86': {
             '32': ['linux_x86'],
             '64': ['linux_x86'],
         },
-        'arm': {
-            '32': ['linux_arm-untrusted', 'linux_arm-trusted'],
-        },
     },
     'mac': {
         'x86': {
             '32': ['mac_x86'],
             '64': ['mac_x86'],
         },
-        'arm': {
-            # This entry is not actually correct, but it must be here
-            # for launching scons.
-            # TODO(pdox): Refactor this table so that pnacl is recognized
-            # as an x86 toolchain also, not just an ARM toolchain.
-            '32': ['linux_arm-untrusted'],
-        },
-
     },
 }
 
-
-
 def _PlatformSubdirs(env):
-  platform = NACL_CANONICAL_PLATFORM_MAP[env['PLATFORM']]
-  arch = env['BUILD_ARCHITECTURE']
-  subarch = env['TARGET_SUBARCH']
-  name = NACL_PLATFORM_DIR_MAP[platform][arch][subarch]
+  if env.Bit('bitcode'):
+    import platform
+    name = 'pnacl_%s_%s' % (platform.system().lower(), platform.machine())
+  else:
+    platform = NACL_CANONICAL_PLATFORM_MAP[env['PLATFORM']]
+    arch = env['BUILD_ARCHITECTURE']
+    subarch = env['TARGET_SUBARCH']
+    name = NACL_PLATFORM_DIR_MAP[platform][arch][subarch]
   return name
 
 
 def _GetNaclSdkRoot(env, sdk_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:
@@ skipping 11 matching lines @@
             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':
-    platforms = _PlatformSubdirs(env)
-    root = os.path.join(env['MAIN_DIR'], 'toolchain', platforms[-1])
-    return root
-
+    tcname = _PlatformSubdirs(env)
+    return os.path.join(env['MAIN_DIR'], 'toolchain', tcname)
   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)
 
 
@@ skipping 58 matching lines @@
                        '-g',
                        '-fno-builtin',
                        '-fno-stack-protector',
                        '-fdiagnostics-show-option',
                        '-pedantic',
                        '-D__linux__',
                        ],
               ASFLAGS=[],
               )
 
-def _SetEnvForPnacl(env, arch):
+def _SetEnvForPnacl(env, root):
+  arch = env['TARGET_FULLARCH']
   assert arch in ['arm', 'x86-32', 'x86-64']
-  pnacl_sdk_root = '${MAIN_DIR}/toolchain/linux_arm-untrusted'
-  pnacl_sdk_lib = pnacl_sdk_root + '/libs-bitcode'
+
+  env['PNACL_ROOT'] = root
+  pnacl_sdk_lib = '${PNACL_ROOT}/libs-bitcode'
   #TODO(robertm): remove NACL_SDK_INCLUDE ASAP
-  pnacl_sdk_include = (pnacl_sdk_root +
-                       '/arm-newlib/arm-none-linux-gnueabi/include')
-  pnacl_sdk_ar = (pnacl_sdk_root + '/bin/pnacl-ar')
-  pnacl_sdk_nm = (pnacl_sdk_root + '/bin/pnacl-nm')
-  pnacl_sdk_ranlib = (pnacl_sdk_root + '/bin/pnacl-ranlib')
+  pnacl_sdk_include = '${PNACL_ROOT}/arm-newlib/arm-none-linux-gnueabi/include'
+  pnacl_sdk_ar = '${PNACL_ROOT}/bin/pnacl-ar'
+  pnacl_sdk_nm = '${PNACL_ROOT}/bin/pnacl-nm'
+  pnacl_sdk_ranlib = '${PNACL_ROOT}/bin/pnacl-ranlib'
 
-  pnacl_sdk_cc = (pnacl_sdk_root + '/bin/pnacl-gcc')
-  pnacl_sdk_cxx = (pnacl_sdk_root + '/bin/pnacl-g++')
-  pnacl_sdk_ld =  (pnacl_sdk_root + '/bin/pnacl-ld')
-  pnacl_sdk_disass = (pnacl_sdk_root + '/arm-none-linux-gnueabi' +
-                  '/bin/llvm-dis')
+  pnacl_sdk_cc = '${PNACL_ROOT}/bin/pnacl-gcc'
+  pnacl_sdk_cxx = '${PNACL_ROOT}/bin/pnacl-g++'
+  pnacl_sdk_ld =  '${PNACL_ROOT}/bin/pnacl-ld'
+  pnacl_sdk_disass = '${PNACL_ROOT}/bin/pnacl-dis'
   # NOTE: XXX_flags start with space for easy concatenation
   pnacl_sdk_cxx_flags = ''
   pnacl_sdk_cc_flags = ' -std=gnu99'
   pnacl_sdk_cc_native_flags = ' -std=gnu99 -arch %s' % arch
   pnacl_sdk_ld_flags = ' -arch %s' % arch
   pnacl_sdk_ld_flags += ' ' + ' '.join(env['PNACL_BCLDFLAGS'])
   if env.Bit('nacl_pic'):
     pnacl_sdk_cc_flags += ' -fPIC'
     pnacl_sdk_cxx_flags += ' -fPIC'
     # NOTE: this is a special hack for the pnacl backend which
     #       does more than linking
     pnacl_sdk_ld_flags += ' -fPIC'
 
   if env.Bit('use_sandboxed_translator'):
     pnacl_sdk_ld_flags += ' --pnacl-sb'
 
-  # TODO(pdox): Remove the dependency on the gcc toolchain here.
-  nacl_gcc_root = os.path.join('${MAIN_DIR}',
-                               'toolchain',
-                               _PlatformSubdirs(env)[0])
+  # TODO(pdox): Remove PNaCl's dependency on the gcc toolchain here.
+  platform = NACL_CANONICAL_PLATFORM_MAP[env['PLATFORM']]
+  nnacl_root = os.path.join(env['MAIN_DIR'], 'toolchain', '%s_x86' % platform)
+
   cc_other_map = {
       'arm':    pnacl_sdk_cc + pnacl_sdk_cc_native_flags,
-      'x86-32': os.path.join(nacl_gcc_root, 'bin', 'nacl-gcc'),
-      'x86-64': os.path.join(nacl_gcc_root, 'bin', 'nacl64-gcc'),
+      'x86-32': os.path.join(nnacl_root, 'bin', 'nacl-gcc'),
+      'x86-64': os.path.join(nnacl_root, 'bin', 'nacl64-gcc'),
       }
 
   env.Replace(# Replace header and lib paths.
               NACL_SDK_INCLUDE=pnacl_sdk_include,
               NACL_SDK_LIB=pnacl_sdk_lib,
               # Replace the normal unix tools with the PNaCl ones.
               CC=pnacl_sdk_cc + pnacl_sdk_cc_flags,
               CXX=pnacl_sdk_cxx + pnacl_sdk_cxx_flags,
               # NOTE: only in bitcode compilation scenarios where
               #       CC compiles to bitcode and
@@ skipping 132 matching lines @@
 
   # Get root of the SDK.
   root = _GetNaclSdkRoot(env, sdk_mode)
 
   # Determine where to get the SDK from.
   if sdk_mode == 'manual':
     _SetEnvForSdkManually(env)
   else:
     # if bitcode=1 use pnacl toolchain
     if env.Bit('bitcode'):
-      _SetEnvForPnacl(env, env['TARGET_FULLARCH'])
+      _SetEnvForPnacl(env, root)
     elif env.Bit('target_x86'):
       _SetEnvForX86Sdk(env, root)
     else:
       print "ERROR: unknown TARGET_ARCHITECTURE: ", env['TARGET_ARCHITECTURE']
       assert 0
 
   env.Prepend(LIBPATH='${NACL_SDK_LIB}')