htl: Drop ptr_pthread_once from pthread_functions

[thirdparty/glibc.git] / scripts / build-many-glibcs.py

#!/usr/bin/python3
# Build many configurations of glibc.
# Copyright (C) 2016-2025 Free Software Foundation, Inc.
# Copyright The GNU Toolchain Authors.
# This file is part of the GNU C Library.
#
# The GNU C Library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# The GNU C Library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with the GNU C Library; if not, see
# <https://www.gnu.org/licenses/>.

"""Build many configurations of glibc.

This script takes as arguments a directory name (containing a src
subdirectory with sources of the relevant toolchain components) and a
description of what to do: 'checkout', to check out sources into that
directory, 'bot-cycle', to run a series of checkout and build steps,
'bot', to run 'bot-cycle' repeatedly, 'host-libraries', to build
libraries required by the toolchain, 'compilers', to build
cross-compilers for various configurations, or 'glibcs', to build
glibc for various configurations and run the compilation parts of the
testsuite.  Subsequent arguments name the versions of components to
check out (<component>-<version), for 'checkout', or, for actions
other than 'checkout' and 'bot-cycle', name configurations for which
compilers or glibc are to be built.

The 'list-compilers' command prints the name of each available
compiler configuration, without building anything.  The 'list-glibcs'
command prints the name of each glibc compiler configuration, followed
by the space, followed by the name of the compiler configuration used
for building this glibc variant.

"""

import argparse
import datetime
import email.mime.text
import email.utils
import json
import os
import re
import shutil
import smtplib
import stat
import subprocess
import sys
import time
import urllib.request

# This is a list of system utilities that are expected to be available
# to this script, and, if a non-zero version is included, the minimum
# version required to work with this sccript.
def get_list_of_required_tools():
    global REQUIRED_TOOLS
    REQUIRED_TOOLS = {
        'awk'      : (get_version_awk,   (0,0,0)),
        'bison'    : (get_version,       (0,0)),
        'flex'     : (get_version,       (0,0,0)),
        'git'      : (get_version,       (1,8,3)),
        'make'     : (get_version,       (4,0)),
        'makeinfo' : (get_version,       (0,0)),
        'patch'    : (get_version,       (0,0,0)),
        'sed'      : (get_version,       (0,0)),
        'tar'      : (get_version,       (0,0,0)),
        'gzip'     : (get_version,       (0,0)),
        'bzip2'    : (get_version_bzip2, (0,0,0)),
        'xz'       : (get_version,       (0,0,0)),
    }

try:
    subprocess.run
except:
    class _CompletedProcess:
        def __init__(self, args, returncode, stdout=None, stderr=None):
            self.args = args
            self.returncode = returncode
            self.stdout = stdout
            self.stderr = stderr

    def _run(*popenargs, input=None, timeout=None, check=False, **kwargs):
        assert(timeout is None)
        with subprocess.Popen(*popenargs, **kwargs) as process:
            try:
                stdout, stderr = process.communicate(input)
            except:
                process.kill()
                process.wait()
                raise
            returncode = process.poll()
            if check and returncode:
                raise subprocess.CalledProcessError(returncode, popenargs)
        return _CompletedProcess(popenargs, returncode, stdout, stderr)

    subprocess.run = _run


