src/bootstrap/configure.py

   1 #!/usr/bin/env python
   2
   3 # ignore-tidy-linelength
   4
   5 from __future__ import absolute_import, division, print_function
   6 import sys
   7 import os
   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"))
  12 import bootstrap
  13
  14
  15 class Option(object):
  16     def __init__(self, name, rustbuild, desc, value):
  17         self.name = name
  18         self.rustbuild = rustbuild
  19         self.desc = desc
  20         self.value = value
  21
  22
  23 options = []
  24
  25
  26 def o(*args):
  27     options.append(Option(*args, value=False))
  28
  29
  30 def v(*args):
  31     options.append(Option(*args, value=True))
  32
  33
  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)")
  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("lldb", "rust.lldb", "build lldb")
  61 o("missing-tools", "dist.missing-tools", "allow failures when building tools")
  62 o("use-libcxx", "llvm.use-libcxx", "build LLVM with libc++")
  63
  64 o("cflags", "llvm.cflags", "build LLVM with these extra compiler flags")
  65 o("cxxflags", "llvm.cxxflags", "build LLVM with these extra compiler flags")
  66 o("ldflags", "llvm.ldflags", "build LLVM with these extra linker flags")
  67
  68 o("llvm-libunwind", "rust.llvm-libunwind", "use LLVM libunwind")
  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("optimize-llvm", "llvm.optimize", "build optimized LLVM")
  74 o("llvm-assertions", "llvm.assertions", "build LLVM with assertions")
  75 o("debug-assertions", "rust.debug-assertions", "build with debugging assertions")
  76 o("llvm-release-debuginfo", "llvm.release-debuginfo", "build LLVM with debugger metadata")
  77 v("debuginfo-level", "rust.debuginfo-level", "debuginfo level for Rust code")
  78 v("debuginfo-level-rustc", "rust.debuginfo-level-rustc", "debuginfo level for the compiler")
  79 v("debuginfo-level-std", "rust.debuginfo-level-std", "debuginfo level for the standard library")
  80 v("debuginfo-level-tools", "rust.debuginfo-level-tools", "debuginfo level for the tools")
  81 v("debuginfo-level-tests", "rust.debuginfo-level-tests", "debuginfo level for the test suites run with compiletest")
  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("llvm-config", None, "set path to llvm-config")
  96 v("llvm-filecheck", None, "set path to LLVM's FileCheck utility")
  97 v("python", "build.python", "set path to python")
  98 v("android-cross-path", "target.arm-linux-androideabi.android-ndk",
  99   "Android NDK standalone path (deprecated)")
 100 v("i686-linux-android-ndk", "target.i686-linux-android.android-ndk",
 101   "i686-linux-android NDK standalone path")
 102 v("arm-linux-androideabi-ndk", "target.arm-linux-androideabi.android-ndk",
 103   "arm-linux-androideabi NDK standalone path")
 104 v("armv7-linux-androideabi-ndk", "target.armv7-linux-androideabi.android-ndk",
 105   "armv7-linux-androideabi NDK standalone path")
 106 v("thumbv7neon-linux-androideabi-ndk", "target.thumbv7neon-linux-androideabi.android-ndk",
 107   "thumbv7neon-linux-androideabi NDK standalone path")
 108 v("aarch64-linux-android-ndk", "target.aarch64-linux-android.android-ndk",
 109   "aarch64-linux-android NDK standalone path")
 110 v("x86_64-linux-android-ndk", "target.x86_64-linux-android.android-ndk",
 111   "x86_64-linux-android NDK standalone path")
 112 v("musl-root", "target.x86_64-unknown-linux-musl.musl-root",
 113   "MUSL root installation directory (deprecated)")
 114 v("musl-root-x86_64", "target.x86_64-unknown-linux-musl.musl-root",
 115   "x86_64-unknown-linux-musl install directory")
 116 v("musl-root-i586", "target.i586-unknown-linux-musl.musl-root",
 117   "i586-unknown-linux-musl install directory")
 118 v("musl-root-i686", "target.i686-unknown-linux-musl.musl-root",
 119   "i686-unknown-linux-musl install directory")
 120 v("musl-root-arm", "target.arm-unknown-linux-musleabi.musl-root",
 121   "arm-unknown-linux-musleabi install directory")
 122 v("musl-root-armhf", "target.arm-unknown-linux-musleabihf.musl-root",
 123   "arm-unknown-linux-musleabihf install directory")
 124 v("musl-root-armv5te", "target.armv5te-unknown-linux-musleabi.musl-root",
 125   "armv5te-unknown-linux-musleabi install directory")
 126 v("musl-root-armv7", "target.armv7-unknown-linux-musleabi.musl-root",
 127   "armv7-unknown-linux-musleabi install directory")
 128 v("musl-root-armv7hf", "target.armv7-unknown-linux-musleabihf.musl-root",
 129   "armv7-unknown-linux-musleabihf install directory")
 130 v("musl-root-aarch64", "target.aarch64-unknown-linux-musl.musl-root",
 131   "aarch64-unknown-linux-musl install directory")
 132 v("musl-root-mips", "target.mips-unknown-linux-musl.musl-root",
 133   "mips-unknown-linux-musl install directory")
 134 v("musl-root-mipsel", "target.mipsel-unknown-linux-musl.musl-root",
 135   "mipsel-unknown-linux-musl install directory")
 136 v("musl-root-mips64", "target.mips64-unknown-linux-muslabi64.musl-root",
 137   "mips64-unknown-linux-muslabi64 install directory")
 138 v("musl-root-mips64el", "target.mips64el-unknown-linux-muslabi64.musl-root",
 139   "mips64el-unknown-linux-muslabi64 install directory")
 140 v("qemu-armhf-rootfs", "target.arm-unknown-linux-gnueabihf.qemu-rootfs",
 141   "rootfs in qemu testing, you probably don't want to use this")
 142 v("qemu-aarch64-rootfs", "target.aarch64-unknown-linux-gnu.qemu-rootfs",
 143   "rootfs in qemu testing, you probably don't want to use this")
 144 v("experimental-targets", "llvm.experimental-targets",
 145   "experimental LLVM targets to build")
 146 v("release-channel", "rust.channel", "the name of the release channel to build")
 147
 148 # Used on systems where "cc" is unavailable
 149 v("default-linker", "rust.default-linker", "the default linker")
 150
 151 # Many of these are saved below during the "writing configuration" step
 152 # (others are conditionally saved).
 153 o("manage-submodules", "build.submodules", "let the build manage the git submodules")
 154 o("full-bootstrap", "build.full-bootstrap", "build three compilers instead of two")
 155 o("extended", "build.extended", "build an extended rust tool set")
 156
 157 v("tools", None, "List of extended tools will be installed")
 158 v("build", "build.build", "GNUs ./configure syntax LLVM build triple")
 159 v("host", None, "GNUs ./configure syntax LLVM host triples")
 160 v("target", None, "GNUs ./configure syntax LLVM target triples")
 161
 162 v("set", None, "set arbitrary key/value pairs in TOML configuration")
 163
 164
 165 def p(msg):
 166     print("configure: " + msg)
 167
 168
 169 def err(msg):
 170     print("configure: error: " + msg)
 171     sys.exit(1)
 172
 173
 174 if '--help' in sys.argv or '-h' in sys.argv:
 175     print('Usage: ./configure [options]')
 176     print('')
 177     print('Options')
 178     for option in options:
 179         if 'android' in option.name:
 180             # no one needs to know about these obscure options
 181             continue
 182         if option.value:
 183             print('\t{:30} {}'.format('--{}=VAL'.format(option.name), option.desc))
 184         else:
 185             print('\t{:30} {}'.format('--enable-{}'.format(option.name), option.desc))
 186     print('')
 187     print('This configure script is a thin configuration shim over the true')
 188     print('configuration system, `config.toml`. You can explore the comments')
 189     print('in `config.toml.example` next to this configure script to see')
 190     print('more information about what each option is. Additionally you can')
 191     print('pass `--set` as an argument to set arbitrary key/value pairs')
 192     print('in the TOML configuration if desired')
 193     print('')
 194     print('Also note that all options which take `--enable` can similarly')
 195     print('be passed with `--disable-foo` to forcibly disable the option')
 196     sys.exit(0)
 197
 198 # Parse all command line arguments into one of these three lists, handling
 199 # boolean and value-based options separately
 200 unknown_args = []
 201 need_value_args = []
 202 known_args = {}
 203
 204 p("processing command line")
 205 i = 1
 206 while i < len(sys.argv):
 207     arg = sys.argv[i]
 208     i += 1
 209     if not arg.startswith('--'):
 210         unknown_args.append(arg)
 211         continue
 212
 213     found = False
 214     for option in options:
 215         value = None
 216         if option.value:
 217             keyval = arg[2:].split('=', 1)
 218             key = keyval[0]
 219             if option.name != key:
 220                 continue
 221
 222             if len(keyval) > 1:
 223                 value = keyval[1]
 224             elif i < len(sys.argv):
 225                 value = sys.argv[i]
 226                 i += 1
 227             else:
 228                 need_value_args.append(arg)
 229                 continue
 230         else:
 231             if arg[2:] == 'enable-' + option.name:
 232                 value = True
 233             elif arg[2:] == 'disable-' + option.name:
 234                 value = False
 235             else:
 236                 continue
 237
 238         found = True
 239         if option.name not in known_args:
 240             known_args[option.name] = []
 241         known_args[option.name].append((option, value))
 242         break
 243
 244     if not found:
 245         unknown_args.append(arg)
 246 p("")
 247
 248 # Note: here and a few other places, we use [-1] to apply the *last* value
 249 # passed.  But if option-checking is enabled, then the known_args loop will
 250 # also assert that options are only passed once.
 251 option_checking = ('option-checking' not in known_args
 252                    or known_args['option-checking'][-1][1])
 253 if option_checking:
 254     if len(unknown_args) > 0:
 255         err("Option '" + unknown_args[0] + "' is not recognized")
 256     if len(need_value_args) > 0:
 257         err("Option '{0}' needs a value ({0}=val)".format(need_value_args[0]))
 258
 259 # Parse all known arguments into a configuration structure that reflects the
 260 # TOML we're going to write out
 261 config = {}
 262
 263
 264 def build():
 265     if 'build' in known_args:
 266         return known_args['build'][-1][1]
 267     return bootstrap.default_build_triple()
 268
 269
 270 def set(key, value):
 271     s = "{:20} := {}".format(key, value)
 272     if len(s) < 70:
 273         p(s)
 274     else:
 275         p(s[:70] + " ...")
 276
 277     arr = config
 278     parts = key.split('.')
 279     for i, part in enumerate(parts):
 280         if i == len(parts) - 1:
 281             arr[part] = value
 282         else:
 283             if part not in arr:
 284                 arr[part] = {}
 285             arr = arr[part]
 286
 287
 288 for key in known_args:
 289     # The `set` option is special and can be passed a bunch of times
 290     if key == 'set':
 291         for option, value in known_args[key]:
 292             keyval = value.split('=', 1)
 293             if len(keyval) == 1 or keyval[1] == "true":
 294                 value = True
 295             elif keyval[1] == "false":
 296                 value = False
 297             else:
 298                 value = keyval[1]
 299             set(keyval[0], value)
 300         continue
 301
 302     # Ensure each option is only passed once
 303     arr = known_args[key]
 304     if option_checking and len(arr) > 1:
 305         err("Option '{}' provided more than once".format(key))
 306     option, value = arr[-1]
 307
 308     # If we have a clear avenue to set our value in rustbuild, do so
 309     if option.rustbuild is not None:
 310         set(option.rustbuild, value)
 311         continue
 312
 313     # Otherwise we're a "special" option and need some extra handling, so do
 314     # that here.
 315     if option.name == 'sccache':
 316         set('llvm.ccache', 'sccache')
 317     elif option.name == 'local-rust':
 318         for path in os.environ['PATH'].split(os.pathsep):
 319             if os.path.exists(path + '/rustc'):
 320                 set('build.rustc', path + '/rustc')
 321                 break
 322         for path in os.environ['PATH'].split(os.pathsep):
 323             if os.path.exists(path + '/cargo'):
 324                 set('build.cargo', path + '/cargo')
 325                 break
 326     elif option.name == 'local-rust-root':
 327         set('build.rustc', value + '/bin/rustc')
 328         set('build.cargo', value + '/bin/cargo')
 329     elif option.name == 'llvm-root':
 330         set('target.{}.llvm-config'.format(build()), value + '/bin/llvm-config')
 331     elif option.name == 'llvm-config':
 332         set('target.{}.llvm-config'.format(build()), value)
 333     elif option.name == 'llvm-filecheck':
 334         set('target.{}.llvm-filecheck'.format(build()), value)
 335     elif option.name == 'tools':
 336         set('build.tools', value.split(','))
 337     elif option.name == 'host':
 338         set('build.host', value.split(','))
 339     elif option.name == 'target':
 340         set('build.target', value.split(','))
 341     elif option.name == 'full-tools':
 342         set('rust.codegen-backends', ['llvm'])
 343         set('rust.lld', True)
 344         set('rust.llvm-tools', True)
 345         set('build.extended', True)
 346     elif option.name == 'option-checking':
 347         # this was handled above
 348         pass
 349     else:
 350         raise RuntimeError("unhandled option {}".format(option.name))
 351
 352 set('build.configure-args', sys.argv[1:])
 353
 354 # "Parse" the `config.toml.example` file into the various sections, and we'll
 355 # use this as a template of a `config.toml` to write out which preserves
 356 # all the various comments and whatnot.
 357 #
 358 # Note that the `target` section is handled separately as we'll duplicate it
 359 # per configured target, so there's a bit of special handling for that here.
 360 sections = {}
 361 cur_section = None
 362 sections[None] = []
 363 section_order = [None]
 364 targets = {}
 365
 366 for line in open(rust_dir + '/config.toml.example').read().split("\n"):
 367     if line.startswith('['):
 368         cur_section = line[1:-1]
 369         if cur_section.startswith('target'):
 370             cur_section = 'target'
 371         elif '.' in cur_section:
 372             raise RuntimeError("don't know how to deal with section: {}".format(cur_section))
 373         sections[cur_section] = [line]
 374         section_order.append(cur_section)
 375     else:
 376         sections[cur_section].append(line)
 377
 378 # Fill out the `targets` array by giving all configured targets a copy of the
 379 # `target` section we just loaded from the example config
 380 configured_targets = [build()]
 381 if 'build' in config:
 382     if 'host' in config['build']:
 383         configured_targets += config['build']['host']
 384     if 'target' in config['build']:
 385         configured_targets += config['build']['target']
 386 if 'target' in config:
 387     for target in config['target']:
 388         configured_targets.append(target)
 389 for target in configured_targets:
 390     targets[target] = sections['target'][:]
 391     targets[target][0] = targets[target][0].replace("x86_64-unknown-linux-gnu", target)
 392
 393
 394 def is_number(value):
 395   try:
 396     float(value)
 397     return True
 398   except ValueError:
 399     return False
 400
 401 # Here we walk through the constructed configuration we have from the parsed
 402 # command line arguments. We then apply each piece of configuration by
 403 # basically just doing a `sed` to change the various configuration line to what
 404 # we've got configure.
 405 def to_toml(value):
 406     if isinstance(value, bool):
 407         if value:
 408             return "true"
 409         else:
 410             return "false"
 411     elif isinstance(value, list):
 412         return '[' + ', '.join(map(to_toml, value)) + ']'
 413     elif isinstance(value, str):
 414         # Don't put quotes around numeric values
 415         if is_number(value):
 416             return value
 417         else:
 418             return "'" + value + "'"
 419     else:
 420         raise RuntimeError('no toml')
 421
 422
 423 def configure_section(lines, config):
 424     for key in config:
 425         value = config[key]
 426         found = False
 427         for i, line in enumerate(lines):
 428             if not line.startswith('#' + key + ' = '):
 429                 continue
 430             found = True
 431             lines[i] = "{} = {}".format(key, to_toml(value))
 432             break
 433         if not found:
 434             raise RuntimeError("failed to find config line for {}".format(key))
 435
 436
 437 for section_key in config:
 438     section_config = config[section_key]
 439     if section_key not in sections:
 440         raise RuntimeError("config key {} not in sections".format(section_key))
 441
 442     if section_key == 'target':
 443         for target in section_config:
 444             configure_section(targets[target], section_config[target])
 445     else:
 446         configure_section(sections[section_key], section_config)
 447
 448 # Now that we've built up our `config.toml`, write it all out in the same
 449 # order that we read it in.
 450 p("")
 451 p("writing `config.toml` in current directory")
 452 with bootstrap.output('config.toml') as f:
 453     for section in section_order:
 454         if section == 'target':
 455             for target in targets:
 456                 for line in targets[target]:
 457                     f.write(line + "\n")
 458         else:
 459             for line in sections[section]:
 460                 f.write(line + "\n")
 461
 462 with bootstrap.output('Makefile') as f:
 463     contents = os.path.join(rust_dir, 'src', 'bootstrap', 'mk', 'Makefile.in')
 464     contents = open(contents).read()
 465     contents = contents.replace("$(CFG_SRC_DIR)", rust_dir + '/')
 466     contents = contents.replace("$(CFG_PYTHON)", sys.executable)
 467     f.write(contents)
 468
 469 p("")
 470 p("run `python {}/x.py --help`".format(rust_dir))
 471 p("")