dev-embedded/ti50-sdk/files/build_clang_toolchain.py

#!/usr/bin/env python3
# Copyright 2021 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Builds the clang toolchain for Ti50."""

# pylint: disable=cros-logging-import

import argparse
import logging
import os
from pathlib import Path
import shlex
import shutil
import subprocess
import sys
from typing import List

# CFlags used when building RISCV runtime libraries.
RISCV_RUNTIME_CFLAGS = (
    '-O2',
    '--target=riscv32-unknown-elf',
    '-DVISIBILITY_HIDDEN',
    '-DNDEBUG',
    '-fno-builtin',
    '-fvisibility=hidden',
    '-fomit-frame-pointer',
    '-mno-relax',
    '-fforce-enable-int128',
    '-DCRT_HAS_INITFINI_ARRAY',
    '-march=rv32imcxsoteria',
    '-ffunction-sections',
    '-fdata-sections',
    '-fstack-size-section',
    '-mcmodel=medlow',
    '-Wno-unused-command-line-argument',
)

# Flags passed to cmake command for building LLVM
# TODO(sukhomlinov): These args are copy-pasted; they might not all be
# necessary.
CMAKE_FLAGS = (
    '-G',
    'Ninja',
    '-DCMAKE_BUILD_TYPE=Release',
    '-DLLVM_ENABLE_LIBCXX=ON',
    '-DLLVM_OPTIMIZED_TABLEGEN=ON',
    '-DLLVM_BUILD_TESTS=OFF',
    '-DCLANG_ENABLE_STATIC_ANALYZER=ON',
    '-DCLANG_DEFAULT_RTLIB="compiler-rt"',
    '-DLLVM_DEFAULT_TARGET_TRIPLE=riscv32-unknown-elf',
    '-DLLVM_INSTALL_BINUTILS_SYMLINKS=ON',
    '-DLLVM_INSTALL_CCTOOLS_SYMLINKS=ON',
    '-DCLANG_DEFAULT_LINKER=ld.lld',
    '-DLLVM_ENABLE_BACKTRACES=OFF',
    '-DLLVM_INCLUDE_EXAMPLES=OFF',
    '-DLLVM_DYLIB_COMPONENTS=""',
    '-DLLVM_LINK_LLVM_DYLIB=OFF',
    '-DLLVM_BUILD_STATIC=OFF',
    '-DLLVM_INSTALL_UTILS=ON',
    '-DLLVM_ENABLE_Z3_SOLVER=OFF',
    '-DLLVM_USE_RELATIVE_PATHS_IN_FILES=ON',
    '-DLLVM_TARGETS_TO_BUILD=RISCV;X86',
    '-DLLVM_ENABLE_PROJECTS=clang;clang-tools-extra;lldb;lld;polly',
)

# Flags for configuring newlib.
NEWLIB_CONFIG_FLAGS = (
    '--target=riscv32-unknown-elf',
    '--enable-newlib-reent-small',
    '--disable-newlib-fvwrite-in-streamio',
    '--disable-newlib-fseek-optimization',
    '--disable-newlib-wide-orient',
    '--enable-newlib-nano-malloc',
    '--disable-newlib-unbuf-stream-opt',
    '--enable-lite-exit',
    '--enable-newlib-global-atexit',
    '--enable-newlib-nano-formatted-io',
    '--disable-newlib-supplied-syscalls',
    '--disable-nls',
    '--enable-newlib-io-c99-formats',
    '--enable-newlib-io-long-long',
)


def remove_path_if_exists(file_or_dir: Path):
  """Removes the given file/directory/symlink if it exists."""
  if file_or_dir.is_file() or file_or_dir.is_symlink():
    file_or_dir.unlink()
  elif file_or_dir.is_dir():
    shutil.rmtree(file_or_dir)
  else:
    assert not file_or_dir.exists(), file_or_dir


