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