NaCl: Update revision in DEPS, r12098 -> r12120

native_client_sdk/src/build_tools/build_sdk.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Entry point for both build and try bots.
 
 This script is invoked from XXX, usually without arguments
 to package an SDK. It automatically determines whether
 this SDK is for mac, win, linux.
@@ skipping 43 matching lines @@
 CYGTAR = os.path.join(NACL_DIR, 'build', 'cygtar.py')
 
 NACLPORTS_URL = 'https://naclports.googlecode.com/svn/trunk/src'
 NACLPORTS_REV = 850
 
 GYPBUILD_DIR = 'gypbuild'
 
 options = None
 
 
-def GetGlibcToolchain(host_arch):
+def GetGlibcToolchain():
   tcdir = os.path.join(NACL_DIR, 'toolchain', '.tars')
-  tcname = 'toolchain_%s_%s.tar.bz2' % (getos.GetPlatform(), host_arch)
+  tcname = 'toolchain_%s_x86.tar.bz2' % getos.GetPlatform()
   return os.path.join(tcdir, tcname)
 
 
-def GetNewlibToolchain(host_arch):
+def GetNewlibToolchain():
   tcdir = os.path.join(NACL_DIR, 'toolchain', '.tars')
-  tcname = 'naclsdk_%s_%s.tgz' % (getos.GetPlatform(), host_arch)
+  tcname = 'naclsdk_%s_x86.tgz' % getos.GetPlatform()
   return os.path.join(tcdir, tcname)
 
 
-def GetPNaClToolchain(host_arch):
+def GetPNaClToolchain():
   tcdir = os.path.join(NACL_DIR, 'toolchain', '.tars')
-  tcname = 'naclsdk_pnacl_%s_%s.tgz' % (getos.GetPlatform(), host_arch)
+  tcname = 'naclsdk_pnacl_%s_x86.tgz' % getos.GetPlatform()
   return os.path.join(tcdir, tcname)
 
 
 def GetToolchainNaClInclude(tcname, tcpath, arch):
   if arch == 'x86':
     if tcname == 'pnacl':
       return os.path.join(tcpath, 'newlib', 'sdk', 'include')
     return os.path.join(tcpath, 'x86_64-nacl', 'include')
   elif arch == 'arm':
     return os.path.join(tcpath, 'arm-nacl', 'include')
@@ skipping 13 matching lines @@
   if tcname == 'pnacl':
     tcname = 'pnacl_newlib'
   if not xarch:
     xarch = ''
   return os.path.join(GetGypGenDir(xarch), 'tc_' + tcname, 'lib' + xarch)
 
 
 def GetToolchainNaClLib(tcname, tcpath, xarch):
   if tcname == 'pnacl':
     return os.path.join(tcpath, 'newlib', 'sdk', 'lib')
-  if xarch == '32':
+  elif xarch == '32':
     return os.path.join(tcpath, 'x86_64-nacl', 'lib32')
-  if xarch == '64':
+  elif xarch == '64':
     return os.path.join(tcpath, 'x86_64-nacl', 'lib')
-  if xarch == 'arm':
+  elif xarch == 'arm':
     return os.path.join(tcpath, 'arm-nacl', 'lib')
 
 
 def GetToolchainDirName(tcname, xarch):
-  if xarch != 'arm':
-    xarch = 'x86'
-  return '%s_%s_%s' % (getos.GetPlatform(), xarch, tcname)
+  if tcname == 'pnacl':
+    return '%s_%s' % (getos.GetPlatform(), tcname)
+  elif xarch == 'arm':
+    return '%s_arm_%s' % (getos.GetPlatform(), tcname)
+  else:
+    return '%s_x86_%s' % (getos.GetPlatform(), tcname)
 
 
 def GetGypToolchainLib(tcname, xarch):
   tcpath = os.path.join(GetGypGenDir(xarch), 'sdk', 'toolchain',
                         GetToolchainDirName(tcname, xarch))
   return GetToolchainNaClLib(tcname, tcpath, xarch)
 
 
 def GetOutputToolchainLib(pepperdir, tcname, xarch):
   tcpath = os.path.join(pepperdir, 'toolchain',
@@ skipping 57 matching lines @@
     'newlib/lib-bc-x86-64',
     'newlib/usr-bc-x86-64'
     # TODO(sbc): remove this once its really not needed.
     # Currently we seem to rely on it at least for <bits/stat.h>
     #'newlib/sysroot',
   ]
   for dirname in dirs_to_prune:
     buildbot_common.RemoveDir(os.path.join(root, dirname))
 
 