def find_clang_resource_dir(llvm_install_dir: Path) -> Path:
  """Locates the resource directory of the clang in |llvm_install_dir|."""
  return Path(
      subprocess.check_output(
          [str(llvm_install_dir / 'bin' / 'clang'), '-print-resource-dir'],
          encoding='utf-8',
      ).strip())


def build_llvm(llvm_dir: Path, build_dir: Path, install_dir: Path):
  """Builds and installs LLVM to install_dir, plus crt{begin,end} for RISCV."""
  build_dir.mkdir(parents=True, exist_ok=True)

  if not (build_dir / 'build.ninja').exists():
    logging.info('Configuring LLVM')
    cmd = [
        'cmake',
        f'-DCMAKE_INSTALL_PREFIX={install_dir}',
        f'-DDEFAULT_SYSROOT={install_dir}',
        f'-DGCC_INSTALL_PREFIX={install_dir}',
        str(llvm_dir / 'llvm'),
    ]
    cmd += CMAKE_FLAGS
    subprocess.check_call(cmd, cwd=build_dir)

  logging.info('Building + installing LLVM')
  subprocess.check_call(['ninja', 'install'], cwd=build_dir)

  # And now we build the runtime library. Whee.
  clang_rtlib_prefix = [
      str(install_dir / 'bin' / 'clang'),
      '-c',
      '-v',
  ]
  clang_rtlib_prefix += RISCV_RUNTIME_CFLAGS

  libdir = find_clang_resource_dir(install_dir)
  (libdir / 'lib').mkdir(parents=True, exist_ok=True)
  subprocess.check_call(clang_rtlib_prefix + [
      str(llvm_dir / 'compiler-rt' / 'lib' / 'crt' / 'crtbegin.c'),
      '-o',
      str(libdir / 'lib' / 'clang_rt.crtbegin-riscv32.o'),
  ])

  subprocess.check_call(clang_rtlib_prefix + [
      str(llvm_dir / 'compiler-rt' / 'lib' / 'crt' / 'crtend.c'),
      '-o',
      str(libdir / 'lib' / 'clang_rt.crtend-riscv32.o'),
  ])


