| #!/usr/bin/env python3 |
| # -*- coding: utf-8 -*- |
| # Copyright 2010 The ChromiumOS Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Script to build the ChromeOS toolchain. |
| |
| This script sets up the toolchain if you give it the gcctools directory. |
| """ |
| |
| |
| __author__ = "[email protected] (Ahmad Sharif)" |
| |
| import argparse |
| import getpass |
| import os |
| import sys |
| import tempfile |
| |
| from cros_utils import command_executer |
| from cros_utils import constants |
| from cros_utils import misc |
| import tc_enter_chroot |
| |
| |
| class ToolchainPart(object): |
| """Class to hold the toolchain pieces.""" |
| |
| def __init__( |
| self, |
| name, |
| source_path, |
| chromeos_root, |
| board, |
| incremental, |
| build_env, |
| gcc_enable_ccache=False, |
| ): |
| self._name = name |
| self._source_path = misc.CanonicalizePath(source_path) |
| self._chromeos_root = chromeos_root |
| self._board = board |
| self._ctarget = misc.GetCtargetFromBoard( |
| self._board, self._chromeos_root |
| ) |
| self._gcc_libs_dest = misc.GetGccLibsDestForBoard( |
| self._board, self._chromeos_root |
| ) |
| self.tag = "%s-%s" % (name, self._ctarget) |
| self._ce = command_executer.GetCommandExecuter() |
| self._mask_file = os.path.join( |
| self._chromeos_root, |
| "chroot", |
| "etc/portage/package.mask/cross-%s" % self._ctarget, |
| ) |
| self._new_mask_file = None |
| |
| self._chroot_source_path = os.path.join( |
| constants.MOUNTED_TOOLCHAIN_ROOT, self._name |
| ).lstrip("/") |
| self._incremental = incremental |
| self._build_env = build_env |
| self._gcc_enable_ccache = gcc_enable_ccache |
| |
| def RunSetupBoardIfNecessary(self): |
| cross_symlink = os.path.join( |
| self._chromeos_root, |
| "chroot", |
| "usr/local/bin/emerge-%s" % self._board, |
| ) |
| if not os.path.exists(cross_symlink): |
| command = "setup_board --board=%s" % self._board |
| self._ce.ChrootRunCommand(self._chromeos_root, command) |
| |
| def Build(self): |
| rv = 1 |
| try: |
| self.UninstallTool() |
| self.MoveMaskFile() |
| self.MountSources(False) |
| self.RemoveCompiledFile() |
| rv = self.BuildTool() |
| finally: |
| self.UnMoveMaskFile() |
| return rv |
| |
| def RemoveCompiledFile(self): |
| compiled_file = os.path.join( |
| self._chromeos_root, |
| "chroot", |
| "var/tmp/portage/cross-%s" % self._ctarget, |
| "%s-9999" % self._name, |
| ".compiled", |
| ) |
| command = "rm -f %s" % compiled_file |
| self._ce.RunCommand(command) |
| |
| def MountSources(self, unmount_source): |
| mount_points = [] |
| mounted_source_path = os.path.join( |
| self._chromeos_root, "chroot", self._chroot_source_path |
| ) |
| src_mp = tc_enter_chroot.MountPoint( |
| self._source_path, mounted_source_path, getpass.getuser(), "ro" |
| ) |
| mount_points.append(src_mp) |
| |
| build_suffix = "build-%s" % self._ctarget |
| build_dir = "%s-%s" % (self._source_path, build_suffix) |
| |
| if not self._incremental and os.path.exists(build_dir): |
| command = "rm -rf %s/*" % build_dir |
| self._ce.RunCommand(command) |
| |
| # Create a -build directory for the objects. |
| command = "mkdir -p %s" % build_dir |
| self._ce.RunCommand(command) |
| |
| mounted_build_dir = os.path.join( |
| self._chromeos_root, |
| "chroot", |
| "%s-%s" % (self._chroot_source_path, build_suffix), |
| ) |
| build_mp = tc_enter_chroot.MountPoint( |
| build_dir, mounted_build_dir, getpass.getuser() |
| ) |
| mount_points.append(build_mp) |
| |
| if unmount_source: |
| unmount_statuses = [mp.UnMount() == 0 for mp in mount_points] |
| assert all(unmount_statuses), "Could not unmount all mount points!" |
| else: |
| mount_statuses = [mp.DoMount() == 0 for mp in mount_points] |
| |
| if not all(mount_statuses): |
| mounted = [ |
| mp |
| for mp, status in zip(mount_points, mount_statuses) |
| if status |
| ] |
| unmount_statuses = [mp.UnMount() == 0 for mp in mounted] |
| assert all( |
| unmount_statuses |
| ), "Could not unmount all mount points!" |
| |
| def UninstallTool(self): |
| command = "sudo CLEAN_DELAY=0 emerge -C cross-%s/%s" % ( |
| self._ctarget, |
| self._name, |
| ) |
| self._ce.ChrootRunCommand(self._chromeos_root, command) |
| |
| def BuildTool(self): |
| env = self._build_env |
| # FEATURES=buildpkg adds minutes of time so we disable it. |
| # TODO(shenhan): keep '-sandbox' for a while for compatibility, then remove |
| # it after a while. |
| features = ( |
| "nostrip userpriv userfetch -usersandbox -sandbox noclean " |
| "-buildpkg" |
| ) |
| env["FEATURES"] = features |
| |
| if self._incremental: |
| env["FEATURES"] += " keepwork" |
| |
| if "USE" in env: |
| env["USE"] += " multislot mounted_%s" % self._name |
| else: |
| env["USE"] = "multislot mounted_%s" % self._name |
| |
| # Disable ccache in our compilers. cache may be problematic for us. |
| # It ignores compiler environments settings and it is not clear if |
| # the cache hit algorithm verifies all the compiler binaries or |
| # just the driver. |
| if self._name == "gcc" and not self._gcc_enable_ccache: |
| env["USE"] += " -wrapper_ccache" |
| |
| env["%s_SOURCE_PATH" % self._name.upper()] = os.path.join( |
| "/", self._chroot_source_path |
| ) |
| env["ACCEPT_KEYWORDS"] = "~*" |
| env_string = " ".join(['%s="%s"' % var for var in env.items()]) |
| command = "emerge =cross-%s/%s-9999" % (self._ctarget, self._name) |
| full_command = "sudo %s %s" % (env_string, command) |
| rv = self._ce.ChrootRunCommand(self._chromeos_root, full_command) |
| if rv != 0: |
| return rv |
| if self._name == "gcc": |
| command = "sudo cp -r /usr/lib/gcc/%s %s" % ( |
| self._ctarget, |
| self._gcc_libs_dest, |
| ) |
| rv = self._ce.ChrootRunCommand(self._chromeos_root, command) |
| return rv |
| |
| def MoveMaskFile(self): |
| self._new_mask_file = None |
| if os.path.isfile(self._mask_file): |
| self._new_mask_file = tempfile.mktemp() |
| command = "sudo mv %s %s" % (self._mask_file, self._new_mask_file) |
| self._ce.RunCommand(command) |
| |
| def UnMoveMaskFile(self): |
| if self._new_mask_file: |
| command = "sudo mv %s %s" % (self._new_mask_file, self._mask_file) |
| self._ce.RunCommand(command) |
| |
| |
| def Main(argv): |
| """The main function.""" |
| # Common initializations |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| "-c", |
| "--chromeos_root", |
| dest="chromeos_root", |
| default="../../", |
| help=("ChromeOS root checkout directory" " uses ../.. if none given."), |
| ) |
| parser.add_argument( |
| "-g", |
| "--gcc_dir", |
| dest="gcc_dir", |
| help="The directory where gcc resides.", |
| ) |
| parser.add_argument( |
| "--binutils_dir", |
| dest="binutils_dir", |
| help="The directory where binutils resides.", |
| ) |
| parser.add_argument( |
| "-x", |
| "--gdb_dir", |
| dest="gdb_dir", |
| help="The directory where gdb resides.", |
| ) |
| parser.add_argument( |
| "-b", |
| "--board", |
| dest="board", |
| default="x86-alex", |
| help="The target board.", |
| ) |
| parser.add_argument( |
| "-n", |
| "--noincremental", |
| dest="noincremental", |
| default=False, |
| action="store_true", |
| help="Use FEATURES=keepwork to do incremental builds.", |
| ) |
| parser.add_argument( |
| "--cflags", |
| dest="cflags", |
| default="", |
| help="Build a compiler with specified CFLAGS", |
| ) |
| parser.add_argument( |
| "--cxxflags", |
| dest="cxxflags", |
| default="", |
| help="Build a compiler with specified CXXFLAGS", |
| ) |
| parser.add_argument( |
| "--cflags_for_target", |
| dest="cflags_for_target", |
| default="", |
| help="Build the target libraries with specified flags", |
| ) |
| parser.add_argument( |
| "--cxxflags_for_target", |
| dest="cxxflags_for_target", |
| default="", |
| help="Build the target libraries with specified flags", |
| ) |
| parser.add_argument( |
| "--ldflags", |
| dest="ldflags", |
| default="", |
| help="Build a compiler with specified LDFLAGS", |
| ) |
| parser.add_argument( |
| "-d", |
| "--debug", |
| dest="debug", |
| default=False, |
| action="store_true", |
| help="Build a compiler with -g3 -O0 appended to both" |
| " CFLAGS and CXXFLAGS.", |
| ) |
| parser.add_argument( |
| "-m", |
| "--mount_only", |
| dest="mount_only", |
| default=False, |
| action="store_true", |
| help="Just mount the tool directories.", |
| ) |
| parser.add_argument( |
| "-u", |
| "--unmount_only", |
| dest="unmount_only", |
| default=False, |
| action="store_true", |
| help="Just unmount the tool directories.", |
| ) |
| parser.add_argument( |
| "--extra_use_flags", |
| dest="extra_use_flags", |
| default="", |
| help="Extra flag for USE, to be passed to the ebuild. " |
| "('multislot' and 'mounted_<tool>' are always passed.)", |
| ) |
| parser.add_argument( |
| "--gcc_enable_ccache", |
| dest="gcc_enable_ccache", |
| default=False, |
| action="store_true", |
| help="Enable ccache for the gcc invocations", |
| ) |
| |
| options = parser.parse_args(argv) |
| |
| chromeos_root = misc.CanonicalizePath(options.chromeos_root) |
| if options.gcc_dir: |
| gcc_dir = misc.CanonicalizePath(options.gcc_dir) |
| assert gcc_dir and os.path.isdir(gcc_dir), "gcc_dir does not exist!" |
| if options.binutils_dir: |
| binutils_dir = misc.CanonicalizePath(options.binutils_dir) |
| assert os.path.isdir(binutils_dir), "binutils_dir does not exist!" |
| if options.gdb_dir: |
| gdb_dir = misc.CanonicalizePath(options.gdb_dir) |
| assert os.path.isdir(gdb_dir), "gdb_dir does not exist!" |
| if options.unmount_only: |
| options.mount_only = False |
| elif options.mount_only: |
| options.unmount_only = False |
| build_env = {} |
| if options.cflags: |
| build_env["CFLAGS"] = "`portageq envvar CFLAGS` " + options.cflags |
| if options.cxxflags: |
| build_env["CXXFLAGS"] = "`portageq envvar CXXFLAGS` " + options.cxxflags |
| if options.cflags_for_target: |
| build_env["CFLAGS_FOR_TARGET"] = options.cflags_for_target |
| if options.cxxflags_for_target: |
| build_env["CXXFLAGS_FOR_TARGET"] = options.cxxflags_for_target |
| if options.ldflags: |
| build_env["LDFLAGS"] = options.ldflags |
| if options.debug: |
| debug_flags = "-g3 -O0" |
| if "CFLAGS" in build_env: |
| build_env["CFLAGS"] += " %s" % (debug_flags) |
| else: |
| build_env["CFLAGS"] = debug_flags |
| if "CXXFLAGS" in build_env: |
| build_env["CXXFLAGS"] += " %s" % (debug_flags) |
| else: |
| build_env["CXXFLAGS"] = debug_flags |
| if options.extra_use_flags: |
| build_env["USE"] = options.extra_use_flags |
| |
| # Create toolchain parts |
| toolchain_parts = {} |
| for board in options.board.split(","): |
| if options.gcc_dir: |
| tp = ToolchainPart( |
| "gcc", |
| gcc_dir, |
| chromeos_root, |
| board, |
| not options.noincremental, |
| build_env, |
| options.gcc_enable_ccache, |
| ) |
| toolchain_parts[tp.tag] = tp |
| tp.RunSetupBoardIfNecessary() |
| if options.binutils_dir: |
| tp = ToolchainPart( |
| "binutils", |
| binutils_dir, |
| chromeos_root, |
| board, |
| not options.noincremental, |
| build_env, |
| ) |
| toolchain_parts[tp.tag] = tp |
| tp.RunSetupBoardIfNecessary() |
| if options.gdb_dir: |
| tp = ToolchainPart( |
| "gdb", |
| gdb_dir, |
| chromeos_root, |
| board, |
| not options.noincremental, |
| build_env, |
| ) |
| toolchain_parts[tp.tag] = tp |
| tp.RunSetupBoardIfNecessary() |
| |
| rv = 0 |
| try: |
| for tag in toolchain_parts: |
| tp = toolchain_parts[tag] |
| if options.mount_only or options.unmount_only: |
| tp.MountSources(options.unmount_only) |
| else: |
| rv = rv + tp.Build() |
| finally: |
| print("Exiting...") |
| return rv |
| |
| |
| if __name__ == "__main__": |
| retval = Main(sys.argv[1:]) |
| sys.exit(retval) |