class Context(object):
    """The global state associated with builds in a given directory."""

    def __init__(self, topdir, parallelism, keep, replace_sources, strip,
                 full_gcc, action, exclude, shallow=False):
        """Initialize the context."""
        self.topdir = topdir
        self.parallelism = parallelism
        self.keep = keep
        self.replace_sources = replace_sources
        self.strip = strip
        self.full_gcc = full_gcc
        self.exclude = exclude
        self.shallow = shallow
        self.srcdir = os.path.join(topdir, 'src')
        self.versions_json = os.path.join(self.srcdir, 'versions.json')
        self.build_state_json = os.path.join(topdir, 'build-state.json')
        self.bot_config_json = os.path.join(topdir, 'bot-config.json')
        self.installdir = os.path.join(topdir, 'install')
        self.host_libraries_installdir = os.path.join(self.installdir,
                                                      'host-libraries')
        self.builddir = os.path.join(topdir, 'build')
        self.logsdir = os.path.join(topdir, 'logs')
        self.logsdir_old = os.path.join(topdir, 'logs-old')
        self.makefile = os.path.join(self.builddir, 'Makefile')
        self.wrapper = os.path.join(self.builddir, 'wrapper')
        self.save_logs = os.path.join(self.builddir, 'save-logs')
        self.script_text = self.get_script_text()
        if action not in ('checkout', 'list-compilers', 'list-glibcs'):
            self.build_triplet = self.get_build_triplet()
            self.glibc_version = self.get_glibc_version()
        self.configs = {}
        self.glibc_configs = {}
        self.makefile_pieces = ['.PHONY: all\n']
        self.add_all_configs()
        self.load_versions_json()
        self.load_build_state_json()
        self.status_log_list = []
        self.email_warning = False

    def get_script_text(self):
        """Return the text of this script."""
        with open(sys.argv[0], 'r') as f:
            return f.read()

    def exec_self(self):
        """Re-execute this script with the same arguments."""
        sys.stdout.flush()
        os.execv(sys.executable, [sys.executable] + sys.argv)

    def get_build_triplet(self):
        """Determine the build triplet with config.guess."""
        config_guess = os.path.join(self.component_srcdir('gcc'),
                                    'config.guess')
        cg_out = subprocess.run([config_guess], stdout=subprocess.PIPE,
                                check=True, universal_newlines=True).stdout
        return cg_out.rstrip()

    def get_glibc_version(self):
        """Determine the glibc version number (major.minor)."""
        version_h = os.path.join(self.component_srcdir('glibc'), 'version.h')
        with open(version_h, 'r') as f:
            lines = f.readlines()
        starttext = '#define VERSION "'
        for l in lines:
            if l.startswith(starttext):
                l = l[len(starttext):]
                l = l.rstrip('"\n')
                m = re.fullmatch(r'([0-9]+)\.([0-9]+)[.0-9]*', l)
                return '%s.%s' % m.group(1, 2)
        print('error: could not determine glibc version')
        exit(1)

    def add_all_configs(self):
        """Add all known glibc build configurations."""
        self.add_config(arch='aarch64',
                        os_name='linux-gnu',
                        extra_glibcs=[{'variant': 'disable-multi-arch',
                                       'cfg': ['--disable-multi-arch']}])
        self.add_config(arch='aarch64_be',
                        os_name='linux-gnu')
        self.add_config(arch='arc',
                        os_name='linux-gnu',
                        gcc_cfg=['--disable-multilib', '--with-cpu=hs38'])
        self.add_config(arch='arc',
                        os_name='linux-gnuhf',
                        gcc_cfg=['--disable-multilib', '--with-cpu=hs38_linux'])
        self.add_config(arch='alpha',
                        os_name='linux-gnu')
        self.add_config(arch='arm',
                        os_name='linux-gnueabi',
                        extra_glibcs=[{'variant': 'v4t',
                                       'ccopts': '-march=armv4t'}])
        self.add_config(arch='armeb',
                        os_name='linux-gnueabi')
        self.add_config(arch='armeb',
                        os_name='linux-gnueabi',
                        variant='be8',
                        gcc_cfg=['--with-arch=armv7-a'])
        self.add_config(arch='arm',
                        os_name='linux-gnueabihf',
                        gcc_cfg=['--with-float=hard', '--with-cpu=arm926ej-s'],
                        extra_glibcs=[{'variant': 'v7a',
                                       'ccopts': '-march=armv7-a -mfpu=vfpv3'},
                                      {'variant': 'thumb',
                                       'ccopts':
                                       '-mthumb -march=armv7-a -mfpu=vfpv3'},
                                      {'variant': 'v7a-disable-multi-arch',
                                       'ccopts': '-march=armv7-a -mfpu=vfpv3',
                                       'cfg': ['--disable-multi-arch']}])
        self.add_config(arch='armeb',
                        os_name='linux-gnueabihf',
                        gcc_cfg=['--with-float=hard', '--with-cpu=arm926ej-s'])
        self.add_config(arch='armeb',
                        os_name='linux-gnueabihf',
                        variant='be8',
                        gcc_cfg=['--with-float=hard', '--with-arch=armv7-a',
                                 '--with-fpu=vfpv3'])
        self.add_config(arch='csky',
                        os_name='linux-gnuabiv2',
                        variant='soft',
                        gcc_cfg=['--disable-multilib'])
        self.add_config(arch='csky',
                        os_name='linux-gnuabiv2',
                        gcc_cfg=['--with-float=hard', '--disable-multilib'])
        self.add_config(arch='hppa',
                        os_name='linux-gnu')
        self.add_config(arch='i686',
                        os_name='gnu')
        self.add_config(arch='loongarch64',
                        os_name='linux-gnu',
                        variant='lp64d',
                        gcc_cfg=['--with-abi=lp64d','--disable-multilib'])
        self.add_config(arch='loongarch64',
                        os_name='linux-gnu',
                        variant='lp64s',
                        gcc_cfg=['--with-abi=lp64s','--disable-multilib'])
        self.add_config(arch='m68k',
                        os_name='linux-gnu',
                        gcc_cfg=['--disable-multilib'])
        self.add_config(arch='m68k',
                        os_name='linux-gnu',
                        variant='coldfire',
                        gcc_cfg=['--with-arch=cf', '--disable-multilib'])
        self.add_config(arch='m68k',
                        os_name='linux-gnu',
                        variant='coldfire-soft',
                        gcc_cfg=['--with-arch=cf', '--with-cpu=54455',
                                 '--disable-multilib'])
        self.add_config(arch='microblaze',
                        os_name='linux-gnu',
                        gcc_cfg=['--disable-multilib'])
        self.add_config(arch='microblazeel',
                        os_name='linux-gnu',
                        gcc_cfg=['--disable-multilib'])
        self.add_config(arch='mips64',
                        os_name='linux-gnu',
                        gcc_cfg=['--with-mips-plt'],
                        glibcs=[{'variant': 'n32'},
                                {'arch': 'mips',
                                 'ccopts': '-mabi=32'},
                                {'variant': 'n64',
                                 'ccopts': '-mabi=64'}])
        self.add_config(arch='mips64',
                        os_name='linux-gnu',
                        variant='soft',
                        gcc_cfg=['--with-mips-plt', '--with-float=soft'],
                        glibcs=[{'variant': 'n32-soft'},
                                {'variant': 'soft',
                                 'arch': 'mips',
                                 'ccopts': '-mabi=32'},
                                {'variant': 'n64-soft',
                                 'ccopts': '-mabi=64'}])
        self.add_config(arch='mips64',
                        os_name='linux-gnu',
                        variant='nan2008',
                        gcc_cfg=['--with-mips-plt', '--with-nan=2008',
                                 '--with-arch-64=mips64r2',
                                 '--with-arch-32=mips32r2'],
                        glibcs=[{'variant': 'n32-nan2008'},
                                {'variant': 'nan2008',
                                 'arch': 'mips',
                                 'ccopts': '-mabi=32'},
                                {'variant': 'n64-nan2008',
                                 'ccopts': '-mabi=64'}])
        self.add_config(arch='mips64',
                        os_name='linux-gnu',
                        variant='nan2008-soft',
                        gcc_cfg=['--with-mips-plt', '--with-nan=2008',
                                 '--with-arch-64=mips64r2',
                                 '--with-arch-32=mips32r2',
                                 '--with-float=soft'],
                        glibcs=[{'variant': 'n32-nan2008-soft'},
                                {'variant': 'nan2008-soft',
                                 'arch': 'mips',
                                 'ccopts': '-mabi=32'},
                                {'variant': 'n64-nan2008-soft',
                                 'ccopts': '-mabi=64'}])
        self.add_config(arch='mips64el',
                        os_name='linux-gnu',
                        gcc_cfg=['--with-mips-plt'],
                        glibcs=[{'variant': 'n32'},
                                {'arch': 'mipsel',
                                 'ccopts': '-mabi=32'},
                                {'variant': 'n64',
                                 'ccopts': '-mabi=64'}])
        self.add_config(arch='mips64el',
                        os_name='linux-gnu',
                        variant='soft',
                        gcc_cfg=['--with-mips-plt', '--with-float=soft'],
                        glibcs=[{'variant': 'n32-soft'},
                                {'variant': 'soft',
                                 'arch': 'mipsel',
                                 'ccopts': '-mabi=32'},
                                {'variant': 'n64-soft',
                                 'ccopts': '-mabi=64'}])
        self.add_config(arch='mips64el',
                        os_name='linux-gnu',
                        variant='nan2008',
                        gcc_cfg=['--with-mips-plt', '--with-nan=2008',
                                 '--with-arch-64=mips64r2',
                                 '--with-arch-32=mips32r2'],
                        glibcs=[{'variant': 'n32-nan2008'},
                                {'variant': 'nan2008',
                                 'arch': 'mipsel',
                                 'ccopts': '-mabi=32'},
                                {'variant': 'n64-nan2008',
                                 'ccopts': '-mabi=64'}])
        self.add_config(arch='mips64el',
                        os_name='linux-gnu',
                        variant='nan2008-soft',
                        gcc_cfg=['--with-mips-plt', '--with-nan=2008',
                                 '--with-arch-64=mips64r2',
                                 '--with-arch-32=mips32r2',
                                 '--with-float=soft'],
                        glibcs=[{'variant': 'n32-nan2008-soft'},
                                {'variant': 'nan2008-soft',
                                 'arch': 'mipsel',
                                 'ccopts': '-mabi=32'},
                                {'variant': 'n64-nan2008-soft',
                                 'ccopts': '-mabi=64'}])
        self.add_config(arch='mipsisa64r6el',
                        os_name='linux-gnu',
                        gcc_cfg=['--with-mips-plt', '--with-nan=2008',
                                 '--with-arch-64=mips64r6',
                                 '--with-arch-32=mips32r6',
                                 '--with-float=hard'],
                        glibcs=[{'variant': 'n32'},
                                {'arch': 'mipsisa32r6el',
                                 'ccopts': '-mabi=32'},
                                {'variant': 'n64',
                                 'ccopts': '-mabi=64'}])
        self.add_config(arch='or1k',
                        os_name='linux-gnu',
                        gcc_cfg=['--with-multilib-list=mcmov,mhard-float'],
                        glibcs=[{'variant': 'soft'},
                                {'variant': 'hard', 'ccopts': '-mhard-float'}])
        self.add_config(arch='powerpc',
                        os_name='linux-gnu',
                        gcc_cfg=['--disable-multilib', '--enable-secureplt'],
                        extra_glibcs=[{'variant': 'power4',
                                       'ccopts': '-mcpu=power4',
                                       'cfg': ['--with-cpu=power4']}])
        self.add_config(arch='powerpc',
                        os_name='linux-gnu',
                        variant='soft',
                        gcc_cfg=['--disable-multilib', '--with-float=soft',
                                 '--enable-secureplt'])
        self.add_config(arch='powerpc64',
                        os_name='linux-gnu',
                        gcc_cfg=['--disable-multilib', '--enable-secureplt'])
        self.add_config(arch='powerpc64le',
                        os_name='linux-gnu',
                        gcc_cfg=['--disable-multilib', '--enable-secureplt'],
                        extra_glibcs=[{'variant': 'disable-multi-arch',
                                       'cfg': ['--disable-multi-arch']}])
        self.add_config(arch='riscv32',
                        os_name='linux-gnu',
                        variant='rv32imac-ilp32',
                        gcc_cfg=['--with-arch=rv32imac', '--with-abi=ilp32',
                                 '--disable-multilib'])
        self.add_config(arch='riscv32',
                        os_name='linux-gnu',
                        variant='rv32imafdc-ilp32',
                        gcc_cfg=['--with-arch=rv32imafdc', '--with-abi=ilp32',
                                 '--disable-multilib'])
        self.add_config(arch='riscv32',
                        os_name='linux-gnu',
                        variant='rv32imafdc-ilp32d',
                        gcc_cfg=['--with-arch=rv32imafdc', '--with-abi=ilp32d',
                                 '--disable-multilib'])
        self.add_config(arch='riscv64',
                        os_name='linux-gnu',
                        variant='rv64imac-lp64',
                        gcc_cfg=['--with-arch=rv64imac', '--with-abi=lp64',
                                 '--disable-multilib'])
        self.add_config(arch='riscv64',
                        os_name='linux-gnu',
                        variant='rv64imafdc-lp64',
                        gcc_cfg=['--with-arch=rv64imafdc', '--with-abi=lp64',
                                 '--disable-multilib'])
        self.add_config(arch='riscv64',
                        os_name='linux-gnu',
                        variant='rv64imafdc-lp64d',
                        gcc_cfg=['--with-arch=rv64imafdc', '--with-abi=lp64d',
                                 '--disable-multilib'])
        self.add_config(arch='s390x',
                        os_name='linux-gnu',
                        glibcs=[{},
                                {'arch': 's390', 'ccopts': '-m31'}],
                        extra_glibcs=[{'variant': 'O3',
                                       'cflags': '-O3'},
                                      {'variant': 'zEC12',
                                       'ccopts': '-march=zEC12'},
                                      {'variant': 'z13',
                                       'ccopts': '-march=z13'},
                                      {'variant': 'z15',
                                       'ccopts': '-march=z15'},
                                      {'variant': 'zEC12-disable-multi-arch',
                                       'ccopts': '-march=zEC12',
                                       'cfg': ['--disable-multi-arch']},
                                      {'variant': 'z13-disable-multi-arch',
                                       'ccopts': '-march=z13',
                                       'cfg': ['--disable-multi-arch']},
                                      {'variant': 'z15-disable-multi-arch',
                                       'ccopts': '-march=z15',
                                       'cfg': ['--disable-multi-arch']}])
        self.add_config(arch='sh3',
                        os_name='linux-gnu')
        self.add_config(arch='sh3eb',
                        os_name='linux-gnu')
        self.add_config(arch='sh4',
                        os_name='linux-gnu')
        self.add_config(arch='sh4eb',
                        os_name='linux-gnu')
        self.add_config(arch='sh4',
                        os_name='linux-gnu',
                        variant='soft',
                        gcc_cfg=['--without-fp'])
        self.add_config(arch='sh4eb',
                        os_name='linux-gnu',
                        variant='soft',
                        gcc_cfg=['--without-fp'])
        self.add_config(arch='sparc64',
                        os_name='linux-gnu',
                        glibcs=[{'cfg' : ['--disable-default-pie']},
                                {'cfg' : ['--disable-default-pie'],
                                 'arch': 'sparcv9',
                                 'ccopts': '-m32 -mlong-double-128 -mcpu=v9'}],
                        extra_glibcs=[{'variant': 'leon3',
                                       'cfg' : ['--disable-default-pie'],
                                       'arch' : 'sparcv8',
                                       'ccopts' : '-m32 -mlong-double-128 -mcpu=leon3'},
                                      {'variant': 'disable-multi-arch',
                                       'cfg': ['--disable-multi-arch', '--disable-default-pie']},
                                      {'variant': 'disable-multi-arch',
                                       'arch': 'sparcv9',
                                       'ccopts': '-m32 -mlong-double-128 -mcpu=v9',
                                       'cfg': ['--disable-multi-arch', '--disable-default-pie']}])
        self.add_config(arch='x86_64',
                        os_name='linux-gnu',
                        gcc_cfg=['--with-multilib-list=m64,m32,mx32'],
                        glibcs=[{},
                                {'variant': 'x32', 'ccopts': '-mx32'},
                                {'arch': 'i686', 'ccopts': '-m32 -march=i686'}],
                        extra_glibcs=[{'variant': 'disable-multi-arch',
                                       'cfg': ['--disable-multi-arch']},
                                      {'variant': 'minimal',
                                       'cfg': ['--disable-multi-arch',
                                               '--disable-profile',
                                               '--disable-timezone-tools',
                                               '--disable-mathvec',
                                               '--disable-build-nscd',
                                               '--disable-nscd']},
                                      {'variant': 'no-pie',
                                       'cfg': ['--disable-default-pie']},
                                      {'variant': 'x32-no-pie',
                                       'ccopts': '-mx32',
                                       'cfg': ['--disable-default-pie']},
                                      {'variant': 'no-pie',
                                       'arch': 'i686',
                                       'ccopts': '-m32 -march=i686',
                                       'cfg': ['--disable-default-pie']},
                                      {'variant': 'disable-multi-arch',
                                       'arch': 'i686',
                                       'ccopts': '-m32 -march=i686',
                                       'cfg': ['--disable-multi-arch']},
                                      {'arch': 'i486',
                                       'ccopts': '-m32 -march=i486'},
                                      {'arch': 'i586',
                                       'ccopts': '-m32 -march=i586'},
                                      {'variant': 'enable-fortify-source',
                                       'cfg': ['--enable-fortify-source']}])
        self.add_config(arch='x86_64',
                        os_name='gnu',
                        gcc_cfg=['--disable-multilib'])

    def add_config(self, **args):
        """Add an individual build configuration."""
        cfg = Config(self, **args)
        if self.exclude and cfg.name in self.exclude:
            return
        if cfg.name in self.configs:
            print('error: duplicate config %s' % cfg.name)
            exit(1)
        self.configs[cfg.name] = cfg
        for c in cfg.all_glibcs:
            if c.name in self.glibc_configs:
                print('error: duplicate glibc config %s' % c.name)
                exit(1)
            self.glibc_configs[c.name] = c

    def component_srcdir(self, component):
        """Return the source directory for a given component, e.g. gcc."""
        return os.path.join(self.srcdir, component)

    def component_builddir(self, action, config, component, subconfig=None):
        """Return the directory to use for a build."""
        if config is None:
            # Host libraries.
            assert subconfig is None
            return os.path.join(self.builddir, action, component)
        if subconfig is None:
            return os.path.join(self.builddir, action, config, component)
        else:
            # glibc build as part of compiler build.
            return os.path.join(self.builddir, action, config, component,
                                subconfig)

    def compiler_installdir(self, config):
        """Return the directory in which to install a compiler."""
        return os.path.join(self.installdir, 'compilers', config)

    def compiler_bindir(self, config):
        """Return the directory in which to find compiler binaries."""
        return os.path.join(self.compiler_installdir(config), 'bin')

    def compiler_sysroot(self, config):
        """Return the sysroot directory for a compiler."""
        return os.path.join(self.compiler_installdir(config), 'sysroot')

    def glibc_installdir(self, config):
        """Return the directory in which to install glibc."""
        return os.path.join(self.installdir, 'glibcs', config)

    def run_builds(self, action, configs):
        """Run the requested builds."""
        if action == 'checkout':
            self.checkout(configs)
            return
        if action == 'bot-cycle':
            if configs:
                print('error: configurations specified for bot-cycle')
                exit(1)
            self.bot_cycle()
            return
        if action == 'bot':
            if configs:
                print('error: configurations specified for bot')
                exit(1)
            self.bot()
            return
        if action in ('host-libraries', 'list-compilers',
                      'list-glibcs') and configs:
            print('error: configurations specified for ' + action)
            exit(1)
        if action == 'list-compilers':
            for name in sorted(self.configs.keys()):
                print(name)
            return
        if action == 'list-glibcs':
            for config in sorted(self.glibc_configs.values(),
                                 key=lambda c: c.name):
                print(config.name, config.compiler.name)
            return
        self.clear_last_build_state(action)
        build_time = datetime.datetime.now(datetime.timezone.utc)
        if action == 'host-libraries':
            build_components = ('gmp', 'mpfr', 'mpc')
            old_components = ()
            old_versions = {}
            self.build_host_libraries()
        elif action == 'compilers':
            build_components = ('binutils', 'gcc', 'glibc', 'linux', 'mig',
                                'gnumach', 'hurd')
            old_components = ('gmp', 'mpfr', 'mpc')
            old_versions = self.build_state['host-libraries']['build-versions']
            self.build_compilers(configs)
        else:
            build_components = ('glibc',)
            old_components = ('gmp', 'mpfr', 'mpc', 'binutils', 'gcc', 'linux',
                              'mig', 'gnumach', 'hurd')
            old_versions = self.build_state['compilers']['build-versions']
            if action == 'update-syscalls':
                self.update_syscalls(configs)
            else:
                self.build_glibcs(configs)
        self.write_files()
        self.do_build()
        if configs:
            # Partial build, do not update stored state.
            return
        build_versions = {}
        for k in build_components:
            if k in self.versions:
                build_versions[k] = {'version': self.versions[k]['version'],
                                     'revision': self.versions[k]['revision']}
        for k in old_components:
            if k in old_versions:
                build_versions[k] = {'version': old_versions[k]['version'],
                                     'revision': old_versions[k]['revision']}
        self.update_build_state(action, build_time, build_versions)

    @staticmethod
    def remove_dirs(*args):
        """Remove directories and their contents if they exist."""
        for dir in args:
            shutil.rmtree(dir, ignore_errors=True)

    @staticmethod
    def remove_recreate_dirs(*args):
        """Remove directories if they exist, and create them as empty."""
        Context.remove_dirs(*args)
        for dir in args:
            os.makedirs(dir, exist_ok=True)

    def add_makefile_cmdlist(self, target, cmdlist, logsdir):
        """Add makefile text for a list of commands."""
        commands = cmdlist.makefile_commands(self.wrapper, logsdir)
        self.makefile_pieces.append('all: %s\n.PHONY: %s\n%s:\n%s\n' %
                                    (target, target, target, commands))
        self.status_log_list.extend(cmdlist.status_logs(logsdir))

    def write_files(self):
        """Write out the Makefile and wrapper script."""
        mftext = ''.join(self.makefile_pieces)
        with open(self.makefile, 'w') as f:
            f.write(mftext)
        wrapper_text = (
            '#!/bin/sh\n'
            'prev_base=$1\n'
            'this_base=$2\n'
            'desc=$3\n'
            'dir=$4\n'
            'path=$5\n'
            'shift 5\n'
            'prev_status=$prev_base-status.txt\n'
            'this_status=$this_base-status.txt\n'
            'this_log=$this_base-log.txt\n'
            'date > "$this_log"\n'
            'echo >> "$this_log"\n'
            'echo "Description: $desc" >> "$this_log"\n'
            'printf "%s" "Command:" >> "$this_log"\n'
            'for word in "$@"; do\n'
            '  if expr "$word" : "[]+,./0-9@A-Z_a-z-]\\\\{1,\\\\}\\$" > /dev/null; then\n'
            '    printf " %s" "$word"\n'
            '  else\n'
            '    printf " \'"\n'
            '    printf "%s" "$word" | sed -e "s/\'/\'\\\\\\\\\'\'/"\n'
            '    printf "\'"\n'
            '  fi\n'
            'done >> "$this_log"\n'
            'echo >> "$this_log"\n'
            'echo "Directory: $dir" >> "$this_log"\n'
            'echo "Path addition: $path" >> "$this_log"\n'
            'echo >> "$this_log"\n'
            'record_status ()\n'
            '{\n'
            '  echo >> "$this_log"\n'
            '  echo "$1: $desc" > "$this_status"\n'
            '  echo "$1: $desc" >> "$this_log"\n'
            '  echo >> "$this_log"\n'
            '  date >> "$this_log"\n'
            '  echo "$1: $desc"\n'
            '  exit 0\n'
            '}\n'
            'check_error ()\n'
            '{\n'
            '  if [ "$1" != "0" ]; then\n'
            '    record_status FAIL\n'
            '  fi\n'
            '}\n'
            'if [ "$prev_base" ] && ! grep -q "^PASS" "$prev_status"; then\n'
            '    record_status UNRESOLVED\n'
            'fi\n'
            'if [ "$dir" ]; then\n'
            '  cd "$dir"\n'
            '  check_error "$?"\n'
            'fi\n'
            'if [ "$path" ]; then\n'
            '  PATH=$path:$PATH\n'
            'fi\n'
            '"$@" < /dev/null >> "$this_log" 2>&1\n'
            'check_error "$?"\n'
            'record_status PASS\n')
        with open(self.wrapper, 'w') as f:
            f.write(wrapper_text)
        # Mode 0o755.
        mode_exec = (stat.S_IRWXU|stat.S_IRGRP|stat.S_IXGRP|
                     stat.S_IROTH|stat.S_IXOTH)
        os.chmod(self.wrapper, mode_exec)
        save_logs_text = (
            '#!/bin/sh\n'
            'if ! [ -f tests.sum ]; then\n'
            '  echo "No test summary available."\n'
            '  exit 0\n'
            'fi\n'
            'save_file ()\n'
            '{\n'
            '  echo "Contents of $1:"\n'
            '  echo\n'
            '  cat "$1"\n'
            '  echo\n'
            '  echo "End of contents of $1."\n'
            '  echo\n'
            '}\n'
            'save_file tests.sum\n'
            'non_pass_tests=$(grep -v "^PASS: " tests.sum | sed -e "s/^PASS: //")\n'
            'for t in $non_pass_tests; do\n'
            '  if [ -f "$t.out" ]; then\n'
            '    save_file "$t.out"\n'
            '  fi\n'
            'done\n')
        with open(self.save_logs, 'w') as f:
            f.write(save_logs_text)
        os.chmod(self.save_logs, mode_exec)

    def do_build(self):
        """Do the actual build."""
        cmd = ['make', '-O', '-j%d' % self.parallelism]
        subprocess.run(cmd, cwd=self.builddir, check=True)

    def build_host_libraries(self):
        """Build the host libraries."""
        installdir = self.host_libraries_installdir
        builddir = os.path.join(self.builddir, 'host-libraries')
        logsdir = os.path.join(self.logsdir, 'host-libraries')
        self.remove_recreate_dirs(installdir, builddir, logsdir)
        cmdlist = CommandList('host-libraries', self.keep)
        # This CFLAGS setting works around GMP 6.3.0's configure
        # script being incompatible with compilers defaulting to C23
        # and should be removed when this script is updated to use a
        # release of GMP from after that configure test was fixed in
        # Jan 2025.
        self.build_host_library(cmdlist, 'gmp',
                                ['CFLAGS=-Wall -O2 -std=gnu17'])
        self.build_host_library(cmdlist, 'mpfr',
                                ['--with-gmp=%s' % installdir])
        self.build_host_library(cmdlist, 'mpc',
                                ['--with-gmp=%s' % installdir,
                                '--with-mpfr=%s' % installdir])
        cmdlist.add_command('done', ['touch', os.path.join(installdir, 'ok')])
        self.add_makefile_cmdlist('host-libraries', cmdlist, logsdir)

    def build_host_library(self, cmdlist, lib, extra_opts=None):
        """Build one host library."""
        srcdir = self.component_srcdir(lib)
        builddir = self.component_builddir('host-libraries', None, lib)
        installdir = self.host_libraries_installdir
        cmdlist.push_subdesc(lib)
        cmdlist.create_use_dir(builddir)
        cfg_cmd = [os.path.join(srcdir, 'configure'),
                   '--prefix=%s' % installdir,
                   '--disable-shared']
        if extra_opts:
            cfg_cmd.extend (extra_opts)
        cmdlist.add_command('configure', cfg_cmd)
        cmdlist.add_command('build', ['make'])
        cmdlist.add_command('check', ['make', 'check'])
        cmdlist.add_command('install', ['make', 'install'])
        cmdlist.cleanup_dir()
        cmdlist.pop_subdesc()

    def build_compilers(self, configs):
        """Build the compilers."""
        if not configs:
            self.remove_dirs(os.path.join(self.builddir, 'compilers'))
            self.remove_dirs(os.path.join(self.installdir, 'compilers'))
            self.remove_dirs(os.path.join(self.logsdir, 'compilers'))
            configs = sorted(self.configs.keys())
        for c in configs:
            self.configs[c].build()

    def build_glibcs(self, configs):
        """Build the glibcs."""
        if not configs:
            self.remove_dirs(os.path.join(self.builddir, 'glibcs'))
            self.remove_dirs(os.path.join(self.installdir, 'glibcs'))
            self.remove_dirs(os.path.join(self.logsdir, 'glibcs'))
            configs = sorted(self.glibc_configs.keys())
        for c in configs:
            self.glibc_configs[c].build()

    def update_syscalls(self, configs):
        """Update the glibc syscall lists."""
        if not configs:
            self.remove_dirs(os.path.join(self.builddir, 'update-syscalls'))
            self.remove_dirs(os.path.join(self.logsdir, 'update-syscalls'))
            configs = sorted(self.glibc_configs.keys())
        for c in configs:
            self.glibc_configs[c].update_syscalls()

    def load_versions_json(self):
        """Load information about source directory versions."""
        if not os.access(self.versions_json, os.F_OK):
            self.versions = {}
            return
        with open(self.versions_json, 'r') as f:
            self.versions = json.load(f)

    def store_json(self, data, filename):
        """Store information in a JSON file."""
        filename_tmp = filename + '.tmp'
        with open(filename_tmp, 'w') as f:
            json.dump(data, f, indent=2, sort_keys=True)
        os.rename(filename_tmp, filename)

    def store_versions_json(self):
        """Store information about source directory versions."""
        self.store_json(self.versions, self.versions_json)

    def set_component_version(self, component, version, explicit, revision):
        """Set the version information for a component."""
        self.versions[component] = {'version': version,
                                    'explicit': explicit,
                                    'revision': revision}
        self.store_versions_json()

    def checkout(self, versions):
        """Check out the desired component versions."""
        default_versions = {'binutils': 'vcs-2.44',
                            'gcc': 'vcs-14',
                            'glibc': 'vcs-mainline',
                            'gmp': '6.3.0',
                            'linux': '6.15',
                            'mpc': '1.3.1',
                            'mpfr': '4.2.2',
                            'mig': 'vcs-mainline',
                            'gnumach': 'vcs-mainline',
                            'hurd': 'vcs-mainline'}
        use_versions = {}
        explicit_versions = {}
        for v in versions:
            found_v = False
            for k in default_versions.keys():
                kx = k + '-'
                if v.startswith(kx):
                    vx = v[len(kx):]
                    if k in use_versions:
                        print('error: multiple versions for %s' % k)
                        exit(1)
                    use_versions[k] = vx
                    explicit_versions[k] = True
                    found_v = True
                    break
            if not found_v:
                print('error: unknown component in %s' % v)
                exit(1)
        for k in default_versions.keys():
            if k not in use_versions:
                if k in self.versions and self.versions[k]['explicit']:
                    use_versions[k] = self.versions[k]['version']
                    explicit_versions[k] = True
                else:
                    use_versions[k] = default_versions[k]
                    explicit_versions[k] = False
        os.makedirs(self.srcdir, exist_ok=True)
        for k in sorted(default_versions.keys()):
            update = os.access(self.component_srcdir(k), os.F_OK)
            v = use_versions[k]
            if (update and
                k in self.versions and
                v != self.versions[k]['version']):
                if not self.replace_sources:
                    print('error: version of %s has changed from %s to %s, '
                          'use --replace-sources to check out again' %
                          (k, self.versions[k]['version'], v))
                    exit(1)
                shutil.rmtree(self.component_srcdir(k))
                update = False
            if v.startswith('vcs-'):
                revision = self.checkout_vcs(k, v[4:], update)
            else:
                self.checkout_tar(k, v, update)
                revision = v
            self.set_component_version(k, v, explicit_versions[k], revision)
        if self.get_script_text() != self.script_text:
            # Rerun the checkout process in case the updated script
            # uses different default versions or new components.
            self.exec_self()

    def checkout_vcs(self, component, version, update):
        """Check out the given version of the given component from version
        control.  Return a revision identifier."""
        if component == 'binutils':
            git_url = 'https://sourceware.org/git/binutils-gdb.git'
            if version == 'mainline':
                git_branch = 'master'
            else:
                trans = str.maketrans({'.': '_'})
                git_branch = 'binutils-%s-branch' % version.translate(trans)
            return self.git_checkout(component, git_url, git_branch, update)
        elif component == 'gcc':
            if version == 'mainline':
                branch = 'master'
            else:
                branch = 'releases/gcc-%s' % version
            return self.gcc_checkout(branch, update)
        elif component == 'glibc':
            git_url = 'https://sourceware.org/git/glibc.git'
            if version == 'mainline':
                git_branch = 'master'
            else:
                git_branch = 'release/%s/master' % version
            r = self.git_checkout(component, git_url, git_branch, update)
            self.fix_glibc_timestamps()
            return r
        elif component == 'gnumach':
            git_url = 'git://git.savannah.gnu.org/hurd/gnumach.git'
            git_branch = 'master'
            r = self.git_checkout(component, git_url, git_branch, update)
            subprocess.run(['autoreconf', '-i'],
                           cwd=self.component_srcdir(component), check=True)
            return r
        elif component == 'mig':
            git_url = 'git://git.savannah.gnu.org/hurd/mig.git'
            git_branch = 'master'
            r = self.git_checkout(component, git_url, git_branch, update)
            subprocess.run(['autoreconf', '-i'],
                           cwd=self.component_srcdir(component), check=True)
            return r
        elif component == 'hurd':
            git_url = 'git://git.savannah.gnu.org/hurd/hurd.git'
            git_branch = 'master'
            r = self.git_checkout(component, git_url, git_branch, update)
            subprocess.run(['autoconf'],
                           cwd=self.component_srcdir(component), check=True)
            return r
        else:
            print('error: component %s coming from VCS' % component)
            exit(1)

    def git_checkout(self, component, git_url, git_branch, update):
        """Check out a component from git.  Return a commit identifier."""
        if update:
            subprocess.run(['git', 'remote', 'prune', 'origin'],
                           cwd=self.component_srcdir(component), check=True)
            if self.replace_sources:
                subprocess.run(['git', 'clean', '-dxfq'],
                               cwd=self.component_srcdir(component), check=True)
            subprocess.run(['git', 'pull', '-q'],
                           cwd=self.component_srcdir(component), check=True)
        else:
            if self.shallow:
                depth_arg = ('--depth', '1')
            else:
                depth_arg = ()
            subprocess.run(['git', 'clone', '-q', '-b', git_branch,
                            *depth_arg, git_url,
                            self.component_srcdir(component)], check=True)
        r = subprocess.run(['git', 'rev-parse', 'HEAD'],
                           cwd=self.component_srcdir(component),
                           stdout=subprocess.PIPE,
                           check=True, universal_newlines=True).stdout
        return r.rstrip()

    def fix_glibc_timestamps(self):
        """Fix timestamps in a glibc checkout."""
        # Ensure that builds do not try to regenerate generated files
        # in the source tree.
        srcdir = self.component_srcdir('glibc')
        # These files have Makefile dependencies to regenerate them in
        # the source tree that may be active during a normal build.
        # Some other files have such dependencies but do not need to
        # be touched because nothing in a build depends on the files
        # in question.
        for f in ('sysdeps/mach/hurd/bits/errno.h',):
            to_touch = os.path.join(srcdir, f)
            subprocess.run(['touch', '-c', to_touch], check=True)
        for dirpath, dirnames, filenames in os.walk(srcdir):
            for f in filenames:
                if (f == 'configure' or
                    f == 'preconfigure' or
                    f.endswith('-kw.h')):
                    to_touch = os.path.join(dirpath, f)
                    subprocess.run(['touch', to_touch], check=True)

    def gcc_checkout(self, branch, update):
        """Check out GCC from git.  Return the commit identifier."""
        if os.access(os.path.join(self.component_srcdir('gcc'), '.svn'),
                     os.F_OK):
            if not self.replace_sources:
                print('error: GCC has moved from SVN to git, use '
                      '--replace-sources to check out again')
                exit(1)
            shutil.rmtree(self.component_srcdir('gcc'))
            update = False
        if not update:
            self.git_checkout('gcc', 'https://gcc.gnu.org/git/gcc.git',
                              branch, update)
        subprocess.run(['contrib/gcc_update', '--silent'],
                       cwd=self.component_srcdir('gcc'), check=True)
        r = subprocess.run(['git', 'rev-parse', 'HEAD'],
                           cwd=self.component_srcdir('gcc'),
                           stdout=subprocess.PIPE,
                           check=True, universal_newlines=True).stdout
        return r.rstrip()

    def checkout_tar(self, component, version, update):
        """Check out the given version of the given component from a
        tarball."""
        if update:
            return
        url_map = {'binutils': 'https://ftp.gnu.org/gnu/binutils/binutils-%(version)s.tar.bz2',
                   'gcc': 'https://ftp.gnu.org/gnu/gcc/gcc-%(version)s/gcc-%(version)s.tar.gz',
                   'gmp': 'https://ftp.gnu.org/gnu/gmp/gmp-%(version)s.tar.xz',
                   'linux': 'https://www.kernel.org/pub/linux/kernel/v%(major)s.x/linux-%(version)s.tar.xz',
                   'mpc': 'https://ftp.gnu.org/gnu/mpc/mpc-%(version)s.tar.gz',
                   'mpfr': 'https://ftp.gnu.org/gnu/mpfr/mpfr-%(version)s.tar.xz',
                   'mig': 'https://ftp.gnu.org/gnu/mig/mig-%(version)s.tar.bz2',
                   'gnumach': 'https://ftp.gnu.org/gnu/gnumach/gnumach-%(version)s.tar.bz2',
                   'hurd': 'https://ftp.gnu.org/gnu/hurd/hurd-%(version)s.tar.bz2'}
        if component not in url_map:
            print('error: component %s coming from tarball' % component)
            exit(1)
        version_major = version.split('.')[0]
        url = url_map[component] % {'version': version, 'major': version_major}
        filename = os.path.join(self.srcdir, url.split('/')[-1])
        response = urllib.request.urlopen(url)
        data = response.read()
        with open(filename, 'wb') as f:
            f.write(data)
        subprocess.run(['tar', '-C', self.srcdir, '-x', '-f', filename],
                       check=True)
        os.rename(os.path.join(self.srcdir, '%s-%s' % (component, version)),
                  self.component_srcdir(component))
        os.remove(filename)

    def load_build_state_json(self):
        """Load information about the state of previous builds."""
        if os.access(self.build_state_json, os.F_OK):
            with open(self.build_state_json, 'r') as f:
                self.build_state = json.load(f)
        else:
            self.build_state = {}
        for k in ('host-libraries', 'compilers', 'glibcs', 'update-syscalls'):
            if k not in self.build_state:
                self.build_state[k] = {}
            if 'build-time' not in self.build_state[k]:
                self.build_state[k]['build-time'] = ''
            if 'build-versions' not in self.build_state[k]:
                self.build_state[k]['build-versions'] = {}
            if 'build-results' not in self.build_state[k]:
                self.build_state[k]['build-results'] = {}
            if 'result-changes' not in self.build_state[k]:
                self.build_state[k]['result-changes'] = {}
            if 'ever-passed' not in self.build_state[k]:
                self.build_state[k]['ever-passed'] = []

    def store_build_state_json(self):
        """Store information about the state of previous builds."""
        self.store_json(self.build_state, self.build_state_json)

    def clear_last_build_state(self, action):
        """Clear information about the state of part of the build."""
        # We clear the last build time and versions when starting a
        # new build.  The results of the last build are kept around,
        # as comparison is still meaningful if this build is aborted
        # and a new one started.
        self.build_state[action]['build-time'] = ''
        self.build_state[action]['build-versions'] = {}
        self.store_build_state_json()

    def update_build_state(self, action, build_time, build_versions):
        """Update the build state after a build."""
        build_time = build_time.replace(microsecond=0)
        self.build_state[action]['build-time'] = build_time.strftime(
            '%Y-%m-%d %H:%M:%S')
        self.build_state[action]['build-versions'] = build_versions
        build_results = {}
        for log in self.status_log_list:
            with open(log, 'r') as f:
                log_text = f.read()
            log_text = log_text.rstrip()
            m = re.fullmatch('([A-Z]+): (.*)', log_text)
            result = m.group(1)
            test_name = m.group(2)
            assert test_name not in build_results
            build_results[test_name] = result
        old_build_results = self.build_state[action]['build-results']
        self.build_state[action]['build-results'] = build_results
        result_changes = {}
        all_tests = set(old_build_results.keys()) | set(build_results.keys())
        for t in all_tests:
            if t in old_build_results:
                old_res = old_build_results[t]
            else:
                old_res = '(New test)'
            if t in build_results:
                new_res = build_results[t]
            else:
                new_res = '(Test removed)'
            if old_res != new_res:
                result_changes[t] = '%s -> %s' % (old_res, new_res)
        self.build_state[action]['result-changes'] = result_changes
        old_ever_passed = {t for t in self.build_state[action]['ever-passed']
                           if t in build_results}
        new_passes = {t for t in build_results if build_results[t] == 'PASS'}
        self.build_state[action]['ever-passed'] = sorted(old_ever_passed |
                                                         new_passes)
        self.store_build_state_json()

    def load_bot_config_json(self):
        """Load bot configuration."""
        with open(self.bot_config_json, 'r') as f:
            self.bot_config = json.load(f)

    def part_build_old(self, action, delay):
        """Return whether the last build for a given action was at least a
        given number of seconds ago, or does not have a time recorded."""
        old_time_str = self.build_state[action]['build-time']
        if not old_time_str:
            return True
        old_time = datetime.datetime.strptime(
            old_time_str, '%Y-%m-%d %H:%M:%S').replace(
                tzinfo=datetime.timezone.utc)
        new_time = datetime.datetime.now(datetime.timezone.utc)
        delta = new_time - old_time
        return delta.total_seconds() >= delay

    def bot_cycle(self):
        """Run a single round of checkout and builds."""
        print('Bot cycle starting %s.'
              % str(datetime.datetime.now(datetime.timezone.utc)))
        self.load_bot_config_json()
        actions = ('host-libraries', 'compilers', 'glibcs')
        self.bot_run_self(['--replace-sources'], 'checkout')
        self.load_versions_json()
        if self.get_script_text() != self.script_text:
            print('Script changed, re-execing.')
            # On script change, all parts of the build should be rerun.
            for a in actions:
                self.clear_last_build_state(a)
            self.exec_self()
        check_components = {'host-libraries': ('gmp', 'mpfr', 'mpc'),
                            'compilers': ('binutils', 'gcc', 'glibc', 'linux',
                                          'mig', 'gnumach', 'hurd'),
                            'glibcs': ('glibc',)}
        must_build = {}
        for a in actions:
            build_vers = self.build_state[a]['build-versions']
            must_build[a] = False
            if not self.build_state[a]['build-time']:
                must_build[a] = True
            old_vers = {}
            new_vers = {}
            for c in check_components[a]:
                if c in build_vers:
                    old_vers[c] = build_vers[c]
                new_vers[c] = {'version': self.versions[c]['version'],
                               'revision': self.versions[c]['revision']}
            if new_vers == old_vers:
                print('Versions for %s unchanged.' % a)
            else:
                print('Versions changed or rebuild forced for %s.' % a)
                if a == 'compilers' and not self.part_build_old(
                        a, self.bot_config['compilers-rebuild-delay']):
                    print('Not requiring rebuild of compilers this soon.')
                else:
                    must_build[a] = True
        if must_build['host-libraries']:
            must_build['compilers'] = True
        if must_build['compilers']:
            must_build['glibcs'] = True
        for a in actions:
            if must_build[a]:
                print('Must rebuild %s.' % a)
                self.clear_last_build_state(a)
            else:
                print('No need to rebuild %s.' % a)
        if os.access(self.logsdir, os.F_OK):
            shutil.rmtree(self.logsdir_old, ignore_errors=True)
            shutil.copytree(self.logsdir, self.logsdir_old)
        for a in actions:
            if must_build[a]:
                build_time = datetime.datetime.now(datetime.timezone.utc)
                print('Rebuilding %s at %s.' % (a, str(build_time)))
                self.bot_run_self([], a)
                self.load_build_state_json()
                self.bot_build_mail(a, build_time)
        print('Bot cycle done at %s.'
              % str(datetime.datetime.now(datetime.timezone.utc)))

    def bot_build_mail(self, action, build_time):
        """Send email with the results of a build."""
        if not ('email-from' in self.bot_config and
                'email-server' in self.bot_config and
                'email-subject' in self.bot_config and
                'email-to' in self.bot_config):
            if not self.email_warning:
                print("Email not configured, not sending.")
                self.email_warning = True
            return

        build_time = build_time.replace(microsecond=0)
        subject = (self.bot_config['email-subject'] %
                   {'action': action,
                    'build-time': build_time.strftime('%Y-%m-%d %H:%M:%S')})
        results = self.build_state[action]['build-results']
        changes = self.build_state[action]['result-changes']
        ever_passed = set(self.build_state[action]['ever-passed'])
        versions = self.build_state[action]['build-versions']
        new_regressions = {k for k in changes if changes[k] == 'PASS -> FAIL'}
        all_regressions = {k for k in ever_passed if results[k] == 'FAIL'}
        all_fails = {k for k in results if results[k] == 'FAIL'}
        if new_regressions:
            new_reg_list = sorted(['FAIL: %s' % k for k in new_regressions])
            new_reg_text = ('New regressions:\n\n%s\n\n' %
                            '\n'.join(new_reg_list))
        else:
            new_reg_text = ''
        if all_regressions:
            all_reg_list = sorted(['FAIL: %s' % k for k in all_regressions])
            all_reg_text = ('All regressions:\n\n%s\n\n' %
                            '\n'.join(all_reg_list))
        else:
            all_reg_text = ''
        if all_fails:
            all_fail_list = sorted(['FAIL: %s' % k for k in all_fails])
            all_fail_text = ('All failures:\n\n%s\n\n' %
                             '\n'.join(all_fail_list))
        else:
            all_fail_text = ''
        if changes:
            changes_list = sorted(changes.keys())
            changes_list = ['%s: %s' % (changes[k], k) for k in changes_list]
            changes_text = ('All changed results:\n\n%s\n\n' %
                            '\n'.join(changes_list))
        else:
            changes_text = ''
        results_text = (new_reg_text + all_reg_text + all_fail_text +
                        changes_text)
        if not results_text:
            results_text = 'Clean build with unchanged results.\n\n'
        versions_list = sorted(versions.keys())
        versions_list = ['%s: %s (%s)' % (k, versions[k]['version'],
                                          versions[k]['revision'])
                         for k in versions_list]
        versions_text = ('Component versions for this build:\n\n%s\n' %
                         '\n'.join(versions_list))
        body_text = results_text + versions_text
        msg = email.mime.text.MIMEText(body_text)
        msg['Subject'] = subject
        msg['From'] = self.bot_config['email-from']
        msg['To'] = self.bot_config['email-to']
        msg['Message-ID'] = email.utils.make_msgid()
        msg['Date'] = email.utils.format_datetime(
            datetime.datetime.now(datetime.timezone.utc))
        with smtplib.SMTP(self.bot_config['email-server']) as s:
            s.send_message(msg)

    def bot_run_self(self, opts, action, check=True):
        """Run a copy of this script with given options."""
        cmd = [sys.executable, sys.argv[0], '--keep=none',
               '-j%d' % self.parallelism]
        if self.full_gcc:
            cmd.append('--full-gcc')
        cmd.extend(opts)
        cmd.extend([self.topdir, action])
        sys.stdout.flush()
        subprocess.run(cmd, check=check)

    def bot(self):
        """Run repeated rounds of checkout and builds."""
        while True:
            self.load_bot_config_json()
            if not self.bot_config['run']:
                print('Bot exiting by request.')
                exit(0)
            self.bot_run_self([], 'bot-cycle', check=False)
            self.load_bot_config_json()
            if not self.bot_config['run']:
                print('Bot exiting by request.')
                exit(0)
            time.sleep(self.bot_config['delay'])
            if self.get_script_text() != self.script_text:
                print('Script changed, bot re-execing.')
                self.exec_self()