def build_newlib(rv_clang_bin: Path, newlib_dir: Path, newlib_build_dir: Path,
                 install_dir: Path):
  """Builds and installs newlib into |install_dir|."""
  newlib_build_dir.mkdir(parents=True)

  logging.info("Setting up newlib's build")

  env_with_rv_clang = os.environ.copy()
  # ...I don't *want* to have all of this in the environment, but if all of
  # this (ignoring PATH) is provided to |./configure| as args, |make| gets
  # angry that it doesn't see the same values in its environment when invoked.
  #
  # TODO(sukhomlinov): This seems like brokenness in newlib, maybe?
  env_with_rv_clang.update({
      'LDFLAGS': f'{env_with_rv_clang.get("LDFLAGS", "")} -fuse-ld=lld',
      'PATH': f'{rv_clang_bin}:{env_with_rv_clang["PATH"]}',
  })

  tool_substitutions = (
      ('AR', 'llvm-ar'),
      ('AS', 'llvm-as'),
      ('NM', 'llvm-nm'),
      ('OBJDUMP', 'llvm-objdump'),
      ('RANLIB', 'llvm-ranlib'),
  )

  for var_name, executable in tool_substitutions:
    executable_path = install_dir / 'bin' / executable
    env_with_rv_clang.update({
        var_name: executable_path,
        f'{var_name}_FOR_TARGET': executable_path,
    })

  env_with_rv_clang.update({
      f'{var_name}_FOR_TARGET': install_dir / 'bin' / exe
      for var_name, exe in (('CC', 'clang'), ('CXX', 'clang++'))
  })

  cmd = [
      './configure',
      f'--prefix={newlib_build_dir}',
      f'CFLAGS_FOR_TARGET={" ".join(RISCV_RUNTIME_CFLAGS)}',
      f'CXXFLAGS_FOR_TARGET={" ".join(RISCV_RUNTIME_CFLAGS)}',
      'LDFLAGS=-fuse-ld=lld',
      'LDFLAGS_FOR_TARGET=-fuse-ld=lld',
  ]
  cmd += NEWLIB_CONFIG_FLAGS
  subprocess.check_call(cmd, cwd=newlib_dir, env=env_with_rv_clang)

  logging.info('Building newlib')

  jobs = f'-j{os.cpu_count()}'
  subprocess.check_call(['make', jobs], cwd=newlib_dir, env=env_with_rv_clang)
  subprocess.check_call(['make', jobs, 'install'],
                        cwd=newlib_dir,
                        env=env_with_rv_clang)

  logging.info("Fixing newlib's installation")
  # Quoting the script that I'm basing this off of:
  # """
  # move includes/libs to where they can be found by default
  # this is also a hack, but avoid adding paths explicitly
  # This is because riscv32-unknown-elf target only use
  # $INSTALL_DIR/lib and $INSTALL_DIR/lib/clang/11.0.0/lib paths,
  # ignoring --libdir and --sysroot for cmake configure
  # $INSTALL_DIR/include contains llvm headers not used for C compilation
  # normally, unless you build llvm tools, but directory is in default
  # search path, so use it for libc headers.
  # """
  installed_include_dir = install_dir / 'include'
  old_include_dir = install_dir / 'include.old'
  if installed_include_dir.exists():
    shutil.move(installed_include_dir, old_include_dir)

  shutil.copytree(newlib_build_dir / 'riscv32-unknown-elf' / 'include',
                  installed_include_dir)

  if old_include_dir.exists():
    shutil.rmtree(old_include_dir)
  for f in (install_dir / 'lib').glob('*.a'):
    f.unlink()

  lib_base = install_dir / 'lib'
  for f in (newlib_build_dir / 'riscv32-unknown-elf' / 'lib').iterdir():
    shutil.copy2(f, lib_base / f.name)


def build_compiler_rt(llvm_path: Path, compiler_rt_build_dir: Path,
                      install_dir: Path):
  """Builds compiler_rt and installs artifacts in |install_dir|."""
  compiler_rt_build_dir.mkdir(parents=True)
  run_clang = [str(install_dir / 'bin' / 'clang'), '-c']
  run_clang += RISCV_RUNTIME_CFLAGS
  compiler_rt_builtins = llvm_path / 'compiler-rt' / 'lib' / 'builtins'
  subprocess.check_call(
      run_clang + [
          str(compiler_rt_builtins / 'riscv' / 'mulsi3.S'),
      ],
      cwd=compiler_rt_build_dir,
  )

  # It's expected that some of these builds fail for various reasons (no atomic
  # uint64_t on riscv, etc.)
  expected_failures = {
      'atomic_flag_clear.c',
      'atomic_flag_clear_explicit.c',
      'atomic_flag_test_and_set.c',
      'atomic_flag_test_and_set_explicit.c',
      'atomic_signal_fence.c',
      'atomic_thread_fence.c',
      'emutls.c',
      'enable_execute_stack.c',
  }

  had_unexpected_results = False
  for f in compiler_rt_builtins.glob('*.c'):
    # Build the expected failures, since doing so is quick, and if they _do_
    # successfully build, that sounds like smoke to me.
    command = run_clang + [str(f)]
    should_fail = f.name in expected_failures
    command_string = ' '.join(shlex.quote(x) for x in command)
    try:
      stdout = subprocess.check_output(
          command,
          cwd=compiler_rt_build_dir,
          stderr=subprocess.STDOUT,
          encoding='utf-8',
      )
    except subprocess.CalledProcessError as e:
      if should_fail:
        logging.info('Running %s failed as expected', command_string)
        continue
      logging.error('Running %s failed unexpectedly; output:\n%s',
                    command_string, e.stdout)
      had_unexpected_results = True
    else:
      if not should_fail:
        logging.info('Running %s succeeded as expected', command_string)
        continue
      logging.error('Running %s succeeded unexpectedly; output:\n%s',
                    command_string, stdout)
      had_unexpected_results = True

  if had_unexpected_results:
    raise ValueError(
        "Manual builds of compiler-rt bits didn't go as planned; please see "
        'logging output')

  libdir = find_clang_resource_dir(install_dir)
  link_command = [
      str(install_dir / 'bin' / 'llvm-ar'),
      'rc',
      str(libdir / 'libclang_rt.builtins-riscv32.a'),
  ]
  link_command += (str(x) for x in compiler_rt_build_dir.glob('*.o'))
  subprocess.check_call(link_command)


