src/bootstrap/configure.py

   1 #!/usr/bin/env python
   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.
   5 #
   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.
  11
  12 # ignore-tidy-linelength
  13
  14 from __future__ import absolute_import, division, print_function
  15 import sys
  16 import os
  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"))
  21 import bootstrap
  22
  23
  24 class Option(object):
  25     def __init__(self, name, rustbuild, desc, value):
  26         self.name = name
  27         self.rustbuild = rustbuild
  28         self.desc = desc
  29         self.value = value
  30
  31
  32 options = []
  33
  34
  35 def o(*args):
  36     options.append(Option(*args, value=False))
  37
  38
  39 def v(*args):
  40     options.append(Option(*args, value=True))
  41
  42
  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")
  71
  72 # Optimization and debugging options. These may be overridden by the release
  73 # channel, etc.
  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")
  85
  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")
  95
  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")
 140
 141 # Used on systems where "cc" is unavailable
 142 v("default-linker", "rust.default-linker", "the default linker")
 143
 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")
 150
 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")
 155
 156 v("set", None, "set arbitrary key/value pairs in TOML configuration")
 157
 158
 159 def p(msg):
 160     print("configure: " + msg)
 161
 162
 163 def err(msg):
 164     print("configure: error: " + msg)
 165     sys.exit(1)
 166
 167
 168 if '--help' in sys.argv or '-h' in sys.argv:
 169     print('Usage: ./configure [options]')
 170     print('')
 171     print('Options')
 172     for option in options:
 173         if 'android' in option.name:
 174             # no one needs to know about these obscure options
 175             continue
 176         if option.value:
 177             print('\t{:30} {}'.format('--{}=VAL'.format(option.name), option.desc))
 178         else:
 179             print('\t{:30} {}'.format('--enable-{}'.format(option.name), option.desc))
 180     print('')
 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')
 187     print('')
 188     print('Also note that all options which take `--enable` can similarly')
 189     print('be passed with `--disable-foo` to forcibly disable the option')
 190     sys.exit(0)
 191
 192 # Parse all command line arguments into one of these three lists, handling
 193 # boolean and value-based options separately
 194 unknown_args = []
 195 need_value_args = []
 196 known_args = {}
 197
 198 p("processing command line")
 199 i = 1
 200 while i < len(sys.argv):
 201     arg = sys.argv[i]
 202     i += 1
 203     if not arg.startswith('--'):
 204         unknown_args.append(arg)
 205         continue
 206
 207     found = False
 208     for option in options:
 209         value = None
 210         if option.value:
 211             keyval = arg[2:].split('=', 1)
 212             key = keyval[0]
 213             if option.name != key:
 214                 continue
 215
 216             if len(keyval) > 1:
 217                 value = keyval[1]
 218             elif i < len(sys.argv):
 219                 value = sys.argv[i]
 220                 i += 1
 221             else:
 222                 need_value_args.append(arg)
 223                 continue
 224         else:
 225             if arg[2:] == 'enable-' + option.name:
 226                 value = True
 227             elif arg[2:] == 'disable-' + option.name:
 228                 value = False
 229             else:
 230                 continue
 231
 232         found = True
 233         if option.name not in known_args:
 234             known_args[option.name] = []
 235         known_args[option.name].append((option, value))
 236         break
 237
 238     if not found:
 239         unknown_args.append(arg)
 240 p("")
 241
 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])
 247 if option_checking:
 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]))
 252
 253 # Parse all known arguments into a configuration structure that reflects the
 254 # TOML we're going to write out
 255 config = {}
 256
 257
 258 def build():
 259     if 'build' in known_args:
 260         return known_args['build'][-1][1]
 261     return bootstrap.default_build_triple()
 262
 263
 264 def set(key, value):
 265     s = "{:20} := {}".format(key, value)
 266     if len(s) < 70:
 267         p(s)
 268     else:
 269         p(s[:70] + " ...")
 270
 271     arr = config
 272     parts = key.split('.')
 273     for i, part in enumerate(parts):
 274         if i == len(parts) - 1:
 275             arr[part] = value
 276         else:
 277             if part not in arr:
 278                 arr[part] = {}
 279             arr = arr[part]
 280
 281
 282 for key in known_args:
 283     # The `set` option is special and can be passed a bunch of times
 284     if key == 'set':
 285         for option, value in known_args[key]:
 286             keyval = value.split('=', 1)
 287             if len(keyval) == 1 or keyval[1] == "true":
 288                 value = True
 289             elif keyval[1] == "false":
 290                 value = False
 291             else:
 292                 value = keyval[1]
 293             set(keyval[0], value)
 294         continue
 295
 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]
 301
 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)
 305         continue
 306
 307     # Otherwise we're a "special" option and need some extra handling, so do
 308     # that here.
 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')
 315                 break
 316         for path in os.environ['PATH'].split(os.pathsep):
 317             if os.path.exists(path + '/cargo'):
 318                 set('build.cargo', path + '/cargo')
 319                 break
 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
 342         pass
 343     else:
 344         raise RuntimeError("unhandled option {}".format(option.name))
 345
 346 set('build.configure-args', sys.argv[1:])
 347
 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.
 351 #
 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.
 354 sections = {}
 355 cur_section = None
 356 sections[None] = []
 357 section_order = [None]
 358 targets = {}
 359
 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)
 369     else:
 370         sections[cur_section].append(line)
 371
 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)
 386
 387
 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.
 392 def to_toml(value):
 393     if isinstance(value, bool):
 394         if value:
 395             return "true"
 396         else:
 397             return "false"
 398     elif isinstance(value, list):
 399         return '[' + ', '.join(map(to_toml, value)) + ']'
 400     elif isinstance(value, str):
 401         return "'" + value + "'"
 402     else:
 403         raise RuntimeError('no toml')
 404
 405
 406 def configure_section(lines, config):
 407     for key in config:
 408         value = config[key]
 409         found = False
 410         for i, line in enumerate(lines):
 411             if not line.startswith('#' + key + ' = '):
 412                 continue
 413             found = True
 414             lines[i] = "{} = {}".format(key, to_toml(value))
 415             break
 416         if not found:
 417             raise RuntimeError("failed to find config line for {}".format(key))
 418
 419
 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))
 424
 425     if section_key == 'target':
 426         for target in section_config:
 427             configure_section(targets[target], section_config[target])
 428     else:
 429         configure_section(sections[section_key], section_config)
 430
 431 # Now that we've built up our `config.toml`, write it all out in the same
 432 # order that we read it in.
 433 p("")
 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]:
 440                     f.write(line + "\n")
 441         else:
 442             for line in sections[section]:
 443                 f.write(line + "\n")
 444
 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)
 450     f.write(contents)
 451
 452 p("")
 453 p("run `python {}/x.py --help`".format(rust_dir))
 454 p("")