class LinuxHeadersPolicyForBuild(object):
    """Names and directories for installing Linux headers.  Build variant."""

    def __init__(self, config):
        self.arch = config.arch
        self.srcdir = config.ctx.component_srcdir('linux')
        self.builddir = config.component_builddir('linux')
        self.headers_dir = os.path.join(config.sysroot, 'usr')

class LinuxHeadersPolicyForUpdateSyscalls(object):
    """Names and directories for Linux headers.  update-syscalls variant."""

    def __init__(self, glibc, headers_dir):
        self.arch = glibc.compiler.arch
        self.srcdir = glibc.compiler.ctx.component_srcdir('linux')
        self.builddir = glibc.ctx.component_builddir(
            'update-syscalls', glibc.name, 'build-linux')
        self.headers_dir = headers_dir

def install_linux_headers(policy, cmdlist):
    """Install Linux kernel headers."""
    arch_map = {'aarch64': 'arm64',
                'alpha': 'alpha',
                'arc': 'arc',
                'arm': 'arm',
                'csky': 'csky',
                'hppa': 'parisc',
                'i486': 'x86',
                'i586': 'x86',
                'i686': 'x86',
                'i786': 'x86',
                'loongarch64': 'loongarch',
                'm68k': 'm68k',
                'microblaze': 'microblaze',
                'mips': 'mips',
                'or1k': 'openrisc',
                'powerpc': 'powerpc',
                's390': 's390',
                'riscv32': 'riscv',
                'riscv64': 'riscv',
                'sh': 'sh',
                'sparc': 'sparc',
                'x86_64': 'x86'}
    linux_arch = None
    for k in arch_map:
        if policy.arch.startswith(k):
            linux_arch = arch_map[k]
            break
    assert linux_arch is not None
    cmdlist.push_subdesc('linux')
    cmdlist.create_use_dir(policy.builddir)
    cmdlist.add_command('install-headers',
                        ['make', '-C', policy.srcdir, 'O=%s' % policy.builddir,
                         'ARCH=%s' % linux_arch,
                         'INSTALL_HDR_PATH=%s' % policy.headers_dir,
                         'headers_install'])
    cmdlist.cleanup_dir()
    cmdlist.pop_subdesc()