-def BuildStepUntarToolchains(pepperdir, arch, toolchains):
+def BuildStepUntarToolchains(pepperdir, toolchains):
   buildbot_common.BuildStep('Untar Toolchains')
   platform = getos.GetPlatform()
-  tcname = platform + '_' + arch
   tmpdir = os.path.join(OUT_DIR, 'tc_temp')
   buildbot_common.RemoveDir(tmpdir)
   buildbot_common.MakeDir(tmpdir)
 
   if 'newlib' in toolchains:
     # Untar the newlib toolchains
-    tarfile = GetNewlibToolchain(arch)
+    tarfile = GetNewlibToolchain()
     buildbot_common.Run([sys.executable, CYGTAR, '-C', tmpdir, '-xf', tarfile],
                         cwd=NACL_DIR)
 
     # Then rename/move it to the pepper toolchain directory
     srcdir = os.path.join(tmpdir, 'sdk', 'nacl-sdk')
-    newlibdir = os.path.join(pepperdir, 'toolchain', tcname + '_newlib')
+    tcname = platform + '_x86_newlib'
+    newlibdir = os.path.join(pepperdir, 'toolchain', tcname)
     buildbot_common.Move(srcdir, newlibdir)
 
   if 'arm' in toolchains:
     # Copy the existing arm toolchain from native_client tree
-    arm_toolchain = os.path.join(NACL_DIR, 'toolchain',
-                                 platform + '_arm_newlib')
+    tcname = platform + '_arm_newlib'
+    arm_toolchain = os.path.join(NACL_DIR, 'toolchain', tcname)
     arm_toolchain_sdk = os.path.join(pepperdir, 'toolchain',
                                      os.path.basename(arm_toolchain))
     buildbot_common.CopyDir(arm_toolchain, arm_toolchain_sdk)
 
   if 'glibc' in toolchains:
     # Untar the glibc toolchains
-    tarfile = GetGlibcToolchain(arch)
+    tarfile = GetGlibcToolchain()
+    tcname = platform + '_x86_glibc'
     buildbot_common.Run([sys.executable, CYGTAR, '-C', tmpdir, '-xf', tarfile],
                         cwd=NACL_DIR)
 
     # Then rename/move it to the pepper toolchain directory
-    srcdir = os.path.join(tmpdir, 'toolchain', tcname)
-    glibcdir = os.path.join(pepperdir, 'toolchain', tcname + '_glibc')
+    srcdir = os.path.join(tmpdir, 'toolchain', platform + '_x86')
+    glibcdir = os.path.join(pepperdir, 'toolchain', tcname)
     buildbot_common.Move(srcdir, glibcdir)
 
   # Untar the pnacl toolchains
   if 'pnacl' in toolchains:
     tmpdir = os.path.join(tmpdir, 'pnacl')
     buildbot_common.RemoveDir(tmpdir)
     buildbot_common.MakeDir(tmpdir)
-    tarfile = GetPNaClToolchain(arch)
+    tarfile = GetPNaClToolchain()
+    tcname = platform + '_pnacl'
     buildbot_common.Run([sys.executable, CYGTAR, '-C', tmpdir, '-xf', tarfile],
                         cwd=NACL_DIR)
 
     # Then rename/move it to the pepper toolchain directory
-    pnacldir = os.path.join(pepperdir, 'toolchain', tcname + '_pnacl')
+    pnacldir = os.path.join(pepperdir, 'toolchain', tcname)
     buildbot_common.Move(tmpdir, pnacldir)
     PrunePNaClToolchain(pnacldir)
 
   buildbot_common.RemoveDir(tmpdir)
 
   if options.gyp and platform != 'win':
     # If the gyp options is specified we install a toolchain
     # wrapper so that gyp can switch toolchains via a commandline
     # option.
     bindir = os.path.join(pepperdir, 'toolchain', tcname, 'bin')
@@ skipping 299 matching lines @@
   buildbot_common.Run(['ninja', '-C', out_config_dir] + targets, cwd=SRC_DIR)
 
 
 def BuildStepBuildToolchains(pepperdir, toolchains):
   buildbot_common.BuildStep('SDK Items')
 
   GypNinjaBuild_NaCl(GYPBUILD_DIR)
   GypNinjaBuild_Breakpad(GYPBUILD_DIR)
 
   platform = getos.GetPlatform()
