This is an archive of the discontinued LLVM Phabricator instance.

Differential D44787

Migrate dockerfiles to use multi-stage builds.
ClosedPublic

Authored by ilya-biryukov on Mar 22 2018, 9:29 AM.

Details

Reviewers
mehdi_amini
klimek
sammccall
Commits
rGd95020108c48: Migrate dockerfiles to use multi-stage builds.
rL328503: Migrate dockerfiles to use multi-stage builds.
Summary

We previously emulated multi-staged builds using two dockerfiles,
native support from Docker allows us to merge them into one,
simplifying our scripts.

For more details about multi-stage builds, see:
https://docs.docker.com/develop/develop-images/multistage-build/

Diff Detail

Repository
rL LLVM

Event Timeline

ilya-biryukov created this revision.Mar 22 2018, 9:29 AM
Harbormaster completed remote builds in B16348: Diff 139457.Mar 22 2018, 9:29 AM
Herald added a subscriber: llvm-commits. · View Herald TranscriptMar 22 2018, 9:29 AM
ilya-biryukov added a reviewer: sammccall.Mar 26 2018, 4:57 AM
sammccall accepted this revision.Mar 26 2018, 6:54 AM
sammccall added inline comments.
docs/Docker.rst
64 ↗(On Diff #139457)

an incomplete dockerfile

This revision is now accepted and ready to land.Mar 26 2018, 6:54 AM
Closed by commit rL328503: Migrate dockerfiles to use multi-stage builds. (authored by ibiryukov). · Explain WhyMar 26 2018, 8:15 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
docs/
56 lines
utils/
docker/
16 lines
debian8/
58 lines
build/
55 lines
release/
21 lines
example/
37 lines
build/
28 lines
release/
24 lines
nvidia-cuda/
31 lines
build/
31 lines
release/
23 lines
scripts/
11 lines

Diff 139792

llvm/trunk/docs/Docker.rst

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
Overview Overview
======== ========
The ``llvm/utils/docker`` folder contains Dockerfiles and simple bash scripts to The ``llvm/utils/docker`` folder contains Dockerfiles and simple bash scripts to
serve as a basis for anyone who wants to create their own Docker image with serve as a basis for anyone who wants to create their own Docker image with
LLVM components, compiled from sources. The sources are checked out from the LLVM components, compiled from sources. The sources are checked out from the
upstream svn repository when building the image. upstream svn repository when building the image.
Inside each subfolder we host Dockerfiles for two images: The resulting image contains only the requested LLVM components and a few extra
packages to make the image minimally useful for C++ development, e.g. libstdc++
and binutils.
- ``build/`` image is used to compile LLVM, it installs a system compiler and all The interface to run the build is ``build_docker_image.sh`` script. It accepts a
build dependencies of LLVM. After the build process is finished, the build list of LLVM repositories to checkout and arguments for CMake invocation.
image will have an archive with compiled components at ``/tmp/clang.tar.gz``.
- ``release/`` image usually only contains LLVM components, compiled by the
``build/`` image, and also libstdc++ and binutils to make image minimally
useful for C++ development. The assumption is that you usually want clang to
be one of the provided components.
To build both of those images, use ``build_docker_image.sh`` script.
It will checkout LLVM sources and build clang in the ``build`` container, copy results
of the build to the local filesystem and then build the ``release`` container using
those. The ``build_docker_image.sh`` accepts a list of LLVM repositories to
checkout, and arguments for CMake invocation.
If you want to write your own docker image, start with an ``example/`` subfolder. If you want to write your own docker image, start with an ``example/`` subfolder.
It provides incomplete Dockerfiles with (very few) FIXMEs explaining the steps It provides an incomplete Dockerfile with (very few) FIXMEs explaining the steps
you need to take in order to make your Dockerfiles functional. you need to take in order to make your Dockerfiles functional.
Usage Usage
===== =====
The ``llvm/utils/build_docker_image.sh`` script provides a rather high degree of The ``llvm/utils/build_docker_image.sh`` script provides a rather high degree of
control on how to run the build. It allows you to specify the projects to control on how to run the build. It allows you to specify the projects to
checkout from svn and provide a list of CMake arguments to use during when checkout from svn and provide a list of CMake arguments to use during when
building LLVM inside docker container. building LLVM inside docker container.
Show All 23 Lines.. code-block:: bash
--source debian8 \ --source debian8 \
--docker-repository clang-debian8 --docker-tag "staging" \ --docker-repository clang-debian8 --docker-tag "staging" \
-p clang -i stage2-install-clang -i stage2-install-clang-headers \ -p clang -i stage2-install-clang -i stage2-install-clang-headers \
-- \ -- \
-DLLVM_TARGETS_TO_BUILD=Native -DCMAKE_BUILD_TYPE=Release \ -DLLVM_TARGETS_TO_BUILD=Native -DCMAKE_BUILD_TYPE=Release \
-DBOOTSTRAP_CMAKE_BUILD_TYPE=Release \ -DBOOTSTRAP_CMAKE_BUILD_TYPE=Release \
-DCLANG_ENABLE_BOOTSTRAP=ON -DCLANG_BOOTSTRAP_TARGETS="install-clang;install-clang-headers" -DCLANG_ENABLE_BOOTSTRAP=ON -DCLANG_BOOTSTRAP_TARGETS="install-clang;install-clang-headers"
This will produce two images, a release image ``clang-debian8:staging`` and a This will produce a new image ``clang-debian8:staging`` from the latest
build image ``clang-debian8-build:staging`` from the latest upstream revision. upstream revision.
After the image is built you can run bash inside a container based on your After the image is built you can run bash inside a container based on your image
image like this: like this:
.. code-block:: bash .. code-block:: bash
docker run -ti clang-debian8:staging bash docker run -ti clang-debian8:staging bash
Now you can run bash commands as you normally would: Now you can run bash commands as you normally would:
.. code-block:: bash .. code-block:: bash
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines.. code-block:: bash
--branch branches/google/stable \ --branch branches/google/stable \
-p clang -i install-clang -i install-clang-headers \ -p clang -i install-clang -i install-clang-headers \
-- \ -- \
-DCMAKE_BUILD_TYPE=Release -DCMAKE_BUILD_TYPE=Release
Minimizing docker image size Minimizing docker image size
============================ ============================
Due to Docker restrictions we use two images (i.e., build and release folders) Due to how Docker's filesystem works, all intermediate writes are persisted in
for the release image to be as small as possible. It's much easier to achieve the resulting image, even if they are removed in the following commands.
that using two images, because Docker would store a filesystem layer for each To minimize the resulting image size we use `multi-stage Docker builds
command in the Dockerfile, i.e. if you install some packages in one command, <https://docs.docker.com/develop/develop-images/multistage-build/>`_.
then remove those in a separate command, the size of the resulting image will Internally Docker builds two images. The first image does all the work: installs
still be proportinal to the size of an image with installed packages. build dependencies, checks out LLVM source code, compiles LLVM, etc.
Therefore, we strive to provide a very simple release image which only copies The first image is only used during build and does not have a descriptive name,
compiled clang and does not do anything else. i.e. it is only accessible via the hash value after the build is finished.
The second image is our resulting image. It contains only the built binaries
Docker 1.13 added a ``--squash`` flag that allows to flatten the layers of the and not any build dependencies. It is also accessible via a descriptive name
image, i.e. remove the parts that were actually deleted. That is an easier way (specified by -d and -t flags).
to produce the smallest images possible by using just a single image. We do not
use it because as of today the flag is in experimental stage and not everyone
may have the latest docker version available. When the flag is out of
experimental stage, we should investigate replacing two images approach with
just a single image, built using ``--squash`` flag.

llvm/trunk/utils/docker/build_docker_image.sh

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Lines
if [ "$CHECKSUMS_FILE" != "" ]; then if [ "$CHECKSUMS_FILE" != "" ]; then
cp "$CHECKSUMS_FILE" "$BUILD_DIR/checksums/checksums.txt" cp "$CHECKSUMS_FILE" "$BUILD_DIR/checksums/checksums.txt"
fi fi
if [ "$DOCKER_TAG" != "" ]; then if [ "$DOCKER_TAG" != "" ]; then
DOCKER_TAG=":$DOCKER_TAG" DOCKER_TAG=":$DOCKER_TAG"
fi fi
echo "Building from $IMAGE_SOURCE" echo "Building ${DOCKER_REPOSITORY}${DOCKER_TAG} from $IMAGE_SOURCE"
echo "Building $DOCKER_REPOSITORY-build$DOCKER_TAG" docker build -t "${DOCKER_REPOSITORY}${DOCKER_TAG}" \
docker build -t "$DOCKER_REPOSITORY-build$DOCKER_TAG" \
--build-arg "buildscript_args=$BUILDSCRIPT_ARGS" \ --build-arg "buildscript_args=$BUILDSCRIPT_ARGS" \
-f "$BUILD_DIR/$IMAGE_SOURCE/build/Dockerfile" \ -f "$BUILD_DIR/$IMAGE_SOURCE/Dockerfile" \
"$BUILD_DIR" "$BUILD_DIR"
echo "Copying clang installation to release image sources"
docker run -v "$BUILD_DIR/$IMAGE_SOURCE:/workspace" "$DOCKER_REPOSITORY-build$DOCKER_TAG" \
cp /tmp/clang.tar.gz /workspace/release
echo "Building release image"
docker build -t "${DOCKER_REPOSITORY}${DOCKER_TAG}" \
"$BUILD_DIR/$IMAGE_SOURCE/release"
echo "Done" echo "Done"

llvm/trunk/utils/docker/debian8/Dockerfile

#===- llvm/utils/docker/debian8/build/Dockerfile -------------------------===//
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
#===----------------------------------------------------------------------===//
# Stage 1. Check out LLVM source code and run the build.
FROM launcher.gcr.io/google/debian8:latest as builder
LABEL maintainer "LLVM Developers"
# Install build dependencies of llvm.
# First, Update the apt's source list and include the sources of the packages.
RUN grep deb /etc/apt/sources.list | \
sed 's/^deb/deb-src /g' >> /etc/apt/sources.list
# Install compiler, python and subversion.
RUN apt-get update && \
apt-get install -y --no-install-recommends ca-certificates gnupg \
build-essential python wget subversion unzip && \
rm -rf /var/lib/apt/lists/*
# Install a newer ninja release. It seems the older version in the debian repos
# randomly crashes when compiling llvm.
RUN wget "https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-linux.zip" && \
echo "d2fea9ff33b3ef353161ed906f260d565ca55b8ca0568fa07b1d2cab90a84a07 ninja-linux.zip" \
| sha256sum -c && \
unzip ninja-linux.zip -d /usr/local/bin && \
rm ninja-linux.zip
# Import public key required for verifying signature of cmake download.
RUN gpg --keyserver hkp://pgp.mit.edu --recv 0x2D2CEF1034921684
# Download, verify and install cmake version that can compile clang into /usr/local.
# (Version in debian8 repos is is too old)
RUN mkdir /tmp/cmake-install && cd /tmp/cmake-install && \
wget "https://cmake.org/files/v3.7/cmake-3.7.2-SHA-256.txt.asc" && \
wget "https://cmake.org/files/v3.7/cmake-3.7.2-SHA-256.txt" && \
gpg --verify cmake-3.7.2-SHA-256.txt.asc cmake-3.7.2-SHA-256.txt && \
wget "https://cmake.org/files/v3.7/cmake-3.7.2-Linux-x86_64.tar.gz" && \
( grep "cmake-3.7.2-Linux-x86_64.tar.gz" cmake-3.7.2-SHA-256.txt | \
sha256sum -c - ) && \
tar xzf cmake-3.7.2-Linux-x86_64.tar.gz -C /usr/local --strip-components=1 && \
cd / && rm -rf /tmp/cmake-install
ADD checksums /tmp/checksums
ADD scripts /tmp/scripts
# Arguments passed to build_install_clang.sh.
ARG buildscript_args
# Run the build. Results of the build will be available at /tmp/clang-install/.
RUN /tmp/scripts/build_install_llvm.sh ${buildscript_args}
# Stage 2. Produce a minimal release image with build results.
FROM launcher.gcr.io/google/debian8:latest
LABEL maintainer "LLVM Developers"
# Install packages for minimal useful image.
RUN apt-get update && \
apt-get install -y --no-install-recommends libstdc++-4.9-dev binutils && \
rm -rf /var/lib/apt/lists/*
# Copy build results of stage 1 to /usr/local.
COPY --from=builder /tmp/clang-install/ /usr/local/

llvm/trunk/utils/docker/debian8/build/Dockerfile

#===- llvm/utils/docker/debian8/build/Dockerfile -------------------------===//
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
#===----------------------------------------------------------------------===//
# Produces an image that compiles and archives clang, based on debian8.
FROM launcher.gcr.io/google/debian8:latest
LABEL maintainer "LLVM Developers"
# Install build dependencies of llvm.
# First, Update the apt's source list and include the sources of the packages.
RUN grep deb /etc/apt/sources.list | \
sed 's/^deb/deb-src /g' >> /etc/apt/sources.list
# Install compiler, python and subversion.
RUN apt-get update && \
apt-get install -y --no-install-recommends ca-certificates gnupg \
build-essential python wget subversion unzip && \
rm -rf /var/lib/apt/lists/*
# Install a newer ninja release. It seems the older version in the debian repos
# randomly crashes when compiling llvm.
RUN wget "https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-linux.zip" && \
echo "d2fea9ff33b3ef353161ed906f260d565ca55b8ca0568fa07b1d2cab90a84a07 ninja-linux.zip" \
| sha256sum -c && \
unzip ninja-linux.zip -d /usr/local/bin && \
rm ninja-linux.zip
# Import public key required for verifying signature of cmake download.
RUN gpg --keyserver hkp://pgp.mit.edu --recv 0x2D2CEF1034921684
# Download, verify and install cmake version that can compile clang into /usr/local.
# (Version in debian8 repos is is too old)
RUN mkdir /tmp/cmake-install && cd /tmp/cmake-install && \
wget "https://cmake.org/files/v3.7/cmake-3.7.2-SHA-256.txt.asc" && \
wget "https://cmake.org/files/v3.7/cmake-3.7.2-SHA-256.txt" && \
gpg --verify cmake-3.7.2-SHA-256.txt.asc cmake-3.7.2-SHA-256.txt && \
wget "https://cmake.org/files/v3.7/cmake-3.7.2-Linux-x86_64.tar.gz" && \
( grep "cmake-3.7.2-Linux-x86_64.tar.gz" cmake-3.7.2-SHA-256.txt | \
sha256sum -c - ) && \
tar xzf cmake-3.7.2-Linux-x86_64.tar.gz -C /usr/local --strip-components=1 && \
cd / && rm -rf /tmp/cmake-install
ADD checksums /tmp/checksums
ADD scripts /tmp/scripts
# Arguments passed to build_install_clang.sh.
ARG buildscript_args
# Run the build. Results of the build will be available as /tmp/clang.tar.gz.
RUN /tmp/scripts/build_install_llvm.sh ${buildscript_args}

llvm/trunk/utils/docker/debian8/release/Dockerfile

#===- llvm/utils/docker/debian8/release/Dockerfile -----------------------===//
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
#===----------------------------------------------------------------------===//
# A release image, containing clang installation, produced by the 'build/' image
# and adding libstdc++ and binutils.
FROM launcher.gcr.io/google/debian8:latest
LABEL maintainer "LLVM Developers"
# Install packages for minimal useful image.
RUN apt-get update && \
apt-get install -y --no-install-recommends libstdc++-4.9-dev binutils && \
rm -rf /var/lib/apt/lists/*
# Unpack clang installation into this image.
ADD clang.tar.gz /usr/local/

llvm/trunk/utils/docker/example/Dockerfile

#===- llvm/utils/docker/example/build/Dockerfile -------------------------===//
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
#===----------------------------------------------------------------------===//
# This is an example Dockerfile to build an image that compiles clang.
# Replace FIXMEs to prepare your own image.
# Stage 1. Check out LLVM source code and run the build.
# FIXME: Replace 'ubuntu' with your base image
FROM ubuntu as builder
# FIXME: Change maintainer name
LABEL maintainer "Maintainer <maintainer@email>"
# FIXME: Install llvm/clang build dependencies here. Including compiler to
# build stage1, cmake, subversion, ninja, etc.
ADD checksums /tmp/checksums
ADD scripts /tmp/scripts
# Arguments passed to build_install_clang.sh.
ARG buildscript_args
# Run the build. Results of the build will be available as /tmp/clang-install.
RUN /tmp/scripts/build_install_llvm.sh ${buildscript_args}
# Stage 2. Produce a minimal release image with build results.
# FIXME: Replace 'ubuntu' with your base image.
FROM ubuntu
# FIXME: Change maintainer name.
LABEL maintainer "Maintainer <maintainer@email>"
# FIXME: Install all packages you want to have in your release container.
# A minimal useful installation should include at least libstdc++ and binutils.
# Copy build results of stage 1 to /usr/local.
COPY --from=builder /tmp/clang-install/ /usr/local/

llvm/trunk/utils/docker/example/build/Dockerfile

#===- llvm/utils/docker/example/build/Dockerfile -------------------------===//
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
#===----------------------------------------------------------------------===//
# This is an example Dockerfile to build an image that compiles clang.
# Replace FIXMEs to prepare your own image.
# FIXME: Replace 'ubuntu' with your base image
FROM ubuntu
# FIXME: Change maintainer name
LABEL maintainer "Maintainer <maintainer@email>"
# FIXME: Install llvm/clang build dependencies. Including compiler to
# build stage1, cmake, subversion, ninja, etc.
ADD checksums /tmp/checksums
ADD scripts /tmp/scripts
# Arguments passed to build_install_clang.sh.
ARG buildscript_args
# Run the build. Results of the build will be available as /tmp/clang.tar.gz.
RUN /tmp/scripts/build_install_llvm.sh ${buildscript_args}

llvm/trunk/utils/docker/example/release/Dockerfile

#===- llvm/utils/docker/example/release/Dockerfile -----------------------===//
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
#===----------------------------------------------------------------------===//
# An image that unpacks a clang installation, compiled by the 'build/'
# container.
# Replace FIXMEs to prepare your own image.
# FIXME: Replace 'ubuntu' with your base image.
FROM ubuntu
# FIXME: Change maintainer name.
LABEL maintainer "Maintainer <maintainer@email>"
# FIXME: Install all packages you want to have in your release container.
# A minimal useful installation must include libstdc++ and binutils.
# Unpack clang installation into this container.
# It is copied to this directory by build_docker_image.sh script.
ADD clang.tar.gz /usr/local/

llvm/trunk/utils/docker/nvidia-cuda/Dockerfile

#===- llvm/utils/docker/nvidia-cuda/build/Dockerfile ---------------------===//
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
#===----------------------------------------------------------------------===//
# Stage 1. Check out LLVM source code and run the build.
FROM nvidia/cuda:8.0-devel as builder
LABEL maintainer "LLVM Developers"
# Install llvm build dependencies.
RUN apt-get update && \
apt-get install -y --no-install-recommends ca-certificates cmake python \
subversion ninja-build && \
rm -rf /var/lib/apt/lists/*
ADD checksums /tmp/checksums
ADD scripts /tmp/scripts
# Arguments passed to build_install_clang.sh.
ARG buildscript_args
# Run the build. Results of the build will be available at /tmp/clang-install/.
RUN /tmp/scripts/build_install_llvm.sh ${buildscript_args}
# Stage 2. Produce a minimal release image with build results.
FROM nvidia/cuda:8.0-devel
LABEL maintainer "LLVM Developers"
# Copy clang installation into this container.
COPY --from=builder /tmp/clang-install/ /usr/local/
# C++ standard library and binutils are already included in the base package.

llvm/trunk/utils/docker/nvidia-cuda/build/Dockerfile

#===- llvm/utils/docker/nvidia-cuda/build/Dockerfile ---------------------===//
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
#===----------------------------------------------------------------------===//
# Produces an image that compiles and archives clang, based on nvidia/cuda
# image.
FROM nvidia/cuda:8.0-devel
LABEL maintainer "LLVM Developers"
# Arguments to pass to build_install_clang.sh.
ARG buildscript_args
# Install llvm build dependencies.
RUN apt-get update && \
apt-get install -y --no-install-recommends ca-certificates cmake python \
subversion ninja-build && \
rm -rf /var/lib/apt/lists/*
ADD checksums /tmp/checksums
ADD scripts /tmp/scripts
# Arguments passed to build_install_clang.sh.
ARG buildscript_args
# Run the build. Results of the build will be available as /tmp/clang.tar.gz.
RUN /tmp/scripts/build_install_llvm.sh ${buildscript_args}

llvm/trunk/utils/docker/nvidia-cuda/release/Dockerfile

#===- llvm/utils/docker/nvidia-cuda/release/Dockerfile -------------------===//
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
#===----------------------------------------------------------------------===//
# This is an example Dockerfile that copies a clang installation, compiled
# by the 'build/' container into a fresh docker image to get a container of
# minimal size.
# Replace FIXMEs to prepare a new Dockerfile.
# FIXME: Replace 'ubuntu' with your base image.
FROM nvidia/cuda:8.0-devel
# FIXME: Change maintainer name.
LABEL maintainer "LLVM Developers"
# Unpack clang installation into this container.
ADD clang.tar.gz /usr/local/
# C++ standard library and binutils are already included in the base package.

llvm/trunk/utils/docker/scripts/build_install_llvm.sh

Show All 10 Lines
set -e set -e
function show_usage() { function show_usage() {
cat << EOF cat << EOF
Usage: build_install_llvm.sh [options] -- [cmake-args] Usage: build_install_llvm.sh [options] -- [cmake-args]
Checkout svn sources and run cmake with the specified arguments. Used Checkout svn sources and run cmake with the specified arguments. Used
inside docker container. inside docker container.
Passes additional -DCMAKE_INSTALL_PREFIX and archives the contents of Passes additional -DCMAKE_INSTALL_PREFIX and puts the build results into
the directory to /tmp/clang.tar.gz. /tmp/clang-install/ directory.
Available options: Available options:
-h|--help show this help message -h|--help show this help message
-b|--branch svn branch to checkout, i.e. 'trunk', -b|--branch svn branch to checkout, i.e. 'trunk',
'branches/release_40' 'branches/release_40'
(default: 'trunk') (default: 'trunk')
-r|--revision svn revision to checkout -r|--revision svn revision to checkout
-c|--cherrypick revision to cherry-pick. Can be specified multiple times. -c|--cherrypick revision to cherry-pick. Can be specified multiple times.
▲ Show 20 Lines • Show All 210 Lines • ▼ Show 20 Linescmake -GNinja \
-DCMAKE_INSTALL_PREFIX="$CLANG_INSTALL_DIR" \ -DCMAKE_INSTALL_PREFIX="$CLANG_INSTALL_DIR" \
-DLLVM_ENABLE_PROJECTS="$CMAKE_LLVM_ENABLE_PROJECTS" \ -DLLVM_ENABLE_PROJECTS="$CMAKE_LLVM_ENABLE_PROJECTS" \
$CMAKE_ARGS \ $CMAKE_ARGS \
"$CLANG_BUILD_DIR/src/llvm" "$CLANG_BUILD_DIR/src/llvm"
ninja $CMAKE_INSTALL_TARGETS ninja $CMAKE_INSTALL_TARGETS
popd popd
# Pack the installed clang into an archive.
echo "Archiving clang installation to /tmp/clang.tar.gz"
cd "$CLANG_INSTALL_DIR"
tar -czf /tmp/clang.tar.gz *
# Cleanup. # Cleanup.
rm -rf "$CLANG_BUILD_DIR" "$CLANG_INSTALL_DIR" rm -rf "$CLANG_BUILD_DIR"
echo "Done" echo "Done"
llvm/trunk/utils/docker/nvidia-cuda/build/Dockerfile