def log_install_paths(install_dir: Path):
  """Prints install paths to stdout."""
  clang = str(install_dir / 'bin' / 'clang')
  subprocess.check_call([clang, '-E', '-x', 'c++', '/dev/null', '-v'])
  subprocess.check_call([clang, '-print-search-dirs'])


def get_parser():
  """Creates a parser for commandline args."""
  parser = argparse.ArgumentParser(
      description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
  parser.add_argument(
      '--work-dir',
      required=True,
      type=Path,
      help='Path to put build artifacts in.',
  )
  parser.add_argument(
      '--llvm-dir',
      required=True,
      type=Path,
      help='Path to the LLVM checkout.',
  )
  parser.add_argument(
      '--newlib-dir',
      required=True,
      type=Path,
      help='Path to the newlib checkout.',
  )
  parser.add_argument(
      '--no-clean-llvm',
      action='store_false',
      dest='clean_llvm',
      help="Don't wipe out LLVM's build directory if it exists.",
  )
  parser.add_argument(
      '--no-clean-newlib',
      action='store_false',
      dest='clean_newlib',
      help="Don't wipe out newlib's build directory if it exists.",
  )
  parser.add_argument(
      '--install-dir',
      required=True,
      type=Path,
      help='Path to the place to install artifacts.',
  )
  return parser


def main(argv: List[str]):
  logging.basicConfig(
      format='%(asctime)s: %(levelname)s: %(filename)s:%(lineno)d: %(message)s',
      level=logging.INFO,
  )

  opts = get_parser().parse_args(argv)
  work_dir = opts.work_dir
  install_dir = opts.install_dir.resolve()
  llvm_path = opts.llvm_dir.resolve()
  newlib_path = opts.newlib_dir.resolve()

  work_dir.mkdir(parents=True, exist_ok=True)

  remove_path_if_exists(install_dir)
  install_dir.mkdir(parents=True)

  llvm_build_dir = work_dir / 'llvm-build' / 'Release'
  if opts.clean_llvm:
    remove_path_if_exists(llvm_build_dir)
  build_llvm(llvm_path, llvm_build_dir, install_dir)

  newlib_build_dir = work_dir / 'newlib' / 'build'
  if opts.clean_newlib:
    # Ugly: newlib builds to _both_ the build dir and an in-git-directory dir;
    # would be nice if it only used one.
    remove_path_if_exists(newlib_build_dir)
    # In an |emerge| flow, we don't need this, but repeated |ebuild|s could
    # leave us with a dirty source directory.
    if (newlib_path / 'Makefile').exists():
      remove_path_if_exists(newlib_path / 'riscv32-unknown-elf')
      subprocess.check_call(['make', 'distclean'], cwd=newlib_path)

  build_newlib(
      rv_clang_bin=install_dir / 'bin',
      newlib_dir=newlib_path,
      newlib_build_dir=newlib_build_dir,
      install_dir=install_dir,
  )

  compiler_rt_build_dir = work_dir / 'compiler-rt-build'
  remove_path_if_exists(compiler_rt_build_dir)
  build_compiler_rt(llvm_path, compiler_rt_build_dir, install_dir)

  log_install_paths(install_dir)


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