-  tcname = platform + '_x86'
-  newlibdir = os.path.join(pepperdir, 'toolchain', tcname + '_newlib')
-  glibcdir = os.path.join(pepperdir, 'toolchain', tcname + '_glibc')
-  pnacldir = os.path.join(pepperdir, 'toolchain', tcname + '_pnacl')
+  newlibdir = os.path.join(pepperdir, 'toolchain', platform + '_x86_newlib')
+  glibcdir = os.path.join(pepperdir, 'toolchain', platform + '_x86_glibc')
+  armdir = os.path.join(pepperdir, 'toolchain', platform + '_arm_newlib')
+  pnacldir = os.path.join(pepperdir, 'toolchain', platform + '_pnacl')
 
   if set(toolchains) & set(['glibc', 'newlib']):
     GypNinjaBuild_PPAPI('ia32', GYPBUILD_DIR)
 
   if 'arm' in toolchains:
     GypNinjaBuild_PPAPI('arm', GYPBUILD_DIR + '-arm')
 
   GypNinjaInstall(pepperdir, toolchains)
 
   if 'newlib' in toolchains:
     InstallNaClHeaders(GetToolchainNaClInclude('newlib', newlibdir, 'x86'),
                        'newlib')
 
   if 'glibc' in toolchains:
     InstallNaClHeaders(GetToolchainNaClInclude('glibc', glibcdir, 'x86'),
                        'glibc')
 
   if 'arm' in toolchains:
-    tcname = platform + '_arm_newlib'
-    armdir = os.path.join(pepperdir, 'toolchain', tcname)
     InstallNaClHeaders(GetToolchainNaClInclude('newlib', armdir, 'arm'),
                        'arm')
 
   if 'pnacl' in toolchains:
     # NOTE: For ia32, gyp builds both x86-32 and x86-64 by default.
     for arch in ('ia32', 'arm'):
       # Fill in the latest native pnacl shim library from the chrome build.
       build_dir = GYPBUILD_DIR + '-pnacl-' + arch
       GypNinjaBuild_Pnacl(build_dir, arch)
       if arch == 'ia32':
@@ skipping 269 matching lines @@
       help='build experimental examples and libraries', action='store_true',
       dest='build_experimental')
   parser.add_option('--skip-toolchain', help='Skip toolchain untar',
       action='store_true')
   parser.add_option('--mac_sdk',
       help='Set the mac_sdk (e.g. 10.6) to use when building with ninja.',
       dest='mac_sdk')
 
   global options
   options, args = parser.parse_args(args[1:])
-  arch = 'x86'
 
   generate_make.use_gyp = options.gyp
   if buildbot_common.IsSDKBuilder():
     options.archive = True
     options.build_ports = True
 
   toolchains = ['newlib', 'glibc', 'arm', 'pnacl', 'host']
   print 'Building: ' + ' '.join(toolchains)
 
   if options.archive and options.skip_tar:
@@ skipping 15 matching lines @@
 
   if 'NACL_SDK_ROOT' in os.environ:
     # We don't want the currently configured NACL_SDK_ROOT to have any effect
     # of the build.
     del os.environ['NACL_SDK_ROOT']
 
   if not options.skip_toolchain:
     BuildStepCleanPepperDirs(pepperdir, pepperdir_old)
     BuildStepMakePepperDirs(pepperdir, ['include', 'toolchain', 'tools'])
     BuildStepDownloadToolchains()
-    BuildStepUntarToolchains(pepperdir, arch, toolchains)
+    BuildStepUntarToolchains(pepperdir, toolchains)
 
   BuildStepCopyTextFiles(pepperdir, pepper_ver, chrome_revision, nacl_revision)
   BuildStepBuildToolchains(pepperdir, toolchains)
 
   BuildStepUpdateHelpers(pepperdir, True)
   BuildStepUpdateUserProjects(pepperdir, toolchains,
                               options.build_experimental, True)
 
   # Ship with libraries prebuilt, so run that first.
   BuildStepBuildLibraries(pepperdir, 'src')
@@ skipping 22 matching lines @@
     BuildStepArchiveSDKTools()
 
   return 0
 
 
 if __name__ == '__main__':
   try:
     sys.exit(main(sys.argv))
   except KeyboardInterrupt:
     buildbot_common.ErrorExit('build_sdk: interrupted')