class Config(object):
    """A configuration for building a compiler and associated libraries."""

    def __init__(self, ctx, arch, os_name, variant=None, gcc_cfg=None,
                 first_gcc_cfg=None, binutils_cfg=None, glibcs=None,
                 extra_glibcs=None):
        """Initialize a Config object."""
        self.ctx = ctx
        self.arch = arch
        self.os = os_name
        self.variant = variant
        if variant is None:
            self.name = '%s-%s' % (arch, os_name)
        else:
            self.name = '%s-%s-%s' % (arch, os_name, variant)
        self.triplet = '%s-glibc-%s' % (arch, os_name)
        if gcc_cfg is None:
            self.gcc_cfg = []
        else:
            self.gcc_cfg = gcc_cfg
        if first_gcc_cfg is None:
            self.first_gcc_cfg = []
        else:
            self.first_gcc_cfg = first_gcc_cfg
        if binutils_cfg is None:
            self.binutils_cfg = []
        else:
            self.binutils_cfg = binutils_cfg
        if glibcs is None:
            glibcs = [{'variant': variant}]
        if extra_glibcs is None:
            extra_glibcs = []
        glibcs = [Glibc(self, **g) for g in glibcs]
        extra_glibcs = [Glibc(self, **g) for g in extra_glibcs]
        self.all_glibcs = glibcs + extra_glibcs
        self.compiler_glibcs = glibcs
        self.installdir = ctx.compiler_installdir(self.name)
        self.bindir = ctx.compiler_bindir(self.name)
        self.sysroot = ctx.compiler_sysroot(self.name)
        self.builddir = os.path.join(ctx.builddir, 'compilers', self.name)
        self.logsdir = os.path.join(ctx.logsdir, 'compilers', self.name)

    def component_builddir(self, component):
        """Return the directory to use for a (non-glibc) build."""
        return self.ctx.component_builddir('compilers', self.name, component)

    def build(self):
        """Generate commands to build this compiler."""
        self.ctx.remove_recreate_dirs(self.installdir, self.builddir,
                                      self.logsdir)
        cmdlist = CommandList('compilers-%s' % self.name, self.ctx.keep)
        cmdlist.add_command('check-host-libraries',
                            ['test', '-f',
                             os.path.join(self.ctx.host_libraries_installdir,
                                          'ok')])
        cmdlist.use_path(self.bindir)
        self.build_cross_tool(cmdlist, 'binutils', 'binutils',
                              ['--disable-gdb',
                               '--disable-gdbserver',
                               '--disable-libdecnumber',
                               '--disable-readline',
                               '--disable-sim'] + self.binutils_cfg)
        if self.os.startswith('linux'):
            install_linux_headers(LinuxHeadersPolicyForBuild(self), cmdlist)
        self.build_gcc(cmdlist, True)
        if self.os == 'gnu':
            self.install_gnumach_headers(cmdlist)
            self.build_cross_tool(cmdlist, 'mig', 'mig')
            self.install_hurd_headers(cmdlist)
        for g in self.compiler_glibcs:
            cmdlist.push_subdesc('glibc')
            cmdlist.push_subdesc(g.name)
            g.build_glibc(cmdlist, GlibcPolicyForCompiler(g))
            cmdlist.pop_subdesc()
            cmdlist.pop_subdesc()
        self.build_gcc(cmdlist, False)
        cmdlist.add_command('done', ['touch',
                                     os.path.join(self.installdir, 'ok')])
        self.ctx.add_makefile_cmdlist('compilers-%s' % self.name, cmdlist,
                                      self.logsdir)

    def build_cross_tool(self, cmdlist, tool_src, tool_build, extra_opts=None):
        """Build one cross tool."""
        srcdir = self.ctx.component_srcdir(tool_src)
        builddir = self.component_builddir(tool_build)
        cmdlist.push_subdesc(tool_build)
        cmdlist.create_use_dir(builddir)
        cfg_cmd = [os.path.join(srcdir, 'configure'),
                   '--prefix=%s' % self.installdir,
                   '--build=%s' % self.ctx.build_triplet,
                   '--host=%s' % self.ctx.build_triplet,
                   '--target=%s' % self.triplet,
                   '--with-sysroot=%s' % self.sysroot]
        if extra_opts:
            cfg_cmd.extend(extra_opts)
        cmdlist.add_command('configure', cfg_cmd)
        cmdlist.add_command('build', ['make'])
        # Parallel "make install" for GCC has race conditions that can
        # cause it to fail; see
        # <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=42980>.  Such
        # problems are not known for binutils, but doing the
        # installation in parallel within a particular toolchain build
        # (as opposed to installation of one toolchain from
        # build-many-glibcs.py running in parallel to the installation
        # of other toolchains being built) is not known to be
        # significantly beneficial, so it is simplest just to disable
        # parallel install for cross tools here.
        cmdlist.add_command('install', ['make', '-j1', 'install'])
        cmdlist.cleanup_dir()
        cmdlist.pop_subdesc()

    def install_gnumach_headers(self, cmdlist):
        """Install GNU Mach headers."""
        srcdir = self.ctx.component_srcdir('gnumach')
        builddir = self.component_builddir('gnumach')
        cmdlist.push_subdesc('gnumach')
        cmdlist.create_use_dir(builddir)
        cmdlist.add_command('configure',
                            [os.path.join(srcdir, 'configure'),
                             '--build=%s' % self.ctx.build_triplet,
                             '--host=%s' % self.triplet,
                             '--prefix=',
                             '--disable-user32',
                             'CC=%s-gcc -nostdlib' % self.triplet])
        cmdlist.add_command('install', ['make', 'DESTDIR=%s' % self.sysroot,
                                        'install-data'])
        cmdlist.cleanup_dir()
        cmdlist.pop_subdesc()

    def install_hurd_headers(self, cmdlist):
        """Install Hurd headers."""
        srcdir = self.ctx.component_srcdir('hurd')
        builddir = self.component_builddir('hurd')
        cmdlist.push_subdesc('hurd')
        cmdlist.create_use_dir(builddir)
        cmdlist.add_command('configure',
                            [os.path.join(srcdir, 'configure'),
                             '--build=%s' % self.ctx.build_triplet,
                             '--host=%s' % self.triplet,
                             '--prefix=',
                             '--disable-profile', '--without-parted',
                             'CC=%s-gcc -nostdlib' % self.triplet])
        cmdlist.add_command('install', ['make', 'prefix=%s' % self.sysroot,
                                        'no_deps=t', 'install-headers'])
        cmdlist.cleanup_dir()
        cmdlist.pop_subdesc()

    def build_gcc(self, cmdlist, bootstrap):
        """Build GCC."""
        # libssp is of little relevance with glibc's own stack
        # checking support.  libcilkrts does not support GNU/Hurd (and
        # has been removed in GCC 8, so --disable-libcilkrts can be
        # removed once glibc no longer supports building with older
        # GCC versions).  --enable-initfini-array is enabled by default
        # in GCC 12, which can be removed when GCC 12 becomes the
        # minimum requirement.
        cfg_opts = list(self.gcc_cfg)
        cfg_opts += ['--enable-initfini-array']
        cfg_opts += ['--disable-libssp', '--disable-libcilkrts']
        host_libs = self.ctx.host_libraries_installdir
        cfg_opts += ['--with-gmp=%s' % host_libs,
                     '--with-mpfr=%s' % host_libs,
                     '--with-mpc=%s' % host_libs]
        if bootstrap:
            tool_build = 'gcc-first'
            # Building a static-only, C-only compiler that is
            # sufficient to build glibc.  Various libraries and
            # features that may require libc headers must be disabled.
            # When configuring with a sysroot, --with-newlib is
            # required to define inhibit_libc (to stop some parts of
            # libgcc including libc headers); --without-headers is not
            # sufficient.
            cfg_opts += ['--enable-languages=c', '--disable-shared',
                         '--disable-threads',
                         '--disable-libatomic',
                         '--disable-decimal-float',
                         '--disable-gcov',
                         '--disable-libffi',
                         '--disable-libgomp',
                         '--disable-libitm',
                         '--disable-libmpx',
                         '--disable-libquadmath',
                         '--disable-libsanitizer',
                         '--without-headers', '--with-newlib',
                         '--with-glibc-version=%s' % self.ctx.glibc_version
                         ]
            cfg_opts += self.first_gcc_cfg
        else:
            tool_build = 'gcc'
            # libsanitizer commonly breaks because of glibc header
            # changes, or on unusual targets.  C++ pre-compiled
            # headers are not used during the glibc build and are
            # expensive to create.
            if not self.ctx.full_gcc:
                cfg_opts += ['--disable-libsanitizer',
                             '--disable-libstdcxx-pch']
            langs = 'all' if self.ctx.full_gcc else 'c,c++'
            cfg_opts += ['--enable-languages=%s' % langs,
                         '--enable-shared', '--enable-threads']
        self.build_cross_tool(cmdlist, 'gcc', tool_build, cfg_opts)

