Revert of [NaCl SDK] Remove support for bionic toolchain

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 49 matching lines @@
 NACLPORTS_REV = '65c71c1524a74ff8415573e5e5ef7c59ce4ac437'
 
 GYPBUILD_DIR = 'gypbuild'
 
 options = None
 
 # Map of: ToolchainName: (PackageName, SDKDir, arch).
 TOOLCHAIN_PACKAGE_MAP = {
     'arm_glibc': ('nacl_arm_glibc', '%(platform)s_arm_glibc', 'arm'),
     'x86_glibc': ('nacl_x86_glibc', '%(platform)s_x86_glibc', 'x86'),
+    'arm_bionic': ('nacl_arm_bionic', '%(platform)s_arm_bionic', 'arm'),
     'pnacl': ('pnacl_newlib', '%(platform)s_pnacl', 'pnacl')
     }
 
 
 def GetToolchainDirName(tcname):
   """Return the directory name for a given toolchain"""
   return TOOLCHAIN_PACKAGE_MAP[tcname][1] % {'platform': getos.GetPlatform()}
 
 
 def GetToolchainDir(pepperdir, tcname):
   """Return the full path to a given toolchain within a given sdk root"""
   return os.path.join(pepperdir, 'toolchain', GetToolchainDirName(tcname))
 
 
 def GetToolchainLibc(tcname):
   if tcname == 'pnacl':
     return 'newlib'
-  for libc in ('glibc', 'newlib', 'host'):
+  for libc in ('bionic', 'glibc', 'newlib', 'host'):
     if libc in tcname:
       return libc
 
 
 def GetToolchainNaClInclude(pepperdir, tcname, arch=None):
   tcpath = GetToolchainDir(pepperdir, tcname)
   if arch is None:
     arch = TOOLCHAIN_PACKAGE_MAP[tcname][2]
   if arch == 'x86':
     return os.path.join(tcpath, 'x86_64-nacl', 'include')
@@ skipping 19 matching lines @@
 def GetGypBuiltLib(tcname, arch):
   if arch == 'ia32':
     lib_suffix = '32'
   elif arch == 'x64':
     lib_suffix = '64'
   elif arch == 'arm':
     lib_suffix = 'arm'
   else:
     lib_suffix = ''
 
-  tcdir = 'tc_' + GetToolchainLibc(tcname)
+  if tcname == 'arm_bionic':
+    tcdir = 'tc_newlib'
+  else:
+    tcdir = 'tc_' + GetToolchainLibc(tcname)
 
   if tcname == 'pnacl':
     if arch is None:
       lib_suffix = ''
       tcdir = 'tc_pnacl_newlib'
       arch = 'x64'
     else:
       arch = 'clang-' + arch
 
   return os.path.join(GetNinjaOutDir(arch), 'gen', tcdir, 'lib' + lib_suffix)
@@ skipping 18 matching lines @@
 
 def GetPNaClTranslatorLib(tcpath, arch):
   if arch not in ['arm', 'x86-32', 'x86-64']:
     buildbot_common.ErrorExit('Unknown architecture %s.' % arch)
   return os.path.join(tcpath, 'translator', arch, 'lib')
 
 
 def BuildStepDownloadToolchains(toolchains):
   buildbot_common.BuildStep('Running package_version.py')
   args = [sys.executable, PKGVER, '--mode', 'nacl_core_sdk']
+  if 'arm_bionic' in toolchains:
+    build_platform = '%s_x86' % getos.GetPlatform()
+    args.extend(['--append', os.path.join(build_platform, 'nacl_arm_bionic')])
   args.extend(['sync', '--extract'])
   buildbot_common.Run(args, cwd=NACL_DIR)
 
 
 def BuildStepCleanPepperDirs(pepperdir, pepperdir_old):
   buildbot_common.BuildStep('Clean Pepper Dirs')
   dirs_to_remove = (
       pepperdir,
       pepperdir_old,
       os.path.join(OUT_DIR, 'arm_trusted')
@@ skipping 103 matching lines @@
       ('native_client/src/include/nacl/nacl_exception.h', 'nacl/'),
       ('native_client/src/include/nacl/nacl_minidump.h', 'nacl/'),
       ('native_client/src/untrusted/irt/irt.h', ''),
       ('native_client/src/untrusted/irt/irt_dev.h', ''),
       ('native_client/src/untrusted/irt/irt_extension.h', ''),
       ('native_client/src/untrusted/nacl/nacl_dyncode.h', 'nacl/'),
       ('native_client/src/untrusted/nacl/nacl_startup.h', 'nacl/'),
       ('native_client/src/untrusted/valgrind/dynamic_annotations.h', 'nacl/'),
       ('ppapi/nacl_irt/public/irt_ppapi.h', ''),
   ],
