2 # Copyright 2017 The Rust Project Developers. See the COPYRIGHT
3 # file at the top-level directory of this distribution and at
4 # http://rust-lang.org/COPYRIGHT.
6 # Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
7 # http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
8 # <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
9 # option. This file may not be copied, modified, or distributed
10 # except according to those terms.
12 # ignore-tidy-linelength
14 from __future__ import absolute_import, division, print_function
17 rust_dir = os.path.dirname(os.path.abspath(__file__))
18 rust_dir = os.path.dirname(rust_dir)
19 rust_dir = os.path.dirname(rust_dir)
20 sys.path.append(os.path.join(rust_dir, "src", "bootstrap"))
25 def __init__(self, name, rustbuild, desc, value):
27 self.rustbuild = rustbuild
36 options.append(Option(*args, value=False))
40 options.append(Option(*args, value=True))
43 o("debug", "rust.debug", "debug mode; disables optimization unless `--enable-optimize` given")
44 o("docs", "build.docs", "build standard library documentation")
45 o("compiler-docs", "build.compiler-docs", "build compiler documentation")
46 o("optimize-tests", "rust.optimize-tests", "build tests with optimizations")
47 o("experimental-parallel-queries", "rust.experimental-parallel-queries", "build rustc with experimental parallelization")
48 o("test-miri", "rust.test-miri", "run miri's test suite")
49 o("debuginfo-tests", "rust.debuginfo-tests", "build tests with debugger metadata")
50 o("verbose-tests", "rust.verbose-tests", "enable verbose output when running tests")
51 o("ccache", "llvm.ccache", "invoke gcc/clang via ccache to reuse object files between builds")
52 o("sccache", None, "invoke gcc/clang via sccache to reuse object files between builds")
53 o("local-rust", None, "use an installed rustc rather than downloading a snapshot")
54 v("local-rust-root", None, "set prefix for local rust binary")
55 o("local-rebuild", "build.local-rebuild", "assume local-rust matches the current version, for rebuilds; implies local-rust, and is implied if local-rust already matches the current version")
56 o("llvm-static-stdcpp", "llvm.static-libstdcpp", "statically link to libstdc++ for LLVM")
57 o("llvm-link-shared", "llvm.link-shared", "prefer shared linking to LLVM (llvm-config --link-shared)")
58 o("rpath", "rust.rpath", "build rpaths into rustc itself")
59 o("llvm-version-check", "llvm.version-check", "check if the LLVM version is supported, build anyway")
60 o("codegen-tests", "rust.codegen-tests", "run the src/test/codegen tests")
61 o("option-checking", None, "complain about unrecognized options in this configure script")
62 o("ninja", "llvm.ninja", "build LLVM using the Ninja generator (for MSVC, requires building in the correct environment)")
63 o("locked-deps", "build.locked-deps", "force Cargo.lock to be up to date")
64 o("vendor", "build.vendor", "enable usage of vendored Rust crates")
65 o("sanitizers", "build.sanitizers", "build the sanitizer runtimes (asan, lsan, msan, tsan)")
66 o("dist-src", "rust.dist-src", "when building tarballs enables building a source tarball")
67 o("cargo-openssl-static", "build.openssl-static", "static openssl in cargo")
68 o("profiler", "build.profiler", "build the profiler runtime")
69 o("emscripten", None, "compile the emscripten backend as well as LLVM")
70 o("full-tools", None, "enable all tools")
72 # Optimization and debugging options. These may be overridden by the release
74 o("optimize", "rust.optimize", "build optimized rust code")
75 o("optimize-llvm", "llvm.optimize", "build optimized LLVM")
76 o("llvm-assertions", "llvm.assertions", "build LLVM with assertions")
77 o("debug-assertions", "rust.debug-assertions", "build with debugging assertions")
78 o("llvm-release-debuginfo", "llvm.release-debuginfo", "build LLVM with debugger metadata")
79 o("debuginfo", "rust.debuginfo", "build with debugger metadata")
80 o("debuginfo-lines", "rust.debuginfo-lines", "build with line number debugger metadata")
81 o("debuginfo-only-std", "rust.debuginfo-only-std", "build only libstd with debugging information")
82 o("debuginfo-tools", "rust.debuginfo-tools", "build extended tools with debugging information")
83 o("debug-jemalloc", "rust.debug-jemalloc", "build jemalloc with --enable-debug --enable-fill")
84 v("save-toolstates", "rust.save-toolstates", "save build and test status of external tools into this file")
86 v("prefix", "install.prefix", "set installation prefix")
87 v("localstatedir", "install.localstatedir", "local state directory")
88 v("datadir", "install.datadir", "install data")
89 v("sysconfdir", "install.sysconfdir", "install system configuration files")
90 v("infodir", "install.infodir", "install additional info")
91 v("libdir", "install.libdir", "install libraries")
92 v("mandir", "install.mandir", "install man pages in PATH")
93 v("docdir", "install.docdir", "install documentation in PATH")
94 v("bindir", "install.bindir", "install binaries")
96 v("llvm-root", None, "set LLVM root")
97 v("python", "build.python", "set path to python")
98 v("jemalloc-root", None, "set directory where libjemalloc_pic.a is located")
99 v("android-cross-path", "target.arm-linux-androideabi.android-ndk",
100 "Android NDK standalone path (deprecated)")
101 v("i686-linux-android-ndk", "target.i686-linux-android.android-ndk",
102 "i686-linux-android NDK standalone path")
103 v("arm-linux-androideabi-ndk", "target.arm-linux-androideabi.android-ndk",
104 "arm-linux-androideabi NDK standalone path")
105 v("armv7-linux-androideabi-ndk", "target.armv7-linux-androideabi.android-ndk",
106 "armv7-linux-androideabi NDK standalone path")
107 v("aarch64-linux-android-ndk", "target.aarch64-linux-android.android-ndk",
108 "aarch64-linux-android NDK standalone path")
109 v("x86_64-linux-android-ndk", "target.x86_64-linux-android.android-ndk",
110 "x86_64-linux-android NDK standalone path")
111 v("musl-root", "target.x86_64-unknown-linux-musl.musl-root",
112 "MUSL root installation directory (deprecated)")
113 v("musl-root-x86_64", "target.x86_64-unknown-linux-musl.musl-root",
114 "x86_64-unknown-linux-musl install directory")
115 v("musl-root-i586", "target.i586-unknown-linux-musl.musl-root",
116 "i586-unknown-linux-musl install directory")
117 v("musl-root-i686", "target.i686-unknown-linux-musl.musl-root",
118 "i686-unknown-linux-musl install directory")
119 v("musl-root-arm", "target.arm-unknown-linux-musleabi.musl-root",
120 "arm-unknown-linux-musleabi install directory")
121 v("musl-root-armhf", "target.arm-unknown-linux-musleabihf.musl-root",
122 "arm-unknown-linux-musleabihf install directory")
123 v("musl-root-armv5te", "target.armv5te-unknown-linux-musleabi.musl-root",
124 "armv5te-unknown-linux-musleabi install directory")
125 v("musl-root-armv7", "target.armv7-unknown-linux-musleabihf.musl-root",
126 "armv7-unknown-linux-musleabihf install directory")
127 v("musl-root-aarch64", "target.aarch64-unknown-linux-musl.musl-root",
128 "aarch64-unknown-linux-musl install directory")
129 v("musl-root-mips", "target.mips-unknown-linux-musl.musl-root",
130 "mips-unknown-linux-musl install directory")
131 v("musl-root-mipsel", "target.mipsel-unknown-linux-musl.musl-root",
132 "mipsel-unknown-linux-musl install directory")
133 v("qemu-armhf-rootfs", "target.arm-unknown-linux-gnueabihf.qemu-rootfs",
134 "rootfs in qemu testing, you probably don't want to use this")
135 v("qemu-aarch64-rootfs", "target.aarch64-unknown-linux-gnu.qemu-rootfs",
136 "rootfs in qemu testing, you probably don't want to use this")
137 v("experimental-targets", "llvm.experimental-targets",
138 "experimental LLVM targets to build")
139 v("release-channel", "rust.channel", "the name of the release channel to build")
141 # Used on systems where "cc" is unavailable
142 v("default-linker", "rust.default-linker", "the default linker")
144 # Many of these are saved below during the "writing configuration" step
145 # (others are conditionally saved).
146 o("manage-submodules", "build.submodules", "let the build manage the git submodules")
147 o("jemalloc", "rust.use-jemalloc", "build liballoc with jemalloc")
148 o("full-bootstrap", "build.full-bootstrap", "build three compilers instead of two")
149 o("extended", "build.extended", "build an extended rust tool set")
151 v("tools", None, "List of extended tools will be installed")
152 v("build", "build.build", "GNUs ./configure syntax LLVM build triple")
153 v("host", None, "GNUs ./configure syntax LLVM host triples")
154 v("target", None, "GNUs ./configure syntax LLVM target triples")
156 v("set", None, "set arbitrary key/value pairs in TOML configuration")
160 print("configure: " + msg)
164 print("configure: error: " + msg)
168 if '--help' in sys.argv or '-h' in sys.argv:
169 print('Usage: ./configure [options]')
172 for option in options:
173 if 'android' in option.name:
174 # no one needs to know about these obscure options
177 print('\t{:30} {}'.format('--{}=VAL'.format(option.name), option.desc))
179 print('\t{:30} {}'.format('--enable-{}'.format(option.name), option.desc))
181 print('This configure script is a thin configuration shim over the true')
182 print('configuration system, `config.toml`. You can explore the comments')
183 print('in `config.toml.example` next to this configure script to see')
184 print('more information about what each option is. Additionally you can')
185 print('pass `--set` as an argument to set arbitrary key/value pairs')
186 print('in the TOML configuration if desired')
188 print('Also note that all options which take `--enable` can similarly')
189 print('be passed with `--disable-foo` to forcibly disable the option')
192 # Parse all command line arguments into one of these three lists, handling
193 # boolean and value-based options separately
198 p("processing command line")
200 while i < len(sys.argv):
203 if not arg.startswith('--'):
204 unknown_args.append(arg)
208 for option in options:
211 keyval = arg[2:].split('=', 1)
213 if option.name != key:
218 elif i < len(sys.argv):
222 need_value_args.append(arg)
225 if arg[2:] == 'enable-' + option.name:
227 elif arg[2:] == 'disable-' + option.name:
233 if option.name not in known_args:
234 known_args[option.name] = []
235 known_args[option.name].append((option, value))
239 unknown_args.append(arg)
242 # Note: here and a few other places, we use [-1] to apply the *last* value
243 # passed. But if option-checking is enabled, then the known_args loop will
244 # also assert that options are only passed once.
245 option_checking = ('option-checking' not in known_args
246 or known_args['option-checking'][-1][1])
248 if len(unknown_args) > 0:
249 err("Option '" + unknown_args[0] + "' is not recognized")
250 if len(need_value_args) > 0:
251 err("Option '{0}' needs a value ({0}=val)".format(need_value_args[0]))
253 # Parse all known arguments into a configuration structure that reflects the
254 # TOML we're going to write out
259 if 'build' in known_args:
260 return known_args['build'][-1][1]
261 return bootstrap.default_build_triple()
265 s = "{:20} := {}".format(key, value)
272 parts = key.split('.')
273 for i, part in enumerate(parts):
274 if i == len(parts) - 1:
282 for key in known_args:
283 # The `set` option is special and can be passed a bunch of times
285 for option, value in known_args[key]:
286 keyval = value.split('=', 1)
287 if len(keyval) == 1 or keyval[1] == "true":
289 elif keyval[1] == "false":
293 set(keyval[0], value)
296 # Ensure each option is only passed once
297 arr = known_args[key]
298 if option_checking and len(arr) > 1:
299 err("Option '{}' provided more than once".format(key))
300 option, value = arr[-1]
302 # If we have a clear avenue to set our value in rustbuild, do so
303 if option.rustbuild is not None:
304 set(option.rustbuild, value)
307 # Otherwise we're a "special" option and need some extra handling, so do
309 if option.name == 'sccache':
310 set('llvm.ccache', 'sccache')
311 elif option.name == 'local-rust':
312 for path in os.environ['PATH'].split(os.pathsep):
313 if os.path.exists(path + '/rustc'):
314 set('build.rustc', path + '/rustc')
316 for path in os.environ['PATH'].split(os.pathsep):
317 if os.path.exists(path + '/cargo'):
318 set('build.cargo', path + '/cargo')
320 elif option.name == 'local-rust-root':
321 set('build.rustc', value + '/bin/rustc')
322 set('build.cargo', value + '/bin/cargo')
323 elif option.name == 'llvm-root':
324 set('target.{}.llvm-config'.format(build()), value + '/bin/llvm-config')
325 elif option.name == 'jemalloc-root':
326 set('target.{}.jemalloc'.format(build()), value + '/libjemalloc_pic.a')
327 elif option.name == 'tools':
328 set('build.tools', value.split(','))
329 elif option.name == 'host':
330 set('build.host', value.split(','))
331 elif option.name == 'target':
332 set('build.target', value.split(','))
333 elif option.name == 'emscripten':
334 set('rust.codegen-backends', ['llvm', 'emscripten'])
335 elif option.name == 'full-tools':
336 set('rust.codegen-backends', ['llvm', 'emscripten'])
337 set('rust.lld', True)
338 set('rust.llvm-tools', True)
339 set('build.extended', True)
340 elif option.name == 'option-checking':
341 # this was handled above
344 raise RuntimeError("unhandled option {}".format(option.name))
346 set('build.configure-args', sys.argv[1:])
348 # "Parse" the `config.toml.example` file into the various sections, and we'll
349 # use this as a template of a `config.toml` to write out which preserves
350 # all the various comments and whatnot.
352 # Note that the `target` section is handled separately as we'll duplicate it
353 # per configure dtarget, so there's a bit of special handling for that here.
357 section_order = [None]
360 for line in open(rust_dir + '/config.toml.example').read().split("\n"):
361 if line.startswith('['):
362 cur_section = line[1:-1]
363 if cur_section.startswith('target'):
364 cur_section = 'target'
365 elif '.' in cur_section:
366 raise RuntimeError("don't know how to deal with section: {}".format(cur_section))
367 sections[cur_section] = [line]
368 section_order.append(cur_section)
370 sections[cur_section].append(line)
372 # Fill out the `targets` array by giving all configured targets a copy of the
373 # `target` section we just loaded from the example config
374 configured_targets = [build()]
375 if 'build' in config:
376 if 'host' in config['build']:
377 configured_targets += config['build']['host']
378 if 'target' in config['build']:
379 configured_targets += config['build']['target']
380 if 'target' in config:
381 for target in config['target']:
382 configured_targets.append(target)
383 for target in configured_targets:
384 targets[target] = sections['target'][:]
385 targets[target][0] = targets[target][0].replace("x86_64-unknown-linux-gnu", target)
388 # Here we walk through the constructed configuration we have from the parsed
389 # command line arguments. We then apply each piece of configuration by
390 # basically just doing a `sed` to change the various configuration line to what
391 # we've got configure.
393 if isinstance(value, bool):
398 elif isinstance(value, list):
399 return '[' + ', '.join(map(to_toml, value)) + ']'
400 elif isinstance(value, str):
401 return "'" + value + "'"
403 raise RuntimeError('no toml')
406 def configure_section(lines, config):
410 for i, line in enumerate(lines):
411 if not line.startswith('#' + key + ' = '):
414 lines[i] = "{} = {}".format(key, to_toml(value))
417 raise RuntimeError("failed to find config line for {}".format(key))
420 for section_key in config:
421 section_config = config[section_key]
422 if section_key not in sections:
423 raise RuntimeError("config key {} not in sections".format(section_key))
425 if section_key == 'target':
426 for target in section_config:
427 configure_section(targets[target], section_config[target])
429 configure_section(sections[section_key], section_config)
431 # Now that we've built up our `config.toml`, write it all out in the same
432 # order that we read it in.
434 p("writing `config.toml` in current directory")
435 with bootstrap.output('config.toml') as f:
436 for section in section_order:
437 if section == 'target':
438 for target in targets:
439 for line in targets[target]:
442 for line in sections[section]:
445 with bootstrap.output('Makefile') as f:
446 contents = os.path.join(rust_dir, 'src', 'bootstrap', 'mk', 'Makefile.in')
447 contents = open(contents).read()
448 contents = contents.replace("$(CFG_SRC_DIR)", rust_dir + '/')
449 contents = contents.replace("$(CFG_PYTHON)", sys.executable)
453 p("run `python {}/x.py --help`".format(rust_dir))