RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 19:23:23 +01:00
Code Issues Projects Releases Wiki Activity
256a95e063
llvm-mirror/utils/llvmbuild
David Greene 125709b0ea Fix the case where the number of jobs is less than the 
number of threads.  In that case make the number of threads
equal to the number of jobs and launch one jobs on each
thread.  This makes things work like make -j.

llvm-svn: 127045
2011-03-04 23:02:52 +00:00

750 lines
30 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/python3
##===- utils/llvmbuild - Build the LLVM project ----------------*-python-*-===##
#
# The LLVM Compiler Infrastructure
#
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
#
##===----------------------------------------------------------------------===##
#
# This script builds many different flavors of the LLVM ecosystem. It
# will build LLVM, Clang, llvm-gcc, and dragonegg as well as run tests
# on them. This script is convenient to use to check builds and tests
# before committing changes to the upstream repository
#
# A typical source setup uses three trees and looks like this:
#
# official
# dragonegg
# trunk
# gcc
# trunk
# llvm
# trunk
# tools
# clang
# tags
# RELEASE_28
# tools
# clang
# llvm-gcc
# trunk
# tags
# RELEASE_28
# staging
# dragonegg
# trunk
# gcc
# trunk
# llvm
# trunk
# tools
# clang
# tags
# RELEASE_28
# tools
# clang
# llvm-gcc
# trunk
# tags
# RELEASE_28
# commit
# dragonegg
# trunk
# gcc
# trunk
# llvm
# trunk
# tools
# clang
# tags
# RELEASE_28
# tools
# clang
# llvm-gcc
# trunk
# tags
# RELEASE_28
#
# "gcc" above is the upstream FSF gcc and "gcc/trunk" refers to the
# 4.5 branch as discussed in the dragonegg build guide.
#
# In a typical workflow, the "official" tree always contains unchanged
# sources from the main LLVM project repositories. The "staging" tree
# is where local work is done. A set of changes resides there waiting
# to be moved upstream. The "commit" tree is where changes from
# "staging" make their way upstream. Individual incremental changes
# from "staging" are applied to "commit" and committed upstream after
# a successful build and test run. A successful build is one in which
# testing results in no more failures than seen in the testing of the
# "official" tree.
#
# A build may be invoked as such:
#
# llvmbuild --src=~/llvm/commit --src=~/llvm/staging
# --src=~/llvm/official --branch=trunk --branch=tags/RELEASE_28
# --build=debug --build=release --build=paranoid
# --prefix=/home/greened/install --builddir=/home/greened/build
#
# This will build the LLVM ecosystem, including LLVM, Clang, llvm-gcc,
# gcc 4.5 and dragonegg, putting build results in ~/build and
# installing tools in ~/install. llvmbuild creates separate build and
# install directories for each source/branch/build flavor. In the
# above example, llvmbuild will build debug, release and paranoid
# (debug+checks) flavors of the trunk and RELEASE_28 branches from
# each source tree (official, staging and commit) for a total of
# eighteen builds. All builds will be run in parallel.
#
# The user may control parallelism via the --jobs and --threads
# switches. --jobs tells llvmbuild the maximum total number of builds
# to activate in parallel. The user may think of it as equivalent to
# the GNU make -j switch. --threads tells llvmbuild how many worker
# threads to use to accomplish those builds. If --threads is less
# than --jobs, --threads workers will be launched and each one will
# pick a source/branch/flavor combination to build. Then llvmbuild
# will invoke GNU make with -j (--jobs / --threads) to use up the
# remaining job capacity. Once a worker is finished with a build, it
# will pick another combination off the list and start building it.
#
##===----------------------------------------------------------------------===##
import optparse
import os
import sys
import threading
import queue
import logging
import traceback
import subprocess
import re
# TODO: Use shutil.which when it is available (3.2 or later)
def find_executable(executable, path=None):
"""Try to find 'executable' in the directories listed in 'path' (a
string listing directories separated by 'os.pathsep'; defaults to
os.environ['PATH']). Returns the complete filename or None if not
found
"""
if path is None:
path = os.environ['PATH']
paths = path.split(os.pathsep)
extlist = ['']
if os.name == 'os2':
(base, ext) = os.path.splitext(executable)
# executable files on OS/2 can have an arbitrary extension, but
# .exe is automatically appended if no dot is present in the name
if not ext:
executable = executable + ".exe"
elif sys.platform == 'win32':
pathext = os.environ['PATHEXT'].lower().split(os.pathsep)
(base, ext) = os.path.splitext(executable)
if ext.lower() not in pathext:
extlist = pathext
for ext in extlist:
execname = executable + ext
if os.path.isfile(execname):
return execname
else:
for p in paths:
f = os.path.join(p, execname)
if os.path.isfile(f):
return f
else:
return None
def is_executable(fpath):
return os.path.exists(fpath) and os.access(fpath, os.X_OK)
def add_options(parser):
parser.add_option("-v", "--verbose", action="store_true",
default=False,
help=("Output informational messages"
" [default: %default]"))
parser.add_option("--src", action="append",
help=("Top-level source directory [default: %default]"))
parser.add_option("--build", action="append",
help=("Build types to run [default: %default]"))
parser.add_option("--branch", action="append",
help=("Source branch to build [default: %default]"))
parser.add_option("--cc", default=find_executable("cc"),
help=("The C compiler to use [default: %default]"))
parser.add_option("--cxx", default=find_executable("c++"),
help=("The C++ compiler to use [default: %default]"))
parser.add_option("--threads", default=4, type="int",
help=("The number of worker threads to use "
"[default: %default]"))
parser.add_option("--jobs", "-j", default=8, type="int",
help=("The number of simultaneous build jobs "
"[default: %default]"))
parser.add_option("--prefix",
help=("Root install directory [default: %default]"))
parser.add_option("--builddir",
help=("Root build directory [default: %default]"))
parser.add_option("--extra-llvm-config-flags", default="",
help=("Extra flags to pass to llvm configure [default: %default]"))
parser.add_option("--extra-llvm-gcc-config-flags", default="",
help=("Extra flags to pass to llvm-gcc configure [default: %default]"))
parser.add_option("--extra-gcc-config-flags", default="",
help=("Extra flags to pass to gcc configure [default: %default]"))
parser.add_option("--force-configure", default=False, action="store_true",
help=("Force reconfigure of all components"))
return
def check_options(parser, options, valid_builds):
# See if we're building valid flavors.
for build in options.build:
if (build not in valid_builds):
parser.error("'" + build + "' is not a valid build flavor "
+ str(valid_builds))
# See if we can find source directories.
for src in options.src:
for component in ["llvm", "llvm-gcc", "gcc", "dragonegg"]:
compsrc = src + "/" + component
if (not os.path.isdir(compsrc)):
parser.error("'" + compsrc + "' does not exist")
if (options.branch is not None):
for branch in options.branch:
if (not os.path.isdir(os.path.join(compsrc, branch))):
parser.error("'" + os.path.join(compsrc, branch)
+ "' does not exist")
# See if we can find the compilers
options.cc = find_executable(options.cc)
options.cxx = find_executable(options.cxx)
return
# Find a unique short name for the given set of paths. This searches
# back through path components until it finds unique component names
# among all given paths.
def get_path_abbrevs(paths):
# Find the number of common starting characters in the last component
# of the paths.
unique_paths = list(paths)
class NotFoundException(Exception): pass
# Find a unique component of each path.
unique_bases = unique_paths[:]
found = 0
while len(unique_paths) > 0:
bases = [os.path.basename(src) for src in unique_paths]
components = { c for c in bases }
# Account for single entry in paths.
if len(components) > 1 or len(components) == len(bases):
# We found something unique.
for c in components:
if bases.count(c) == 1:
index = bases.index(c)
unique_bases[index] = c
# Remove the corresponding path from the set under
# consideration.
unique_paths[index] = None
unique_paths = [ p for p in unique_paths if p is not None ]
unique_paths = [os.path.dirname(src) for src in unique_paths]
if len(unique_paths) > 0:
raise NotFoundException()
abbrevs = dict(zip(paths, [base for base in unique_bases]))
return abbrevs
# Given a set of unique names, find a short character sequence that
# uniquely identifies them.
def get_short_abbrevs(unique_bases):
# Find a unique start character for each path base.
my_unique_bases = unique_bases[:]
unique_char_starts = unique_bases[:]
while len(my_unique_bases) > 0:
for start, char_tuple in enumerate(zip(*[base
for base in my_unique_bases])):
chars = { c for c in char_tuple }
# Account for single path.
if len(chars) > 1 or len(chars) == len(char_tuple):
# We found something unique.
for c in chars:
if char_tuple.count(c) == 1:
index = char_tuple.index(c)
unique_char_starts[index] = start
# Remove the corresponding path from the set under
# consideration.
my_unique_bases[index] = None
my_unique_bases = [ b for b in my_unique_bases
if b is not None ]
break
if len(my_unique_bases) > 0:
raise NotFoundException()
abbrevs = [abbrev[start_index:start_index+3]
for abbrev, start_index
in zip([base for base in unique_bases],
[index for index in unique_char_starts])]
abbrevs = dict(zip(unique_bases, abbrevs))
return abbrevs
class Builder(threading.Thread):
class ExecutableNotFound(Exception): pass
class FileNotExecutable(Exception): pass
def __init__(self, work_queue, jobs,
build_abbrev, source_abbrev, branch_abbrev,
options):
super().__init__()
self.work_queue = work_queue
self.jobs = jobs
self.cc = options.cc
self.cxx = options.cxx
self.build_abbrev = build_abbrev
self.source_abbrev = source_abbrev
self.branch_abbrev = branch_abbrev
self.build_prefix = options.builddir
self.install_prefix = options.prefix
self.options = options
self.component_abbrev = dict(
llvm="llvm",
llvm_gcc="lgcc",
llvm2="llv2",
gcc="ugcc",
dagonegg="degg")
def run(self):
while True:
try:
source, branch, build = self.work_queue.get()
self.dobuild(source, branch, build)
except:
traceback.print_exc()
finally:
self.work_queue.task_done()
def execute(self, command, execdir, env, component):
prefix = self.component_abbrev[component.replace("-", "_")]
pwd = os.getcwd()
if not os.path.exists(execdir):
os.makedirs(execdir)
execenv = os.environ.copy()
for key, value in env.items():
execenv[key] = value
self.logger.debug("[" + prefix + "] " + "env " + str(env) + " "
+ " ".join(command));
try:
proc = subprocess.Popen(command,
cwd=execdir,
env=execenv,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
line = proc.stdout.readline()
while line:
self.logger.info("[" + prefix + "] "
+ str(line, "utf-8").rstrip())
line = proc.stdout.readline()
except:
traceback.print_exc()
# Get a list of C++ include directories to pass to clang.
def get_includes(self):
# Assume we're building with g++ for now.
command = [self.cxx]
command += ["-v", "-x", "c++", "/dev/null", "-fsyntax-only"]
includes = []
self.logger.debug(command)
try:
proc = subprocess.Popen(command,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
gather = False
line = proc.stdout.readline()
while line:
self.logger.debug(line)
if re.search("End of search list", str(line)) is not None:
self.logger.debug("Stop Gather")
gather = False
if gather:
includes.append(str(line, "utf-8").strip())
if re.search("#include <...> search starts", str(line)) is not None:
self.logger.debug("Start Gather")
gather = True
line = proc.stdout.readline()
except:
traceback.print_exc()
self.logger.debug(includes)
return includes
def dobuild(self, source, branch, build):
build_suffix = ""
ssabbrev = get_short_abbrevs([ab for ab in self.source_abbrev.values()])
if branch is not None:
sbabbrev = get_short_abbrevs([ab for ab in self.branch_abbrev.values()])
prefix = "[" + ssabbrev[self.source_abbrev[source]] + "-" + sbabbrev[self.branch_abbrev[branch]] + "-" + self.build_abbrev[build] + "]"
self.install_prefix += "/" + self.source_abbrev[source] + "/" + branch + "/" + build
build_suffix += self.source_abbrev[source] + "/" + branch + "/" + build
else:
prefix = "[" + ssabbrev[self.source_abbrev[source]] + "-" + self.build_abbrev[build] + "]"
self.install_prefix += "/" + self.source_abbrev[source] + "/" + build
build_suffix += "/" + self.source_abbrev[source] + "/" + build
self.logger = logging.getLogger(prefix)
self.logger.debug(self.install_prefix)
# Assume we're building with gcc for now.
cxxincludes = self.get_includes()
cxxroot = cxxincludes[0]
cxxarch = os.path.basename(cxxincludes[1])
configure_flags = dict(
llvm=dict(debug=["--prefix=" + self.install_prefix,
"--with-extra-options=-Werror",
"--with-cxx-include-root=" + cxxroot,
"--with-cxx-include-arch=" + cxxarch],
release=["--prefix=" + self.install_prefix,
"--with-extra-options=-Werror",
"--enable-optimized",
"--with-cxx-include-root=" + cxxroot,
"--with-cxx-include-arch=" + cxxarch],
paranoid=["--prefix=" + self.install_prefix,
"--with-extra-options=-Werror",
"--enable-expensive-checks",
"--with-cxx-include-root=" + cxxroot,
"--with-cxx-include-arch=" + cxxarch]),
llvm_gcc=dict(debug=["--prefix=" + self.install_prefix,
"--enable-checking",
"--program-prefix=llvm-",
"--enable-llvm=" + self.build_prefix + "/llvm/" + build_suffix,
# Fortran install seems to be broken.
# "--enable-languages=c,c++,fortran"],
"--enable-languages=c,c++"],
release=["--prefix=" + self.install_prefix,
"--program-prefix=llvm-",
"--enable-llvm=" + self.build_prefix + "/llvm/" + build_suffix,
# Fortran install seems to be broken.
# "--enable-languages=c,c++,fortran"],
"--enable-languages=c,c++"],
paranoid=["--prefix=" + self.install_prefix,
"--enable-checking",
"--program-prefix=llvm-",
"--enable-llvm=" + self.build_prefix + "/llvm/" + build_suffix,
# Fortran install seems to be broken.
# "--enable-languages=c,c++,fortran"]),
"--enable-languages=c,c++"]),
llvm2=dict(debug=["--prefix=" + self.install_prefix,
"--with-extra-options=-Werror",
"--with-llvmgccdir=" + self.install_prefix + "/bin",
"--with-cxx-include-root=" + cxxroot,
"--with-cxx-include-arch=" + cxxarch],
release=["--prefix=" + self.install_prefix,
"--with-extra-options=-Werror",
"--enable-optimized",
"--with-llvmgccdir=" + self.install_prefix + "/bin",
"--with-cxx-include-root=" + cxxroot,
"--with-cxx-include-arch=" + cxxarch],
paranoid=["--prefix=" + self.install_prefix,
"--with-extra-options=-Werror",
"--enable-expensive-checks",
"--with-llvmgccdir=" + self.install_prefix + "/bin",
"--with-cxx-include-root=" + cxxroot,
"--with-cxx-include-arch=" + cxxarch]),
gcc=dict(debug=["--prefix=" + self.install_prefix,
"--enable-checking"],
release=["--prefix=" + self.install_prefix],
paranoid=["--prefix=" + self.install_prefix,
"--enable-checking"]),
dragonegg=dict(debug=[],
release=[],
paranoid=[]))
configure_env = dict(
llvm=dict(debug=dict(CC=self.cc,
CXX=self.cxx),
release=dict(CC=self.cc,
CXX=self.cxx),
paranoid=dict(CC=self.cc,
CXX=self.cxx)),
llvm_gcc=dict(debug=dict(CC=self.cc,
CXX=self.cxx),
release=dict(CC=self.cc,
CXX=self.cxx),
paranoid=dict(CC=self.cc,
CXX=self.cxx)),
llvm2=dict(debug=dict(CC=self.cc,
CXX=self.cxx),
release=dict(CC=self.cc,
CXX=self.cxx),
paranoid=dict(CC=self.cc,
CXX=self.cxx)),
gcc=dict(debug=dict(CC=self.cc,
CXX=self.cxx),
release=dict(CC=self.cc,
CXX=self.cxx),
paranoid=dict(CC=self.cc,
CXX=self.cxx)),
dragonegg=dict(debug=dict(CC=self.cc,
CXX=self.cxx),
release=dict(CC=self.cc,
CXX=self.cxx),
paranoid=dict(CC=self.cc,
CXX=self.cxx)))
make_flags = dict(
llvm=dict(debug=["-j" + str(self.jobs)],
release=["-j" + str(self.jobs)],
paranoid=["-j" + str(self.jobs)]),
llvm_gcc=dict(debug=["-j" + str(self.jobs),
"bootstrap"],
release=["-j" + str(self.jobs),
"bootstrap"],
paranoid=["-j" + str(self.jobs),
"bootstrap"]),
llvm2=dict(debug=["-j" + str(self.jobs)],
release=["-j" + str(self.jobs)],
paranoid=["-j" + str(self.jobs)]),
gcc=dict(debug=["-j" + str(self.jobs),
"bootstrap"],
release=["-j" + str(self.jobs),
"bootstrap"],
paranoid=["-j" + str(self.jobs),
"bootstrap"]),
dragonegg=dict(debug=["-j" + str(self.jobs)],
release=["-j" + str(self.jobs)],
paranoid=["-j" + str(self.jobs)]))
make_env = dict(
llvm=dict(debug=dict(),
release=dict(),
paranoid=dict()),
llvm_gcc=dict(debug=dict(),
release=dict(),
paranoid=dict()),
llvm2=dict(debug=dict(),
release=dict(),
paranoid=dict()),
gcc=dict(debug=dict(),
release=dict(),
paranoid=dict()),
dragonegg=dict(debug=dict(GCC=self.install_prefix + "/bin/gcc",
LLVM_CONFIG=self.install_prefix + "/bin/llvm-config"),
release=dict(GCC=self.install_prefix + "/bin/gcc",
LLVM_CONFIG=self.install_prefix + "/bin/llvm-config"),
paranoid=dict(GCC=self.install_prefix + "/bin/gcc",
LLVM_CONFIG=self.install_prefix + "/bin/llvm-config")))
make_install_flags = dict(
llvm=dict(debug=["install"],
release=["install"],
paranoid=["install"]),
llvm_gcc=dict(debug=["install"],
release=["install"],
paranoid=["install"]),
llvm2=dict(debug=["install"],
release=["install"],
paranoid=["install"]),
gcc=dict(debug=["install"],
release=["install"],
paranoid=["install"]),
dragonegg=dict(debug=["install"],
release=["install"],
paranoid=["install"]))
make_install_env = dict(
llvm=dict(debug=dict(),
release=dict(),
paranoid=dict()),
llvm_gcc=dict(debug=dict(),
release=dict(),
paranoid=dict()),
llvm2=dict(debug=dict(),
release=dict(),
paranoid=dict()),
gcc=dict(debug=dict(),
release=dict(),
paranoid=dict()),
dragonegg=dict(debug=dict(),
release=dict(),
paranoid=dict()))
make_check_flags = dict(
llvm=dict(debug=["check"],
release=["check"],
paranoid=["check"]),
llvm_gcc=dict(debug=["check"],
release=["check"],
paranoid=["check"]),
llvm2=dict(debug=["check"],
release=["check"],
paranoid=["check"]),
gcc=dict(debug=["check"],
release=["check"],
paranoid=["check"]),
dragonegg=dict(debug=["check"],
release=["check"],
paranoid=["check"]))
make_check_env = dict(
llvm=dict(debug=dict(),
release=dict(),
paranoid=dict()),
llvm_gcc=dict(debug=dict(),
release=dict(),
paranoid=dict()),
llvm2=dict(debug=dict(),
release=dict(),
paranoid=dict()),
gcc=dict(debug=dict(),
release=dict(),
paranoid=dict()),
dragonegg=dict(debug=dict(),
release=dict(),
paranoid=dict()))
for component in ["llvm", "llvm-gcc", "llvm2", "gcc", "dragonegg"]:
comp = component[:]
srcdir = source + "/" + comp.rstrip("2")
builddir = self.build_prefix + "/" + comp + "/" + build_suffix
installdir = self.install_prefix
if (branch is not None):
srcdir += "/" + branch
comp_key = comp.replace("-", "_")
config_args = configure_flags[comp_key][build][:]
config_args.extend(getattr(self.options,
"extra_" + comp_key
+ "_config_flags").split())
self.logger.info("Configuring " + component + " in " + builddir)
self.configure(component, srcdir, builddir,
config_args,
configure_env[comp_key][build])
self.logger.info("Building " + component + " in " + builddir)
self.make(component, srcdir, builddir,
make_flags[comp_key][build],
make_env[comp_key][build])
self.logger.info("Installing " + component + " in " + installdir)
self.make(component, srcdir, builddir,
make_install_flags[comp_key][build],
make_install_env[comp_key][build])
self.logger.info("Testing " + component + " in " + builddir)
self.make(component, srcdir, builddir,
make_check_flags[comp_key][build],
make_check_env[comp_key][build])
def configure(self, component, srcdir, builddir, flags, env):
self.logger.debug("Configure " + str(flags) + " " + str(srcdir) + " -> "
+ str(builddir))
configure_files = dict(
llvm=[(srcdir + "/configure", builddir + "/Makefile")],
llvm_gcc=[(srcdir + "/configure", builddir + "/Makefile"),
(srcdir + "/gcc/configure", builddir + "/gcc/Makefile")],
llvm2=[(srcdir + "/configure", builddir + "/Makefile")],
gcc=[(srcdir + "/configure", builddir + "/Makefile"),
(srcdir + "/gcc/configure", builddir + "/gcc/Makefile")],
dragonegg=[()])
doconfig = False
for conf, mf in configure_files[component.replace("-", "_")]:
if not os.path.exists(conf):
return
if os.path.exists(conf) and os.path.exists(mf):
confstat = os.stat(conf)
makestat = os.stat(mf)
if confstat.st_mtime > makestat.st_mtime:
doconfig = True
break
else:
doconfig = True
break
if not doconfig and not self.options.force_configure:
return
program = srcdir + "/configure"
if not is_executable(program):
return
args = [program]
args += ["--verbose"]
args += flags
self.execute(args, builddir, env, component)
def make(self, component, srcdir, builddir, flags, env):
program = find_executable("make")
if program is None:
raise ExecutableNotFound
if not is_executable(program):
raise FileNotExecutable
args = [program]
args += flags
self.execute(args, builddir, env, component)
# Global constants
build_abbrev = dict(debug="dbg", release="opt", paranoid="par")
# Parse options
parser = optparse.OptionParser(version="%prog 1.0")
add_options(parser)
(options, args) = parser.parse_args()
check_options(parser, options, build_abbrev.keys());
if options.verbose:
logging.basicConfig(level=logging.DEBUG,
format='%(name)-13s: %(message)s')
else:
logging.basicConfig(level=logging.INFO,
format='%(name)-13s: %(message)s')
source_abbrev = get_path_abbrevs(set(options.src))
branch_abbrev = get_path_abbrevs(set(options.branch))
work_queue = queue.Queue()
jobs = options.jobs // options.threads
if jobs == 0:
jobs = 1
numthreads = options.threads
if jobs < numthreads:
numthreads = jobs
jobs = 1
for t in range(numthreads):
builder = Builder(work_queue, jobs,
build_abbrev, source_abbrev, branch_abbrev,
options)
builder.daemon = True
builder.start()
for build in set(options.build):
for source in set(options.src):
if options.branch is not None:
for branch in set(options.branch):
work_queue.put((source, branch, build))
else:
work_queue.put((source, None, build))
work_queue.join()
Reference in New Issue View Git Blame Copy Permalink