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("test-miri", "rust.test-miri", "run miri's test suite")
48 o("debuginfo-tests", "rust.debuginfo-tests", "build tests with debugger metadata")
49 o("quiet-tests", "rust.quiet-tests", "enable quieter output when running tests")
50 o("ccache", "llvm.ccache", "invoke gcc/clang via ccache to reuse object files between builds")
51 o("sccache", None, "invoke gcc/clang via sccache to reuse object files between builds")
52 o("local-rust", None, "use an installed rustc rather than downloading a snapshot")
53 v("local-rust-root", None, "set prefix for local rust binary")
54 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")
55 o("llvm-static-stdcpp", "llvm.static-libstdcpp", "statically link to libstdc++ for LLVM")
56 o("llvm-link-shared", "llvm.link-shared", "prefer shared linking to LLVM (llvm-config --link-shared)")
57 o("rpath", "rust.rpath", "build rpaths into rustc itself")
58 o("llvm-version-check", "llvm.version-check", "check if the LLVM version is supported, build anyway")
59 o("codegen-tests", "rust.codegen-tests", "run the src/test/codegen tests")
60 o("option-checking", None, "complain about unrecognized options in this configure script")
61 o("ninja", "llvm.ninja", "build LLVM using the Ninja generator (for MSVC, requires building in the correct environment)")
62 o("locked-deps", "build.locked-deps", "force Cargo.lock to be up to date")
63 o("vendor", "build.vendor", "enable usage of vendored Rust crates")
64 o("sanitizers", "build.sanitizers", "build the sanitizer runtimes (asan, lsan, msan, tsan)")
65 o("dist-src", "rust.dist-src", "when building tarballs enables building a source tarball")
66 o("cargo-openssl-static", "build.openssl-static", "static openssl in cargo")
67 o("profiler", "build.profiler", "build the profiler runtime")
68 o("emscripten", None, "compile the emscripten backend as well as LLVM")
70 # Optimization and debugging options. These may be overridden by the release
72 o("optimize", "rust.optimize", "build optimized rust code")
73 o("thinlto", "rust.thinlto", "build Rust with ThinLTO enabled")
74 o("optimize-llvm", "llvm.optimize", "build optimized LLVM")
75 o("llvm-assertions", "llvm.assertions", "build LLVM with assertions")
76 o("debug-assertions", "rust.debug-assertions", "build with debugging assertions")
77 o("llvm-release-debuginfo", "llvm.release-debuginfo", "build LLVM with debugger metadata")
78 o("debuginfo", "rust.debuginfo", "build with debugger metadata")
79 o("debuginfo-lines", "rust.debuginfo-lines", "build with line number debugger metadata")
80 o("debuginfo-only-std", "rust.debuginfo-only-std", "build only libstd with debugging information")
81 o("debug-jemalloc", "rust.debug-jemalloc", "build jemalloc with --enable-debug --enable-fill")
82 v("save-toolstates", "rust.save-toolstates", "save build and test status of external tools into this file")
84 v("prefix", "install.prefix", "set installation prefix")
85 v("localstatedir", "install.localstatedir", "local state directory")
86 v("datadir", "install.datadir", "install data")
87 v("sysconfdir", "install.sysconfdir", "install system configuration files")
88 v("infodir", "install.infodir", "install additional info")
89 v("libdir", "install.libdir", "install libraries")
90 v("mandir", "install.mandir", "install man pages in PATH")
91 v("docdir", "install.docdir", "install documentation in PATH")
92 v("bindir", "install.bindir", "install binaries")
94 v("llvm-root", None, "set LLVM root")
95 v("python", "build.python", "set path to python")
96 v("jemalloc-root", None, "set directory where libjemalloc_pic.a is located")
97 v("android-cross-path", "target.arm-linux-androideabi.android-ndk",
98 "Android NDK standalone path (deprecated)")
99 v("i686-linux-android-ndk", "target.i686-linux-android.android-ndk",
100 "i686-linux-android NDK standalone path")
101 v("arm-linux-androideabi-ndk", "target.arm-linux-androideabi.android-ndk",
102 "arm-linux-androideabi NDK standalone path")
103 v("armv7-linux-androideabi-ndk", "target.armv7-linux-androideabi.android-ndk",
104 "armv7-linux-androideabi NDK standalone path")
105 v("aarch64-linux-android-ndk", "target.aarch64-linux-android.android-ndk",
106 "aarch64-linux-android NDK standalone path")
107 v("x86_64-linux-android-ndk", "target.x86_64-linux-android.android-ndk",
108 "x86_64-linux-android NDK standalone path")
109 v("musl-root", "target.x86_64-unknown-linux-musl.musl-root",
110 "MUSL root installation directory (deprecated)")
111 v("musl-root-x86_64", "target.x86_64-unknown-linux-musl.musl-root",
112 "x86_64-unknown-linux-musl install directory")
113 v("musl-root-i586", "target.i586-unknown-linux-musl.musl-root",
114 "i586-unknown-linux-musl install directory")
115 v("musl-root-i686", "target.i686-unknown-linux-musl.musl-root",
116 "i686-unknown-linux-musl install directory")
117 v("musl-root-arm", "target.arm-unknown-linux-musleabi.musl-root",
118 "arm-unknown-linux-musleabi install directory")
119 v("musl-root-armhf", "target.arm-unknown-linux-musleabihf.musl-root",
120 "arm-unknown-linux-musleabihf install directory")
121 v("musl-root-armv7", "target.armv7-unknown-linux-musleabihf.musl-root",
122 "armv7-unknown-linux-musleabihf install directory")
123 v("musl-root-aarch64", "target.aarch64-unknown-linux-musl.musl-root",
124 "aarch64-unknown-linux-musl install directory")
125 v("musl-root-mips", "target.mips-unknown-linux-musl.musl-root",
126 "mips-unknown-linux-musl install directory")
127 v("musl-root-mipsel", "target.mipsel-unknown-linux-musl.musl-root",
128 "mipsel-unknown-linux-musl install directory")
129 v("qemu-armhf-rootfs", "target.arm-unknown-linux-gnueabihf.qemu-rootfs",
130 "rootfs in qemu testing, you probably don't want to use this")
131 v("qemu-aarch64-rootfs", "target.aarch64-unknown-linux-gnu.qemu-rootfs",
132 "rootfs in qemu testing, you probably don't want to use this")
133 v("experimental-targets", "llvm.experimental-targets",
134 "experimental LLVM targets to build")
135 v("release-channel", "rust.channel", "the name of the release channel to build")
137 # Used on systems where "cc" is unavailable
138 v("default-linker", "rust.default-linker", "the default linker")
140 # Many of these are saved below during the "writing configuration" step
141 # (others are conditionally saved).
142 o("manage-submodules", "build.submodules", "let the build manage the git submodules")
143 o("jemalloc", "rust.use-jemalloc", "build liballoc with jemalloc")
144 o("full-bootstrap", "build.full-bootstrap", "build three compilers instead of two")
145 o("extended", "build.extended", "build an extended rust tool set")
147 v("build", "build.build", "GNUs ./configure syntax LLVM build triple")
148 v("host", None, "GNUs ./configure syntax LLVM host triples")
149 v("target", None, "GNUs ./configure syntax LLVM target triples")
151 v("set", None, "set arbitrary key/value pairs in TOML configuration")
155 print("configure: " + msg)
159 print("configure: error: " + msg)
163 if '--help' in sys.argv or '-h' in sys.argv:
164 print('Usage: ./configure [options]')
167 for option in options:
168 if 'android' in option.name:
169 # no one needs to know about these obscure options
172 print('\t{:30} {}'.format('--{}=VAL'.format(option.name), option.desc))
174 print('\t{:30} {}'.format('--enable-{}'.format(option.name), option.desc))
176 print('This configure script is a thin configuration shim over the true')
177 print('configuration system, `config.toml`. You can explore the comments')
178 print('in `config.toml.example` next to this configure script to see')
179 print('more information about what each option is. Additionally you can')
180 print('pass `--set` as an argument to set arbitrary key/value pairs')
181 print('in the TOML configuration if desired')
183 print('Also note that all options which take `--enable` can similarly')
184 print('be passed with `--disable-foo` to forcibly disable the option')
187 # Parse all command line arguments into one of these three lists, handling
188 # boolean and value-based options separately
193 p("processing command line")
195 while i < len(sys.argv):
198 if not arg.startswith('--'):
199 unknown_args.append(arg)
203 for option in options:
206 keyval = arg[2:].split('=', 1)
208 if option.name != key:
213 elif i < len(sys.argv):
217 need_value_args.append(arg)
220 if arg[2:] == 'enable-' + option.name:
222 elif arg[2:] == 'disable-' + option.name:
228 if option.name not in known_args:
229 known_args[option.name] = []
230 known_args[option.name].append((option, value))
234 unknown_args.append(arg)
237 # Note: here and a few other places, we use [-1] to apply the *last* value
238 # passed. But if option-checking is enabled, then the known_args loop will
239 # also assert that options are only passed once.
240 option_checking = ('option-checking' not in known_args
241 or known_args['option-checking'][-1][1])
243 if len(unknown_args) > 0:
244 err("Option '" + unknown_args[0] + "' is not recognized")
245 if len(need_value_args) > 0:
246 err("Option '{0}' needs a value ({0}=val)".format(need_value_args[0]))
248 # Parse all known arguments into a configuration structure that reflects the
249 # TOML we're going to write out
254 if 'build' in known_args:
255 return known_args['build'][-1][1]
256 return bootstrap.default_build_triple()
260 s = "{:20} := {}".format(key, value)
267 parts = key.split('.')
268 for i, part in enumerate(parts):
269 if i == len(parts) - 1:
277 for key in known_args:
278 # The `set` option is special and can be passed a bunch of times
280 for option, value in known_args[key]:
281 keyval = value.split('=', 1)
282 if len(keyval) == 1 or keyval[1] == "true":
284 elif keyval[1] == "false":
288 set(keyval[0], value)
291 # Ensure each option is only passed once
292 arr = known_args[key]
293 if option_checking and len(arr) > 1:
294 err("Option '{}' provided more than once".format(key))
295 option, value = arr[-1]
297 # If we have a clear avenue to set our value in rustbuild, do so
298 if option.rustbuild is not None:
299 set(option.rustbuild, value)
302 # Otherwise we're a "special" option and need some extra handling, so do
304 if option.name == 'sccache':
305 set('llvm.ccache', 'sccache')
306 elif option.name == 'local-rust':
307 for path in os.environ['PATH'].split(os.pathsep):
308 if os.path.exists(path + '/rustc'):
309 set('build.rustc', path + '/rustc')
311 for path in os.environ['PATH'].split(os.pathsep):
312 if os.path.exists(path + '/cargo'):
313 set('build.cargo', path + '/cargo')
315 elif option.name == 'local-rust-root':
316 set('build.rustc', value + '/bin/rustc')
317 set('build.cargo', value + '/bin/cargo')
318 elif option.name == 'llvm-root':
319 set('target.{}.llvm-config'.format(build()), value + '/bin/llvm-config')
320 elif option.name == 'jemalloc-root':
321 set('target.{}.jemalloc'.format(build()), value + '/libjemalloc_pic.a')
322 elif option.name == 'host':
323 set('build.host', value.split(','))
324 elif option.name == 'target':
325 set('build.target', value.split(','))
326 elif option.name == 'emscripten':
327 set('rust.codegen-backends', ['llvm', 'emscripten'])
328 elif option.name == 'option-checking':
329 # this was handled above
332 raise RuntimeError("unhandled option {}".format(option.name))
334 set('build.configure-args', sys.argv[1:])
336 # "Parse" the `config.toml.example` file into the various sections, and we'll
337 # use this as a template of a `config.toml` to write out which preserves
338 # all the various comments and whatnot.
340 # Note that the `target` section is handled separately as we'll duplicate it
341 # per configure dtarget, so there's a bit of special handling for that here.
345 section_order = [None]
348 for line in open(rust_dir + '/config.toml.example').read().split("\n"):
349 if line.startswith('['):
350 cur_section = line[1:-1]
351 if cur_section.startswith('target'):
352 cur_section = 'target'
353 elif '.' in cur_section:
354 raise RuntimeError("don't know how to deal with section: {}".format(cur_section))
355 sections[cur_section] = [line]
356 section_order.append(cur_section)
358 sections[cur_section].append(line)
360 # Fill out the `targets` array by giving all configured targets a copy of the
361 # `target` section we just loaded from the example config
362 configured_targets = [build()]
363 if 'build' in config:
364 if 'host' in config['build']:
365 configured_targets += config['build']['host']
366 if 'target' in config['build']:
367 configured_targets += config['build']['target']
368 if 'target' in config:
369 for target in config['target']:
370 configured_targets.append(target)
371 for target in configured_targets:
372 targets[target] = sections['target'][:]
373 targets[target][0] = targets[target][0].replace("x86_64-unknown-linux-gnu", target)
376 # Here we walk through the constructed configuration we have from the parsed
377 # command line arguments. We then apply each piece of configuration by
378 # basically just doing a `sed` to change the various configuration line to what
379 # we've got configure.
381 if isinstance(value, bool):
386 elif isinstance(value, list):
387 return '[' + ', '.join(map(to_toml, value)) + ']'
388 elif isinstance(value, str):
389 return "'" + value + "'"
391 raise RuntimeError('no toml')
394 def configure_section(lines, config):
398 for i, line in enumerate(lines):
399 if not line.startswith('#' + key + ' = '):
402 lines[i] = "{} = {}".format(key, to_toml(value))
405 raise RuntimeError("failed to find config line for {}".format(key))
408 for section_key in config:
409 section_config = config[section_key]
410 if section_key not in sections:
411 raise RuntimeError("config key {} not in sections".format(section_key))
413 if section_key == 'target':
414 for target in section_config:
415 configure_section(targets[target], section_config[target])
417 configure_section(sections[section_key], section_config)
419 # Now that we've built up our `config.toml`, write it all out in the same
420 # order that we read it in.
422 p("writing `config.toml` in current directory")
423 with open('config.toml', 'w') as f:
424 for section in section_order:
425 if section == 'target':
426 for target in targets:
427 for line in targets[target]:
430 for line in sections[section]:
433 with open('Makefile', 'w') as f:
434 contents = os.path.join(rust_dir, 'src', 'bootstrap', 'mk', 'Makefile.in')
435 contents = open(contents).read()
436 contents = contents.replace("$(CFG_SRC_DIR)", rust_dir + '/')
437 contents = contents.replace("$(CFG_PYTHON)", sys.executable)
441 p("run `python {}/x.py --help`".format(rust_dir))