+  'bionic': [
+      ('ppapi/nacl_irt/public/irt_ppapi.h', ''),
+  ],
 }
 
 def InstallFiles(src_root, dest_root, file_list):
   """Copy a set of files from src_root to dest_root according
   to the given mapping.  This allows files to be copied from
   to a location in the destination tree that is different to the
   location in the source tree.
 
   If the destination mapping ends with a '/' then the destination
   basename is inherited from the the source file.
@@ skipping 38 matching lines @@
 
 
 def MakeNinjaRelPath(path):
   return os.path.join(os.path.relpath(OUT_DIR, SRC_DIR), path)
 
 
 # TODO(ncbray): stop building and copying libraries into the SDK that are
 # already provided by the toolchain.
 # Mapping from libc to libraries gyp-build trusted libraries
 TOOLCHAIN_LIBS = {
+  'bionic' : [
+    'libminidump_generator.a',
+    'libnacl_dyncode.a',
+    'libnacl_exception.a',
+    'libnacl_list_mappings.a',
+    'libppapi.a',
+  ],
   'newlib' : [
     'libminidump_generator.a',
     'libnacl.a',
     'libnacl_dyncode.a',
     'libnacl_exception.a',
     'libnacl_list_mappings.a',
     'libnosys.a',
     'libppapi.a',
     'libppapi_stub.a',
     'libpthread.a',
@@ skipping 71 matching lines @@
   InstallFiles(GetNinjaOutDir('ia32'), tools_dir, tools_files_32)
   InstallFiles(GetNinjaOutDir('arm'), tools_dir, arm_files)
 
   for tc in toolchains:
     if tc in ('host', 'clang-newlib'):
       continue
     elif tc == 'pnacl':
       xarches = (None, 'ia32', 'x64', 'arm')
     elif tc in ('x86_glibc', 'x86_newlib'):
       xarches = ('ia32', 'x64')
-    elif tc == 'arm_glibc':
+    elif tc in ('arm_glibc', 'arm_bionic'):
       xarches = ('arm',)
     else:
       raise AssertionError('unexpected toolchain value: %s' % tc)
 
     for xarch in xarches:
       src_dir = GetGypBuiltLib(tc, xarch)
       dst_dir = GetOutputToolchainLib(pepperdir, tc, xarch)
       libc = GetToolchainLibc(tc)
       InstallFiles(src_dir, dst_dir, TOOLCHAIN_LIBS[libc])
 
@@ skipping 396 matching lines @@
   buildbot_common.BuildStep('Build GoNaCl AppEngine Projects')
   cmd = ['make', 'upload', 'REVISION=%s' % chrome_revision]
   env = dict(os.environ)
   env['NACL_SDK_ROOT'] = pepperdir
   env['NACLPORTS_NO_ANNOTATE'] = "1"
   buildbot_common.Run(cmd, env=env, cwd=GONACL_APPENGINE_SRC_DIR)
 
 
 def main(args):
   parser = argparse.ArgumentParser(description=__doc__)
+  parser.add_argument('--nacl-tree-path',
+      help='Path to native client tree for bionic build.',
+      dest='nacl_tree_path')
   parser.add_argument('--qemu', help='Add qemu for ARM.',
       action='store_true')
+  parser.add_argument('--bionic', help='Add bionic build.',
+      action='store_true')
   parser.add_argument('--tar', help='Force the tar step.',
       action='store_true')
   parser.add_argument('--archive', help='Force the archive step.',
       action='store_true')
   parser.add_argument('--release', help='PPAPI release version.',
       dest='release', default=None)
   parser.add_argument('--build-app-engine',
       help='Build AppEngine demos.', action='store_true')
   parser.add_argument('--experimental',
       help='build experimental examples and libraries', action='store_true',
@@ skipping 16 matching lines @@
     import optcomplete
     optcomplete.autocomplete(parser)
   except ImportError:
     pass
 
   global options
   options = parser.parse_args(args)
 
   buildbot_common.BuildStep('build_sdk')
 
+  if options.nacl_tree_path:
+    options.bionic = True
+    toolchain_build = os.path.join(options.nacl_tree_path, 'toolchain_build')
+    print 'WARNING: Building bionic toolchain from NaCl checkout.'
+    print 'This option builds bionic from the sources currently in the'
+    print 'provided NativeClient checkout, and the results instead of '
+    print 'downloading a toolchain from the builder. This may result in a'
+    print 'NaCl SDK that can not run on ToT chrome.'
+    print 'NOTE:  To clobber you will need to run toolchain_build_bionic.py'
+    print 'directly from the NativeClient checkout.'
+    print ''
+    response = raw_input("Type 'y' and hit enter to continue.\n")
+    if response != 'y' and response != 'Y':
+      print 'Aborting.'
+      return 1
+
+    # Get head version of NativeClient tree
+    buildbot_common.BuildStep('Build bionic toolchain.')
+    buildbot_common.Run([sys.executable, 'toolchain_build_bionic.py', '-f'],
+                        cwd=toolchain_build)
+  else:
+    toolchain_build = None
+
   if buildbot_common.IsSDKBuilder():
     options.archive = True
     # TODO(binji): re-enable app_engine build when the linux builder stops
     # breaking when trying to git clone from github.
     # See http://crbug.com/412969.
     options.build_app_engine = False
     options.tar = True
 
   # NOTE: order matters here. This will be the order that is specified in the
   # Makefiles; the first toolchain will be the default.
   toolchains = ['pnacl', 'x86_glibc', 'arm_glibc', 'clang-newlib', 'host']
 
+  # Changes for experimental bionic builder
+  if options.bionic:
+    toolchains.append('arm_bionic')
+    options.build_app_engine = False
+
   print 'Building: ' + ' '.join(toolchains)
   platform = getos.GetPlatform()
 
   if options.archive and not options.tar:
     parser.error('Incompatible arguments with archive.')
 
   chrome_version = int(build_version.ChromeMajorVersion())
   chrome_revision = build_version.ChromeRevision()
   nacl_revision = build_version.NaClRevision()
   pepper_ver = str(chrome_version)
   pepper_old = str(chrome_version - 1)
   pepperdir = os.path.join(OUT_DIR, 'pepper_' + pepper_ver)
   pepperdir_old = os.path.join(OUT_DIR, 'pepper_' + pepper_old)
-  tarname = 'naclsdk_%s.tar.bz2' % platform
+  if options.bionic:
+    tarname = 'naclsdk_bionic.tar.bz2'
+  else:
+    tarname = 'naclsdk_%s.tar.bz2' % platform
   tarfile = os.path.join(OUT_DIR, tarname)
 
   if options.release:
     pepper_ver = options.release
   print 'Building PEPPER %s at %s' % (pepper_ver, chrome_revision)
 
   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 platform == 'linux':
     # Linux-only: make sure the debian/stable sysroot image is installed
     install_script = os.path.join(SRC_DIR, 'build', 'linux', 'sysroot_scripts',
                                   'install-sysroot.py')
 
     buildbot_common.Run([sys.executable, install_script, '--arch=arm'])
     buildbot_common.Run([sys.executable, install_script, '--arch=i386'])
     buildbot_common.Run([sys.executable, install_script, '--arch=amd64'])
 
   if not options.skip_toolchain:
     BuildStepCleanPepperDirs(pepperdir, pepperdir_old)
     BuildStepMakePepperDirs(pepperdir, ['include', 'toolchain', 'tools'])
     BuildStepDownloadToolchains(toolchains)
-    BuildStepUntarToolchains(pepperdir, toolchains)
+    if options.nacl_tree_path:
+      # Instead of untarring, copy the raw bionic toolchain
+      not_bionic = [i for i in toolchains if i != 'arm_bionic']
+      BuildStepUntarToolchains(pepperdir, not_bionic)
+      tcname = GetToolchainDirName('arm_bionic')
+      srcdir = os.path.join(toolchain_build, 'out', tcname)
+      bionicdir = os.path.join(pepperdir, 'toolchain', tcname)
+      oshelpers.Copy(['-r', srcdir, bionicdir])
+    else:
+      BuildStepUntarToolchains(pepperdir, toolchains)
     if platform == 'linux':
       buildbot_common.Move(os.path.join(pepperdir, 'toolchain', 'arm_trusted'),
                            os.path.join(OUT_DIR, 'arm_trusted'))
 
 
   if platform == 'linux':
     # Linux-only: Copy arm libraries from the arm_trusted package.  These are
     # needed to be able to run sel_ldr_arm under qemu.
     arm_libs = [
       'lib/arm-linux-gnueabihf/librt.so.1',
@@ skipping 21 matching lines @@
   BuildStepUpdateUserProjects(pepperdir, toolchains,
                               options.build_experimental, True)
 
   BuildStepCopyTextFiles(pepperdir, pepper_ver, chrome_revision, nacl_revision)
 
   # Ship with libraries prebuilt, so run that first.
   BuildStepBuildLibraries(pepperdir, 'src')
   GenerateNotice(pepperdir)
 
   # Verify the SDK contains what we expect.
-  BuildStepVerifyFilelist(pepperdir)
+  if not options.bionic:
+    BuildStepVerifyFilelist(pepperdir)
 
   if options.tar:
     BuildStepTarBundle(pepper_ver, tarfile)
 
   if platform == 'linux':
     BuildStepBuildPNaClComponent(pepper_ver, chrome_revision)
 
   if options.build_app_engine and platform == 'linux':
     BuildStepBuildAppEngine(pepperdir, chrome_revision)
 
@@ skipping 11 matching lines @@
       BuildStepArchivePNaClComponent(chrome_revision)
 
   return 0
 
 
 if __name__ == '__main__':
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     buildbot_common.ErrorExit('build_sdk: interrupted')