class GlibcPolicyDefault(object):
    """Build policy for glibc: common defaults."""

    def __init__(self, glibc):
        self.srcdir = glibc.ctx.component_srcdir('glibc')
        self.use_usr = glibc.os != 'gnu'
        self.prefix = '/usr' if self.use_usr else ''
        self.configure_args = [
            '--prefix=%s' % self.prefix,
            '--enable-profile',
            '--build=%s' % glibc.ctx.build_triplet,
            '--host=%s' % glibc.triplet,
            'CC=%s' % glibc.tool_name('gcc'),
            'CXX=%s' % glibc.tool_name('g++'),
        ]
        if glibc.os == 'gnu':
            self.configure_args.append('MIG=%s' % glibc.tool_name('mig'))
        if glibc.cflags:
            self.configure_args.append('CFLAGS=%s' % glibc.cflags)
            self.configure_args.append('CXXFLAGS=%s' % glibc.cflags)
        self.configure_args += glibc.cfg

    def configure(self, cmdlist):
        """Invoked to add the configure command to the command list."""
        cmdlist.add_command('configure',
                            [os.path.join(self.srcdir, 'configure'),
                             *self.configure_args])

    def extra_commands(self, cmdlist):
        """Invoked to inject additional commands (make check) after build."""
        pass

