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("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")
  69
  70 # Optimization and debugging options. These may be overridden by the release
  71 # channel, etc.
  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")
  83
  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")
  93
  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")
 136
 137 # Used on systems where "cc" is unavailable
 138 v("default-linker", "rust.default-linker", "the default linker")
 139
 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")
 146
 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")
 150
 151 v("set", None, "set arbitrary key/value pairs in TOML configuration")
 152
 153
 154 def p(msg):
 155     print("configure: " + msg)
 156
 157
 158 def err(msg):
 159     print("configure: error: " + msg)
 160     sys.exit(1)
 161
 162
 163 if '--help' in sys.argv or '-h' in sys.argv:
 164     print('Usage: ./configure [options]')
 165     print('')
 166     print('Options')
 167     for option in options:
 168         if 'android' in option.name:
 169             # no one needs to know about these obscure options
 170             continue
 171         if option.value:
 172             print('\t{:30} {}'.format('--{}=VAL'.format(option.name), option.desc))
 173         else:
 174             print('\t{:30} {}'.format('--enable-{}'.format(option.name), option.desc))
 175     print('')
 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')
 182     print('')
 183     print('Also note that all options which take `--enable` can similarly')
 184     print('be passed with `--disable-foo` to forcibly disable the option')
 185     sys.exit(0)
 186
 187 # Parse all command line arguments into one of these three lists, handling
 188 # boolean and value-based options separately
 189 unknown_args = []
 190 need_value_args = []
 191 known_args = {}
 192
 193 p("processing command line")
 194 i = 1
 195 while i < len(sys.argv):
 196     arg = sys.argv[i]
 197     i += 1
 198     if not arg.startswith('--'):
 199         unknown_args.append(arg)
 200         continue
 201
 202     found = False
 203     for option in options:
 204         value = None
 205         if option.value:
 206             keyval = arg[2:].split('=', 1)
 207             key = keyval[0]
 208             if option.name != key:
 209                 continue
 210
 211             if len(keyval) > 1:
 212                 value = keyval[1]
 213             elif i < len(sys.argv):
 214                 value = sys.argv[i]
 215                 i += 1
 216             else:
 217                 need_value_args.append(arg)
 218                 continue
 219         else:
 220             if arg[2:] == 'enable-' + option.name:
 221                 value = True
 222             elif arg[2:] == 'disable-' + option.name:
 223                 value = False
 224             else:
 225                 continue
 226
 227         found = True
 228         if option.name not in known_args:
 229             known_args[option.name] = []
 230         known_args[option.name].append((option, value))
 231         break
 232
 233     if not found:
 234         unknown_args.append(arg)
 235 p("")
 236
 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])
 242 if option_checking:
 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]))
 247
 248 # Parse all known arguments into a configuration structure that reflects the
 249 # TOML we're going to write out
 250 config = {}
 251
 252
 253 def build():
 254     if 'build' in known_args:
 255         return known_args['build'][-1][1]
 256     return bootstrap.default_build_triple()
 257
 258
 259 def set(key, value):
 260     s = "{:20} := {}".format(key, value)
 261     if len(s) < 70:
 262         p(s)
 263     else:
 264         p(s[:70] + " ...")
 265
 266     arr = config
 267     parts = key.split('.')
 268     for i, part in enumerate(parts):
 269         if i == len(parts) - 1:
 270             arr[part] = value
 271         else:
 272             if part not in arr:
 273                 arr[part] = {}
 274             arr = arr[part]
 275
 276
 277 for key in known_args:
 278     # The `set` option is special and can be passed a bunch of times
 279     if key == 'set':
 280         for option, value in known_args[key]:
 281             keyval = value.split('=', 1)
 282             if len(keyval) == 1 or keyval[1] == "true":
 283                 value = True
 284             elif keyval[1] == "false":
 285                 value = False
 286             else:
 287                 value = keyval[1]
 288             set(keyval[0], value)
 289         continue
 290
 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]
 296
 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)
 300         continue
 301
 302     # Otherwise we're a "special" option and need some extra handling, so do
 303     # that here.
 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')
 310                 break
 311         for path in os.environ['PATH'].split(os.pathsep):
 312             if os.path.exists(path + '/cargo'):
 313                 set('build.cargo', path + '/cargo')
 314                 break
 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
 330         pass
 331     else:
 332         raise RuntimeError("unhandled option {}".format(option.name))
 333
 334 set('build.configure-args', sys.argv[1:])
 335
 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.
 339 #
 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.
 342 sections = {}
 343 cur_section = None
 344 sections[None] = []
 345 section_order = [None]
 346 targets = {}
 347
 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)
 357     else:
 358         sections[cur_section].append(line)
 359
 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)
 374
 375
 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.
 380 def to_toml(value):
 381     if isinstance(value, bool):
 382         if value:
 383             return "true"
 384         else:
 385             return "false"
 386     elif isinstance(value, list):
 387         return '[' + ', '.join(map(to_toml, value)) + ']'
 388     elif isinstance(value, str):
 389         return "'" + value + "'"
 390     else:
 391         raise RuntimeError('no toml')
 392
 393
 394 def configure_section(lines, config):
 395     for key in config:
 396         value = config[key]
 397         found = False
 398         for i, line in enumerate(lines):
 399             if not line.startswith('#' + key + ' = '):
 400                 continue
 401             found = True
 402             lines[i] = "{} = {}".format(key, to_toml(value))
 403             break
 404         if not found:
 405             raise RuntimeError("failed to find config line for {}".format(key))
 406
 407
 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))
 412
 413     if section_key == 'target':
 414         for target in section_config:
 415             configure_section(targets[target], section_config[target])
 416     else:
 417         configure_section(sections[section_key], section_config)
 418
 419 # Now that we've built up our `config.toml`, write it all out in the same
 420 # order that we read it in.
 421 p("")
 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]:
 428                     f.write(line + "\n")
 429         else:
 430             for line in sections[section]:
 431                 f.write(line + "\n")
 432
 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)
 438     f.write(contents)
 439
 440 p("")
 441 p("run `python {}/x.py --help`".format(rust_dir))
 442 p("")