3 # ignore-tidy-linelength
5 from __future__ import absolute_import, division, print_function
8 rust_dir = os.path.dirname(os.path.abspath(__file__))
9 rust_dir = os.path.dirname(rust_dir)
10 rust_dir = os.path.dirname(rust_dir)
11 sys.path.append(os.path.join(rust_dir, "src", "bootstrap"))
16 def __init__(self, name, rustbuild, desc, value):
18 self.rustbuild = rustbuild
27 options.append(Option(*args, value=False))
31 options.append(Option(*args, value=True))
34 o("debug", "rust.debug", "enables debugging environment; does not affect optimization of bootstrapped code (use `--disable-optimize` for that)")
35 o("docs", "build.docs", "build standard library documentation")
36 o("compiler-docs", "build.compiler-docs", "build compiler documentation")
37 o("optimize-tests", "rust.optimize-tests", "build tests with optimizations")
38 o("parallel-compiler", "rust.parallel-compiler", "build a multi-threaded rustc")
39 o("verbose-tests", "rust.verbose-tests", "enable verbose output when running tests")
40 o("ccache", "llvm.ccache", "invoke gcc/clang via ccache to reuse object files between builds")
41 o("sccache", None, "invoke gcc/clang via sccache to reuse object files between builds")
42 o("local-rust", None, "use an installed rustc rather than downloading a snapshot")
43 v("local-rust-root", None, "set prefix for local rust binary")
44 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")
45 o("llvm-static-stdcpp", "llvm.static-libstdcpp", "statically link to libstdc++ for LLVM")
46 o("llvm-link-shared", "llvm.link-shared", "prefer shared linking to LLVM (llvm-config --link-shared)")
47 o("rpath", "rust.rpath", "build rpaths into rustc itself")
48 o("llvm-version-check", "llvm.version-check", "check if the LLVM version is supported, build anyway")
49 o("codegen-tests", "rust.codegen-tests", "run the src/test/codegen tests")
50 o("option-checking", None, "complain about unrecognized options in this configure script")
51 o("ninja", "llvm.ninja", "build LLVM using the Ninja generator (for MSVC, requires building in the correct environment)")
52 o("locked-deps", "build.locked-deps", "force Cargo.lock to be up to date")
53 o("vendor", "build.vendor", "enable usage of vendored Rust crates")
54 o("sanitizers", "build.sanitizers", "build the sanitizer runtimes (asan, lsan, msan, tsan, hwasan)")
55 o("dist-src", "rust.dist-src", "when building tarballs enables building a source tarball")
56 o("cargo-native-static", "build.cargo-native-static", "static native libraries in cargo")
57 o("profiler", "build.profiler", "build the profiler runtime")
58 o("full-tools", None, "enable all tools")
59 o("lld", "rust.lld", "build lld")
60 o("clang", "llvm.clang", "build clang")
61 o("missing-tools", "dist.missing-tools", "allow failures when building tools")
62 o("use-libcxx", "llvm.use-libcxx", "build LLVM with libc++")
63 o("control-flow-guard", "rust.control-flow-guard", "Enable Control Flow Guard")
65 v("llvm-cflags", "llvm.cflags", "build LLVM with these extra compiler flags")
66 v("llvm-cxxflags", "llvm.cxxflags", "build LLVM with these extra compiler flags")
67 v("llvm-ldflags", "llvm.ldflags", "build LLVM with these extra linker flags")
69 v("llvm-libunwind", "rust.llvm-libunwind", "use LLVM libunwind")
71 # Optimization and debugging options. These may be overridden by the release
73 o("optimize", "rust.optimize", "build optimized rust code")
74 o("optimize-llvm", "llvm.optimize", "build optimized LLVM")
75 o("llvm-assertions", "llvm.assertions", "build LLVM with assertions")
76 o("llvm-plugins", "llvm.plugins", "build LLVM with plugin interface")
77 o("debug-assertions", "rust.debug-assertions", "build with debugging assertions")
78 o("debug-assertions-std", "rust.debug-assertions-std", "build the standard library with debugging assertions")
79 o("overflow-checks", "rust.overflow-checks", "build with overflow checks")
80 o("overflow-checks-std", "rust.overflow-checks-std", "build the standard library with overflow checks")
81 o("llvm-release-debuginfo", "llvm.release-debuginfo", "build LLVM with debugger metadata")
82 v("debuginfo-level", "rust.debuginfo-level", "debuginfo level for Rust code")
83 v("debuginfo-level-rustc", "rust.debuginfo-level-rustc", "debuginfo level for the compiler")
84 v("debuginfo-level-std", "rust.debuginfo-level-std", "debuginfo level for the standard library")
85 v("debuginfo-level-tools", "rust.debuginfo-level-tools", "debuginfo level for the tools")
86 v("debuginfo-level-tests", "rust.debuginfo-level-tests", "debuginfo level for the test suites run with compiletest")
87 v("save-toolstates", "rust.save-toolstates", "save build and test status of external tools into this file")
89 v("prefix", "install.prefix", "set installation prefix")
90 v("localstatedir", "install.localstatedir", "local state directory")
91 v("datadir", "install.datadir", "install data")
92 v("sysconfdir", "install.sysconfdir", "install system configuration files")
93 v("infodir", "install.infodir", "install additional info")
94 v("libdir", "install.libdir", "install libraries")
95 v("mandir", "install.mandir", "install man pages in PATH")
96 v("docdir", "install.docdir", "install documentation in PATH")
97 v("bindir", "install.bindir", "install binaries")
99 v("llvm-root", None, "set LLVM root")
100 v("llvm-config", None, "set path to llvm-config")
101 v("llvm-filecheck", None, "set path to LLVM's FileCheck utility")
102 v("python", "build.python", "set path to python")
103 v("android-cross-path", "target.arm-linux-androideabi.android-ndk",
104 "Android NDK standalone path (deprecated)")
105 v("i686-linux-android-ndk", "target.i686-linux-android.android-ndk",
106 "i686-linux-android NDK standalone path")
107 v("arm-linux-androideabi-ndk", "target.arm-linux-androideabi.android-ndk",
108 "arm-linux-androideabi NDK standalone path")
109 v("armv7-linux-androideabi-ndk", "target.armv7-linux-androideabi.android-ndk",
110 "armv7-linux-androideabi NDK standalone path")
111 v("thumbv7neon-linux-androideabi-ndk", "target.thumbv7neon-linux-androideabi.android-ndk",
112 "thumbv7neon-linux-androideabi NDK standalone path")
113 v("aarch64-linux-android-ndk", "target.aarch64-linux-android.android-ndk",
114 "aarch64-linux-android NDK standalone path")
115 v("x86_64-linux-android-ndk", "target.x86_64-linux-android.android-ndk",
116 "x86_64-linux-android NDK standalone path")
117 v("musl-root", "target.x86_64-unknown-linux-musl.musl-root",
118 "MUSL root installation directory (deprecated)")
119 v("musl-root-x86_64", "target.x86_64-unknown-linux-musl.musl-root",
120 "x86_64-unknown-linux-musl install directory")
121 v("musl-root-i586", "target.i586-unknown-linux-musl.musl-root",
122 "i586-unknown-linux-musl install directory")
123 v("musl-root-i686", "target.i686-unknown-linux-musl.musl-root",
124 "i686-unknown-linux-musl install directory")
125 v("musl-root-arm", "target.arm-unknown-linux-musleabi.musl-root",
126 "arm-unknown-linux-musleabi install directory")
127 v("musl-root-armhf", "target.arm-unknown-linux-musleabihf.musl-root",
128 "arm-unknown-linux-musleabihf install directory")
129 v("musl-root-armv5te", "target.armv5te-unknown-linux-musleabi.musl-root",
130 "armv5te-unknown-linux-musleabi install directory")
131 v("musl-root-armv7", "target.armv7-unknown-linux-musleabi.musl-root",
132 "armv7-unknown-linux-musleabi install directory")
133 v("musl-root-armv7hf", "target.armv7-unknown-linux-musleabihf.musl-root",
134 "armv7-unknown-linux-musleabihf install directory")
135 v("musl-root-aarch64", "target.aarch64-unknown-linux-musl.musl-root",
136 "aarch64-unknown-linux-musl install directory")
137 v("musl-root-mips", "target.mips-unknown-linux-musl.musl-root",
138 "mips-unknown-linux-musl install directory")
139 v("musl-root-mipsel", "target.mipsel-unknown-linux-musl.musl-root",
140 "mipsel-unknown-linux-musl install directory")
141 v("musl-root-mips64", "target.mips64-unknown-linux-muslabi64.musl-root",
142 "mips64-unknown-linux-muslabi64 install directory")
143 v("musl-root-mips64el", "target.mips64el-unknown-linux-muslabi64.musl-root",
144 "mips64el-unknown-linux-muslabi64 install directory")
145 v("qemu-armhf-rootfs", "target.arm-unknown-linux-gnueabihf.qemu-rootfs",
146 "rootfs in qemu testing, you probably don't want to use this")
147 v("qemu-aarch64-rootfs", "target.aarch64-unknown-linux-gnu.qemu-rootfs",
148 "rootfs in qemu testing, you probably don't want to use this")
149 v("qemu-riscv64-rootfs", "target.riscv64gc-unknown-linux-gnu.qemu-rootfs",
150 "rootfs in qemu testing, you probably don't want to use this")
151 v("experimental-targets", "llvm.experimental-targets",
152 "experimental LLVM targets to build")
153 v("release-channel", "rust.channel", "the name of the release channel to build")
154 v("release-description", "rust.description", "optional descriptive string for version output")
155 v("dist-compression-formats", None,
156 "comma-separated list of compression formats to use")
158 # Used on systems where "cc" is unavailable
159 v("default-linker", "rust.default-linker", "the default linker")
161 # Many of these are saved below during the "writing configuration" step
162 # (others are conditionally saved).
163 o("manage-submodules", "build.submodules", "let the build manage the git submodules")
164 o("full-bootstrap", "build.full-bootstrap", "build three compilers instead of two")
165 o("extended", "build.extended", "build an extended rust tool set")
167 v("tools", None, "List of extended tools will be installed")
168 v("codegen-backends", None, "List of codegen backends to build")
169 v("build", "build.build", "GNUs ./configure syntax LLVM build triple")
170 v("host", None, "GNUs ./configure syntax LLVM host triples")
171 v("target", None, "GNUs ./configure syntax LLVM target triples")
173 v("set", None, "set arbitrary key/value pairs in TOML configuration")
177 print("configure: " + msg)
181 print("configure: error: " + msg)
185 if '--help' in sys.argv or '-h' in sys.argv:
186 print('Usage: ./configure [options]')
189 for option in options:
190 if 'android' in option.name:
191 # no one needs to know about these obscure options
194 print('\t{:30} {}'.format('--{}=VAL'.format(option.name), option.desc))
196 print('\t{:30} {}'.format('--enable-{}'.format(option.name), option.desc))
198 print('This configure script is a thin configuration shim over the true')
199 print('configuration system, `config.toml`. You can explore the comments')
200 print('in `config.toml.example` next to this configure script to see')
201 print('more information about what each option is. Additionally you can')
202 print('pass `--set` as an argument to set arbitrary key/value pairs')
203 print('in the TOML configuration if desired')
205 print('Also note that all options which take `--enable` can similarly')
206 print('be passed with `--disable-foo` to forcibly disable the option')
209 # Parse all command line arguments into one of these three lists, handling
210 # boolean and value-based options separately
215 p("processing command line")
217 while i < len(sys.argv):
220 if not arg.startswith('--'):
221 unknown_args.append(arg)
225 for option in options:
228 keyval = arg[2:].split('=', 1)
230 if option.name != key:
235 elif i < len(sys.argv):
239 need_value_args.append(arg)
242 if arg[2:] == 'enable-' + option.name:
244 elif arg[2:] == 'disable-' + option.name:
250 if option.name not in known_args:
251 known_args[option.name] = []
252 known_args[option.name].append((option, value))
256 unknown_args.append(arg)
259 # Note: here and a few other places, we use [-1] to apply the *last* value
260 # passed. But if option-checking is enabled, then the known_args loop will
261 # also assert that options are only passed once.
262 option_checking = ('option-checking' not in known_args
263 or known_args['option-checking'][-1][1])
265 if len(unknown_args) > 0:
266 err("Option '" + unknown_args[0] + "' is not recognized")
267 if len(need_value_args) > 0:
268 err("Option '{0}' needs a value ({0}=val)".format(need_value_args[0]))
270 # Parse all known arguments into a configuration structure that reflects the
271 # TOML we're going to write out
276 if 'build' in known_args:
277 return known_args['build'][-1][1]
278 return bootstrap.default_build_triple(verbose=False)
282 if isinstance(value, list):
283 # Remove empty values, which value.split(',') tends to generate.
284 value = [v for v in value if v]
286 s = "{:20} := {}".format(key, value)
293 parts = key.split('.')
294 for i, part in enumerate(parts):
295 if i == len(parts) - 1:
303 for key in known_args:
304 # The `set` option is special and can be passed a bunch of times
306 for option, value in known_args[key]:
307 keyval = value.split('=', 1)
308 if len(keyval) == 1 or keyval[1] == "true":
310 elif keyval[1] == "false":
314 set(keyval[0], value)
317 # Ensure each option is only passed once
318 arr = known_args[key]
319 if option_checking and len(arr) > 1:
320 err("Option '{}' provided more than once".format(key))
321 option, value = arr[-1]
323 # If we have a clear avenue to set our value in rustbuild, do so
324 if option.rustbuild is not None:
325 set(option.rustbuild, value)
328 # Otherwise we're a "special" option and need some extra handling, so do
330 if option.name == 'sccache':
331 set('llvm.ccache', 'sccache')
332 elif option.name == 'local-rust':
333 for path in os.environ['PATH'].split(os.pathsep):
334 if os.path.exists(path + '/rustc'):
335 set('build.rustc', path + '/rustc')
337 for path in os.environ['PATH'].split(os.pathsep):
338 if os.path.exists(path + '/cargo'):
339 set('build.cargo', path + '/cargo')
341 elif option.name == 'local-rust-root':
342 set('build.rustc', value + '/bin/rustc')
343 set('build.cargo', value + '/bin/cargo')
344 elif option.name == 'llvm-root':
345 set('target.{}.llvm-config'.format(build()), value + '/bin/llvm-config')
346 elif option.name == 'llvm-config':
347 set('target.{}.llvm-config'.format(build()), value)
348 elif option.name == 'llvm-filecheck':
349 set('target.{}.llvm-filecheck'.format(build()), value)
350 elif option.name == 'tools':
351 set('build.tools', value.split(','))
352 elif option.name == 'codegen-backends':
353 set('rust.codegen-backends', value.split(','))
354 elif option.name == 'host':
355 set('build.host', value.split(','))
356 elif option.name == 'target':
357 set('build.target', value.split(','))
358 elif option.name == 'full-tools':
359 set('rust.codegen-backends', ['llvm'])
360 set('rust.lld', True)
361 set('rust.llvm-tools', True)
362 set('build.extended', True)
363 elif option.name == 'option-checking':
364 # this was handled above
366 elif option.name == 'dist-compression-formats':
367 set('dist.compression-formats', value.split(','))
369 raise RuntimeError("unhandled option {}".format(option.name))
371 set('build.configure-args', sys.argv[1:])
373 # "Parse" the `config.toml.example` file into the various sections, and we'll
374 # use this as a template of a `config.toml` to write out which preserves
375 # all the various comments and whatnot.
377 # Note that the `target` section is handled separately as we'll duplicate it
378 # per configured target, so there's a bit of special handling for that here.
382 section_order = [None]
385 for line in open(rust_dir + '/config.toml.example').read().split("\n"):
386 if line.startswith('['):
387 cur_section = line[1:-1]
388 if cur_section.startswith('target'):
389 cur_section = 'target'
390 elif '.' in cur_section:
391 raise RuntimeError("don't know how to deal with section: {}".format(cur_section))
392 sections[cur_section] = [line]
393 section_order.append(cur_section)
395 sections[cur_section].append(line)
397 # Fill out the `targets` array by giving all configured targets a copy of the
398 # `target` section we just loaded from the example config
399 configured_targets = [build()]
400 if 'build' in config:
401 if 'host' in config['build']:
402 configured_targets += config['build']['host']
403 if 'target' in config['build']:
404 configured_targets += config['build']['target']
405 if 'target' in config:
406 for target in config['target']:
407 configured_targets.append(target)
408 for target in configured_targets:
409 targets[target] = sections['target'][:]
410 targets[target][0] = targets[target][0].replace("x86_64-unknown-linux-gnu", "'{}'".format(target))
413 def is_number(value):
421 # Here we walk through the constructed configuration we have from the parsed
422 # command line arguments. We then apply each piece of configuration by
423 # basically just doing a `sed` to change the various configuration line to what
424 # we've got configure.
426 if isinstance(value, bool):
431 elif isinstance(value, list):
432 return '[' + ', '.join(map(to_toml, value)) + ']'
433 elif isinstance(value, str):
434 # Don't put quotes around numeric values
438 return "'" + value + "'"
440 raise RuntimeError('no toml')
443 def configure_section(lines, config):
447 for i, line in enumerate(lines):
448 if not line.startswith('#' + key + ' = '):
451 lines[i] = "{} = {}".format(key, to_toml(value))
454 # These are used by rpm, but aren't accepted by x.py.
455 # Give a warning that they're ignored, but not a hard error.
456 if key in ["infodir", "localstatedir"]:
457 print("warning: {} will be ignored".format(key))
459 raise RuntimeError("failed to find config line for {}".format(key))
462 for section_key in config:
463 section_config = config[section_key]
464 if section_key not in sections:
465 raise RuntimeError("config key {} not in sections".format(section_key))
467 if section_key == 'target':
468 for target in section_config:
469 configure_section(targets[target], section_config[target])
471 configure_section(sections[section_key], section_config)
473 # Now that we've built up our `config.toml`, write it all out in the same
474 # order that we read it in.
476 p("writing `config.toml` in current directory")
477 with bootstrap.output('config.toml') as f:
478 for section in section_order:
479 if section == 'target':
480 for target in targets:
481 for line in targets[target]:
484 for line in sections[section]:
487 with bootstrap.output('Makefile') as f:
488 contents = os.path.join(rust_dir, 'src', 'bootstrap', 'mk', 'Makefile.in')
489 contents = open(contents).read()
490 contents = contents.replace("$(CFG_SRC_DIR)", rust_dir + '/')
491 contents = contents.replace("$(CFG_PYTHON)", sys.executable)
495 p("run `python {}/x.py --help`".format(rust_dir))