class GlibcPolicyForCompiler(GlibcPolicyDefault):
    """Build policy for glibc during the compilers stage."""

    def __init__(self, glibc):
        super().__init__(glibc)
        self.builddir = glibc.ctx.component_builddir(
            'compilers', glibc.compiler.name, 'glibc', glibc.name)
        self.installdir = glibc.compiler.sysroot

class GlibcPolicyForBuild(GlibcPolicyDefault):
    """Build policy for glibc during the glibcs stage."""

    def __init__(self, glibc):
        super().__init__(glibc)
        self.builddir = glibc.ctx.component_builddir(
            'glibcs', glibc.name, 'glibc')
        self.installdir = glibc.ctx.glibc_installdir(glibc.name)
        if glibc.ctx.strip:
            self.strip = glibc.tool_name('strip')
        else:
            self.strip = None
        self.save_logs = glibc.ctx.save_logs

    def extra_commands(self, cmdlist):
        if self.strip:
            # Avoid stripping libc.so and libpthread.so, which are
            # linker scripts stored in /lib on Hurd.
            find_command = 'find %s/lib* -name "*.so*"' % self.installdir
            cmdlist.add_command('strip', ['sh', '-c', (
                'set -e; for f in $(%s); do '
                'if ! head -c16 $f | grep -q "GNU ld script"; then %s $f; fi; '
                'done' % (find_command, self.strip))])
        cmdlist.add_command('check', ['make', 'check'])
        cmdlist.add_command('save-logs', [self.save_logs], always_run=True)

class GlibcPolicyForUpdateSyscalls(GlibcPolicyDefault):
    """Build policy for glibc during update-syscalls."""

    def __init__(self, glibc):
        super().__init__(glibc)
        self.builddir = glibc.ctx.component_builddir(
            'update-syscalls', glibc.name, 'glibc')
        self.linuxdir = glibc.ctx.component_builddir(
            'update-syscalls', glibc.name, 'linux')
        self.linux_policy = LinuxHeadersPolicyForUpdateSyscalls(
            glibc, self.linuxdir)
        self.configure_args.insert(
            0, '--with-headers=%s' % os.path.join(self.linuxdir, 'include'))
        # self.installdir not set because installation is not supported

class Glibc(object):
    """A configuration for building glibc."""

    def __init__(self, compiler, arch=None, os_name=None, variant=None,
                 cfg=None, ccopts=None, cflags=None):
        """Initialize a Glibc object."""
        self.ctx = compiler.ctx
        self.compiler = compiler
        if arch is None:
            self.arch = compiler.arch
        else:
            self.arch = arch
        if os_name is None:
            self.os = compiler.os
        else:
            self.os = os_name
        self.variant = variant
        if variant is None:
            self.name = '%s-%s' % (self.arch, self.os)
        else:
            self.name = '%s-%s-%s' % (self.arch, self.os, variant)
        self.triplet = '%s-glibc-%s' % (self.arch, self.os)
        if cfg is None:
            self.cfg = []
        else:
            self.cfg = cfg
        # ccopts contain ABI options and are passed to configure as CC / CXX.
        self.ccopts = ccopts
        # cflags contain non-ABI options like -g or -O and are passed to
        # configure as CFLAGS / CXXFLAGS.
        self.cflags = cflags

    def tool_name(self, tool):
        """Return the name of a cross-compilation tool."""
        ctool = '%s-%s' % (self.compiler.triplet, tool)
        if self.ccopts and (tool == 'gcc' or tool == 'g++'):
            ctool = '%s %s' % (ctool, self.ccopts)
        return ctool

    def build(self):
        """Generate commands to build this glibc."""
        builddir = self.ctx.component_builddir('glibcs', self.name, 'glibc')
        installdir = self.ctx.glibc_installdir(self.name)
        logsdir = os.path.join(self.ctx.logsdir, 'glibcs', self.name)
        self.ctx.remove_recreate_dirs(installdir, builddir, logsdir)
        cmdlist = CommandList('glibcs-%s' % self.name, self.ctx.keep)
        cmdlist.add_command('check-compilers',
                            ['test', '-f',
                             os.path.join(self.compiler.installdir, 'ok')])
        cmdlist.use_path(self.compiler.bindir)
        self.build_glibc(cmdlist, GlibcPolicyForBuild(self))
        self.ctx.add_makefile_cmdlist('glibcs-%s' % self.name, cmdlist,
                                      logsdir)

    def build_glibc(self, cmdlist, policy):
        """Generate commands to build this glibc, either as part of a compiler
        build or with the bootstrapped compiler (and in the latter case, run
        tests as well)."""
        cmdlist.create_use_dir(policy.builddir)
        policy.configure(cmdlist)
        cmdlist.add_command('build', ['make'])
        cmdlist.add_command('install', ['make', 'install',
                                        'install_root=%s' % policy.installdir])
        # GCC uses paths such as lib/../lib64, so make sure lib
        # directories always exist.
        mkdir_cmd = ['mkdir', '-p',
                     os.path.join(policy.installdir, 'lib')]
        if policy.use_usr:
            mkdir_cmd += [os.path.join(policy.installdir, 'usr', 'lib')]
        cmdlist.add_command('mkdir-lib', mkdir_cmd)
        policy.extra_commands(cmdlist)
        cmdlist.cleanup_dir()

    def update_syscalls(self):
        if self.os == 'gnu':
            # Hurd does not have system call tables that need updating.
            return

        policy = GlibcPolicyForUpdateSyscalls(self)
        logsdir = os.path.join(self.ctx.logsdir, 'update-syscalls', self.name)
        self.ctx.remove_recreate_dirs(policy.builddir, logsdir)
        cmdlist = CommandList('update-syscalls-%s' % self.name, self.ctx.keep)
        cmdlist.add_command('check-compilers',
                            ['test', '-f',
                             os.path.join(self.compiler.installdir, 'ok')])
        cmdlist.use_path(self.compiler.bindir)

        install_linux_headers(policy.linux_policy, cmdlist)

        cmdlist.create_use_dir(policy.builddir)
        policy.configure(cmdlist)
        cmdlist.add_command('build', ['make', 'update-syscall-lists'])
        cmdlist.cleanup_dir()
        self.ctx.add_makefile_cmdlist('update-syscalls-%s' % self.name,
                                      cmdlist, logsdir)

class Command(object):
    """A command run in the build process."""

    def __init__(self, desc, num, dir, path, command, always_run=False):
        """Initialize a Command object."""
        self.dir = dir
        self.path = path
        self.desc = desc
        trans = str.maketrans({' ': '-'})
        self.logbase = '%03d-%s' % (num, desc.translate(trans))
        self.command = command
        self.always_run = always_run

    @staticmethod
    def shell_make_quote_string(s):
        """Given a string not containing a newline, quote it for use by the
        shell and make."""
        assert '\n' not in s
        if re.fullmatch('[]+,./0-9@A-Z_a-z-]+', s):
            return s
        strans = str.maketrans({"'": "'\\''"})
        s = "'%s'" % s.translate(strans)
        mtrans = str.maketrans({'$': '$$'})
        return s.translate(mtrans)

    @staticmethod
    def shell_make_quote_list(l, translate_make):
        """Given a list of strings not containing newlines, quote them for use
        by the shell and make, returning a single string.  If translate_make
        is true and the first string is 'make', change it to $(MAKE)."""
        l = [Command.shell_make_quote_string(s) for s in l]
        if translate_make and l[0] == 'make':
            l[0] = '$(MAKE)'
        return ' '.join(l)

    def shell_make_quote(self):
        """Return this command quoted for the shell and make."""
        return self.shell_make_quote_list(self.command, True)


class CommandList(object):
    """A list of commands run in the build process."""

    def __init__(self, desc, keep):
        """Initialize a CommandList object."""
        self.cmdlist = []
        self.dir = None
        self.path = None
        self.desc = [desc]
        self.keep = keep

    def desc_txt(self, desc):
        """Return the description to use for a command."""
        return '%s %s' % (' '.join(self.desc), desc)

    def use_dir(self, dir):
        """Set the default directory for subsequent commands."""
        self.dir = dir

    def use_path(self, path):
        """Set a directory to be prepended to the PATH for subsequent
        commands."""
        self.path = path

    def push_subdesc(self, subdesc):
        """Set the default subdescription for subsequent commands (e.g., the
        name of a component being built, within the series of commands
        building it)."""
        self.desc.append(subdesc)

    def pop_subdesc(self):
        """Pop a subdescription from the list of descriptions."""
        self.desc.pop()

    def create_use_dir(self, dir):
        """Remove and recreate a directory and use it for subsequent
        commands."""
        self.add_command_dir('rm', None, ['rm', '-rf', dir])
        self.add_command_dir('mkdir', None, ['mkdir', '-p', dir])
        self.use_dir(dir)

    def add_command_dir(self, desc, dir, command, always_run=False):
        """Add a command to run in a given directory."""
        cmd = Command(self.desc_txt(desc), len(self.cmdlist), dir, self.path,
                      command, always_run)
        self.cmdlist.append(cmd)

    def add_command(self, desc, command, always_run=False):
        """Add a command to run in the default directory."""
        cmd = Command(self.desc_txt(desc), len(self.cmdlist), self.dir,
                      self.path, command, always_run)
        self.cmdlist.append(cmd)

    def cleanup_dir(self, desc='cleanup', dir=None):
        """Clean up a build directory.  If no directory is specified, the
        default directory is cleaned up and ceases to be the default
        directory."""
        if dir is None:
            dir = self.dir
            self.use_dir(None)
        if self.keep != 'all':
            self.add_command_dir(desc, None, ['rm', '-rf', dir],
                                 always_run=(self.keep == 'none'))

    def makefile_commands(self, wrapper, logsdir):
        """Return the sequence of commands in the form of text for a Makefile.
        The given wrapper script takes arguments: base of logs for
        previous command, or empty; base of logs for this command;
        description; directory; PATH addition; the command itself."""
        # prev_base is the base of the name for logs of the previous
        # command that is not always-run (that is, a build command,
        # whose failure should stop subsequent build commands from
        # being run, as opposed to a cleanup command, which is run
        # even if previous commands failed).
        prev_base = ''
        cmds = []
        for c in self.cmdlist:
            ctxt = c.shell_make_quote()
            if prev_base and not c.always_run:
                prev_log = os.path.join(logsdir, prev_base)
            else:
                prev_log = ''
            this_log = os.path.join(logsdir, c.logbase)
            if not c.always_run:
                prev_base = c.logbase
            if c.dir is None:
                dir = ''
            else:
                dir = c.dir
            if c.path is None:
                path = ''
            else:
                path = c.path
            prelims = [wrapper, prev_log, this_log, c.desc, dir, path]
            prelim_txt = Command.shell_make_quote_list(prelims, False)
            cmds.append('\t@%s %s' % (prelim_txt, ctxt))
        return '\n'.join(cmds)

    def status_logs(self, logsdir):
        """Return the list of log files with command status."""
        return [os.path.join(logsdir, '%s-status.txt' % c.logbase)
                for c in self.cmdlist]


def get_parser():
    """Return an argument parser for this module."""
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('-j', dest='parallelism',
                        help='Run this number of jobs in parallel',
                        type=int, default=os.cpu_count())
    parser.add_argument('--keep', dest='keep',
                        help='Whether to keep all build directories, '
                        'none or only those from failed builds',
                        default='none', choices=('none', 'all', 'failed'))
    parser.add_argument('--replace-sources', action='store_true',
                        help='Remove and replace source directories '
                        'with the wrong version of a component')
    parser.add_argument('--strip', action='store_true',
                        help='Strip installed glibc libraries')
    parser.add_argument('--full-gcc', action='store_true',
                        help='Build GCC with all languages and libsanitizer')
    parser.add_argument('--shallow', action='store_true',
                        help='Do not download Git history during checkout')
    parser.add_argument('--exclude', dest='exclude',
                        help='Targets to be excluded', nargs='*')
    parser.add_argument('topdir',
                        help='Toplevel working directory')
    parser.add_argument('action',
                        help='What to do',
                        choices=('checkout', 'bot-cycle', 'bot',
                                 'host-libraries', 'compilers', 'glibcs',
                                 'update-syscalls', 'list-compilers',
                                 'list-glibcs'))
    parser.add_argument('configs',
                        help='Versions to check out or configurations to build',
                        nargs='*')
    return parser


def get_version_common(progname,line,word,arg1):
    try:
        out = subprocess.run([progname, arg1],
                             stdout=subprocess.PIPE,
                             stderr=subprocess.DEVNULL,
                             stdin=subprocess.DEVNULL,
                             check=True, universal_newlines=True)
        v = out.stdout.splitlines()[line].split()[word]
        v = re.match(r'[0-9]+(.[0-9]+)*', v).group()
        return [int(x) for x in v.split('.')]
    except:
        return 'missing';

def get_version_common_stderr(progname,line,word,arg1):
    try:
        out = subprocess.run([progname, arg1],
                             stdout=subprocess.DEVNULL,
                             stderr=subprocess.PIPE,
                             stdin=subprocess.DEVNULL,
                             check=True, universal_newlines=True)
        v = out.stderr.splitlines()[line].split()[word]
        v = re.match(r'[0-9]+(.[0-9]+)*', v).group()
        return [int(x) for x in v.split('.')]
    except:
        return 'missing';

def get_version(progname):
    return get_version_common(progname, 0, -1, '--version');

def get_version_awk(progname):
    return get_version_common(progname, 0, 2, '--version');

def get_version_bzip2(progname):
    return get_version_common_stderr(progname, 0, 6, '-h');

def check_version(ver, req):
    for v, r in zip(ver, req):
        if v > r:
            return True
        if v < r:
            return False
    return True

def version_str(ver):
    return '.'.join([str (x) for x in ver])

def check_for_required_tools():
    get_list_of_required_tools()
    count_old_tools = 0
    count_missing_tools = 0

    for k, v in REQUIRED_TOOLS.items():
        version = v[0](k)
        if version == 'missing':
            ok = 'missing'
        else:
            ok = 'ok' if check_version (version, v[1]) else 'old'
        if ok == 'old':
            if count_old_tools == 0:
                print("One or more required tools are too old:")
            count_old_tools = count_old_tools + 1
            print('{:9}: {:3} (obtained=\"{}\" required=\"{}\")'.format(k, ok,
                    version_str(version), version_str(v[1])))
        if ok == 'missing':
            if count_missing_tools == 0:
                print("One or more required tools are missing:")
            count_missing_tools = count_missing_tools + 1
            print('{:9}: {:3} (required=\"{}\")'.format(k, ok,
                    version_str(v[1])))

    if count_old_tools > 0 or count_missing_tools > 0:
        exit (1);

def main(argv):
    """The main entry point."""
    check_for_required_tools();
    parser = get_parser()
    opts = parser.parse_args(argv)
    topdir = os.path.abspath(opts.topdir)
    ctx = Context(topdir, opts.parallelism, opts.keep, opts.replace_sources,
                  opts.strip, opts.full_gcc, opts.action, opts.exclude,
                  shallow=opts.shallow)
    ctx.run_builds(opts.action, opts.configs)


if __name__ == '__main__':
    main(sys.argv[1:])