---

yaml
---
r: 278166
b: refs/heads/auto
c: 0d5f474
h: refs/heads/master

Author: murarth

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 32683ce1930ef1390f20e4ab72650e6804fd1c1b
+refs/heads/auto: 0d5f474f30563383aa0c72ec84d3f2c26fa1c348
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/Makefile.in

@@ -59,8 +59,9 @@
 #   * check-stage$(stage)-$(crate) - Test a crate in a specific stage
 #   * check-stage$(stage)-{rpass,rfail,cfail,rmake,...} - Run tests in src/test/
 #   * check-stage1-T-$(target)-H-$(host) - Run cross-compiled-tests
-#   * tidy - Basic style check, show highest rustc error code and
-#     the status of language and lib features
+#   * tidy-basic - show file / line stats
+#   * tidy-errors - show the highest rustc error code
+#   * tidy-features - show the status of language and lib features
 #   * rustc-stage$(stage) - Only build up to a specific stage
 #
 # Then mix in some of these environment variables to harness the

branches/auto/configure

@@ -632,7 +632,6 @@ valopt build "${DEFAULT_BUILD}" "GNUs ./configure syntax LLVM build triple"
 valopt android-cross-path "" "Android NDK standalone path (deprecated)"
 valopt i686-linux-android-ndk "" "i686-linux-android NDK standalone path"
 valopt arm-linux-androideabi-ndk "" "arm-linux-androideabi NDK standalone path"
-valopt armv7-linux-androideabi-ndk "" "armv7-linux-androideabi NDK standalone path"
 valopt aarch64-linux-android-ndk "" "aarch64-linux-android NDK standalone path"
 valopt nacl-cross-path  "" "NaCl SDK path (Pepper Canary is recommended). Must be absolute!"
 valopt release-channel "dev" "the name of the release channel to build"
@@ -1145,15 +1144,6 @@ do
 
     case $i in
         *android*)
-            case $i in
-                armv7-linux-androideabi)
-                    cmd_prefix="arm-linux-androideabi"
-                    ;;
-                *)
-                    cmd_prefix=$i
-                    ;;
-            esac
-
             upper_snake_target=$(echo "$i" | tr '[:lower:]' '[:upper:]' | tr '\-' '\_')
             eval ndk=\$"CFG_${upper_snake_target}_NDK"
             if [ -z "$ndk" ]
@@ -1164,7 +1154,7 @@ do
             fi
 
             # Perform a basic sanity check of the NDK
-            for android_ndk_tool in "$ndk/bin/$cmd_prefix-gcc" "$ndk/bin/$cmd_prefix-g++" "$ndk/bin/$cmd_prefix-ar"
+            for android_ndk_tool in "$ndk/bin/$i-gcc" "$ndk/bin/$i-g++" "$ndk/bin/$i-ar"
             do
                 if [ ! -f $android_ndk_tool ]
                 then
@@ -1796,7 +1786,6 @@ putvar CFG_LIBDIR_RELATIVE
 putvar CFG_DISABLE_MANAGE_SUBMODULES
 putvar CFG_AARCH64_LINUX_ANDROID_NDK
 putvar CFG_ARM_LINUX_ANDROIDEABI_NDK
-putvar CFG_ARMV7_LINUX_ANDROIDEABI_NDK
 putvar CFG_I686_LINUX_ANDROID_NDK
 putvar CFG_NACL_CROSS_PATH
 putvar CFG_MANDIR

branches/auto/mk/cfg/armv7-linux-androideabi.mk

@@ -111,7 +111,7 @@ DEPS_rustc_lint := rustc log syntax rustc_const_eval
 DEPS_rustc_llvm := native:rustllvm libc std rustc_bitflags
 DEPS_rustc_metadata := rustc syntax rbml rustc_const_math
 DEPS_rustc_passes := syntax rustc core rustc_const_eval
-DEPS_rustc_mir := rustc syntax rustc_const_math rustc_const_eval rustc_bitflags
+DEPS_rustc_mir := rustc syntax rustc_const_math rustc_const_eval
 DEPS_rustc_resolve := arena rustc log syntax
 DEPS_rustc_platform_intrinsics := std
 DEPS_rustc_plugin := rustc rustc_metadata syntax rustc_mir

branches/auto/mk/crates.mk

@@ -15,21 +15,14 @@
 
 .PHONY: TAGS.emacs TAGS.vi
 
-CTAGS_RUSTC_LOCATIONS=$(patsubst ${CFG_SRC_DIR}src/lib%test,, \
-				$(wildcard ${CFG_SRC_DIR}src/lib*)) ${CFG_SRC_DIR}src/libtest
+CTAGS_LOCATIONS=$(wildcard ${CFG_SRC_DIR}src/lib*)
 CTAGS_LOCATIONS=$(patsubst ${CFG_SRC_DIR}src/librust%,, \
                 $(patsubst ${CFG_SRC_DIR}src/lib%test,, \
 				$(wildcard ${CFG_SRC_DIR}src/lib*))) ${CFG_SRC_DIR}src/libtest
-CTAGS_OPTS=--options="${CFG_SRC_DIR}src/etc/ctags.rust" --languages=Rust --recurse
-
-TAGS.rustc.emacs:
-	ctags -e -f $@ ${CTAGS_OPTS} ${CTAGS_RUSTC_LOCATIONS}
+CTAGS_OPTS=--options="${CFG_SRC_DIR}src/etc/ctags.rust" --languages=Rust --recurse ${CTAGS_LOCATIONS}
 
 TAGS.emacs:
-	ctags -e -f $@ ${CTAGS_OPTS} ${CTAGS_LOCATIONS}
-
-TAGS.rustc.vi:
-	ctags -f $@ ${CTAGS_OPTS} ${CTAGS_RUSTC_LOCATIONS}
+	ctags -e -f $@ ${CTAGS_OPTS}
 
 TAGS.vi:
-	ctags -f $@ ${CTAGS_OPTS} ${CTAGS_LOCATIONS}
+	ctags -f $@ ${CTAGS_OPTS}

branches/auto/mk/ctags.mk

@@ -77,7 +77,6 @@ $(PKG_TAR): $(PKG_FILES)
 	$(Q)mkdir -p tmp/dist/$(PKG_NAME)
 	$(Q)tar \
          -C $(S) \
-         -f - \
          --exclude-vcs \
          --exclude=*~ \
          --exclude=*.pyc \
@@ -87,7 +86,7 @@ $(PKG_TAR): $(PKG_FILES)
          --exclude=*/llvm/test/*/*/*.ll \
          --exclude=*/llvm/test/*/*/*.td \
          --exclude=*/llvm/test/*/*/*.s \
-         -c $(UNROOTED_PKG_FILES) | tar -x -f - -C tmp/dist/$(PKG_NAME)
+         -c $(UNROOTED_PKG_FILES) | tar -x -C tmp/dist/$(PKG_NAME)
 	@$(call E, making $@)
 	$(Q)tar -czf $(PKG_TAR) -C tmp/dist $(PKG_NAME)
 	$(Q)rm -Rf tmp/dist/$(PKG_NAME)

branches/auto/mk/dist.mk

@@ -169,7 +169,7 @@ ifdef CFG_CCACHE_BASEDIR
   export CCACHE_BASEDIR
 endif
 
-FIND_COMPILER = $(strip $(1:ccache=))
+FIND_COMPILER = $(word 1,$(1:ccache=))
 
 define CFG_MAKE_TOOLCHAIN
   # Prepend the tools with their prefix if cross compiling
@@ -187,7 +187,7 @@ define CFG_MAKE_TOOLCHAIN
     endif
   endif
 
-  CFG_COMPILE_C_$(1) = '$$(call FIND_COMPILER,$$(CC_$(1)))' \
+  CFG_COMPILE_C_$(1) = '$$(CC_$(1))' \
         $$(CFLAGS) \
         $$(CFG_GCCISH_CFLAGS) \
         $$(CFG_GCCISH_CFLAGS_$(1)) \
@@ -198,7 +198,7 @@ define CFG_MAKE_TOOLCHAIN
         $$(CFG_GCCISH_LINK_FLAGS_$(1)) \
         $$(CFG_GCCISH_DEF_FLAG_$(1))$$(3) $$(2) \
         $$(call CFG_INSTALL_NAME_$(1),$$(4))
-  CFG_COMPILE_CXX_$(1) = '$$(call FIND_COMPILER,$$(CXX_$(1)))' \
+  CFG_COMPILE_CXX_$(1) = '$$(CXX_$(1))' \
         $$(CXXFLAGS) \
         $$(CFG_GCCISH_CFLAGS) \
         $$(CFG_GCCISH_CXXFLAGS) \

branches/auto/mk/platform.mk

@@ -635,8 +635,8 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) = \
         --host-rustcflags "$(RUSTC_FLAGS_$(3)) $$(CTEST_RUSTC_FLAGS) -L $$(RT_OUTPUT_DIR_$(3))" \
         --lldb-python-dir=$(CFG_LLDB_PYTHON_DIR) \
         --target-rustcflags "$(RUSTC_FLAGS_$(2)) $$(CTEST_RUSTC_FLAGS) -L $$(RT_OUTPUT_DIR_$(2))" \
-	--cc '$$(call FIND_COMPILER,$$(CC_$(2)))' \
-	--cxx '$$(call FIND_COMPILER,$$(CXX_$(2)))' \
+	--cc '$$(CC_$(2))' \
+	--cxx '$$(CXX_$(2))' \
 	--cflags "$$(CFG_GCCISH_CFLAGS_$(2))" \
 	--llvm-components "$$(LLVM_ALL_COMPONENTS_$(2))" \
 	--llvm-cxxflags "$$(LLVM_CXXFLAGS_$(2))" \

branches/auto/mk/tests.mk

@@ -1,4 +1,4 @@
-# rustbuild - Bootstrapping Rust
+# Bootstrapping Rust
 
 This is an in-progress README which is targeted at helping to explain how Rust
 is bootstrapped and in general some of the technical details of the build
@@ -8,64 +8,20 @@ system.
 > intended to be the primarily used one just yet. The makefiles are currently
 > the ones that are still "guaranteed to work" as much as possible at least.
 
-## Using rustbuild
+## Using the new build system
 
 When configuring Rust via `./configure`, pass the following to enable building
 via this build system:
 
 ```
 ./configure --enable-rustbuild
-make
 ```
 
-Afterwards the `Makefile` which is generated will have a few commands like
-`make check`, `make tidy`, etc. For finer-grained control, the
-`bootstrap.py` entry point can be used:
-
-```
-python src/bootstrap/bootstrap.py
-```
-
-This accepts a number of options like `--stage` and `--step` which can configure
-what's actually being done.
-
-## Configuring rustbuild
-
-There are currently two primary methods for configuring the rustbuild build
-system. First, the `./configure` options serialized in `config.mk` will be
-parsed and read. That is, if any `./configure` options are passed, they'll be
-handled naturally.
-
-Next, rustbuild offers a TOML-based configuration system with a `config.toml`
-file in the same location as `config.mk`. An example of this configuration can
-be found at `src/bootstrap/config.toml.example`, and the configuration file
-can also be passed as `--config path/to/config.toml` if the build system is
-being invoked manually (via the python script).
-
-## Build stages
-
-The rustbuild build system goes through a few phases to actually build the
-compiler. What actually happens when you invoke rustbuild is:
-
-1. The entry point script, `src/bootstrap/bootstrap.py` is run. This script is
-   responsible for downloading the stage0 compiler/Cargo binaries, and it then
-   compiles the build system itself (this folder). Finally, it then invokes the
-   actual `boostrap` binary build system.
-2. In Rust, `bootstrap` will slurp up all configuration, perform a number of
-   sanity checks (compilers exist for example), and then start building the
-   stage0 artifacts.
-3. The stage0 `cargo` downloaded earlier is used to build the standard library
-   and the compiler, and then these binaries are then copied to the `stage1`
-   directory. That compiler is then used to generate the stage1 artifacts which
-   are then copied to the stage2 directory, and then finally the stage2
-   artifacts are generated using that compiler.
-
-The goal of each stage is to (a) leverage Cargo as much as possible and failing
-that (b) leverage Rust as much as possible!
+## ...
 
 ## Directory Layout
 
-This build system houses all output under the `build` directory, which looks
+This build system houses all output under the `target` directory, which looks
 like this:
 
 ```
@@ -86,12 +42,6 @@ build/
     debug/
     release/
 
-  # Output of the dist-related steps like dist-std, dist-rustc, and dist-docs
-  dist/
-
-  # Temporary directory used for various input/output as part of various stages
-  tmp/
-
   # Each remaining directory is scoped by the "host" triple of compilation at
   # hand.
   x86_64-unknown-linux-gnu/
@@ -100,8 +50,7 @@ build/
     # folder is under. The exact layout here will likely depend on the platform,
     # and this is also built with CMake so the build system is also likely
     # different.
-    compiler-rt/
-      build/
+    compiler-rt/build/
 
     # Output folder for LLVM if it is compiled for this target
     llvm/
@@ -118,17 +67,6 @@ build/
       share/
       ...
 
-    # Output folder for all documentation of this target. This is what's filled
-    # in whenever the `doc` step is run.
-    doc/
-
-    # Output for all compiletest-based test suites
-    test/
-      run-pass/
-      compile-fail/
-      debuginfo/
-      ...
-
     # Location where the stage0 Cargo and Rust compiler are unpacked. This
     # directory is purely an extracted and overlaid tarball of these two (done
     # by the bootstrapy python script). In theory the build system does not
@@ -144,9 +82,7 @@ build/
     # invocation. The build system instruments calling Cargo in the right order
     # with the right variables to ensure these are filled in correctly.
     stageN-std/
-    stageN-test/
     stageN-rustc/
-    stageN-tools/
 
     # This is a special case of the above directories, **not** filled in via
     # Cargo but rather the build system itself. The stage0 compiler already has
@@ -160,7 +96,7 @@ build/
     # Basically this directory is just a temporary artifact use to configure the
     # stage0 compiler to ensure that the libstd we just built is used to
     # compile the stage1 compiler.
-    stage0-sysroot/lib/
+    stage0-rustc/lib/
 
     # These output directories are intended to be standalone working
     # implementations of the compiler (corresponding to each stage). The build
@@ -172,69 +108,3 @@ build/
     stage2/
     stage3/
 ```
-
-## Cargo projects
-
-The current build is unfortunately not quite as simple as `cargo build` in a
-directory, but rather the compiler is split into three different Cargo projects:
-
-* `src/rustc/std_shim` - a project which builds and compiles libstd
-* `src/rustc/test_shim` - a project which builds and compiles libtest
-* `src/rustc` - the actual compiler itself
-
-Each "project" has a corresponding Cargo.lock file with all dependencies, and
-this means that building the compiler involves running Cargo three times. The
-structure here serves two goals:
-
-1. Facilitating dependencies coming from crates.io. These dependencies don't
-   depend on `std`, so libstd is a separate project compiled ahead of time
-   before the actual compiler builds.
-2. Splitting "host artifacts" from "target artifacts". That is, when building
-   code for an arbitrary target you don't need the entire compiler, but you'll
-   end up needing libraries like libtest that depend on std but also want to use
-   crates.io dependencies. Hence, libtest is split out as its own project that
-   is sequenced after `std` but before `rustc`. This project is built for all
-   targets.
-
-There is some loss in build parallelism here because libtest can be compiled in
-parallel with a number of rustc artifacts, but in theory the loss isn't too bad!
-
-## Build tools
-
-We've actually got quite a few tools that we use in the compiler's build system
-and for testing. To organize these, each tool is a project in `src/tools` with a
-corresponding `Cargo.toml`. All tools are compiled with Cargo (currently having
-independent `Cargo.lock` files) and do not currently explicitly depend on the
-compiler or standard library. Compiling each tool is sequenced after the
-appropriate libstd/libtest/librustc compile above.
-
-## Extending rustbuild
-
-So you'd like to add a feature to the rustbuild build system or just fix a bug.
-Great! One of the major motivational factors for moving away from `make` is that
-Rust is in theory much easier to read, modify, and write. If you find anything
-excessively confusing, please open an issue on this and we'll try to get it
-documented or simplified pronto.
-
-First up, you'll probably want to read over the documentation above as that'll
-give you a high level overview of what rustbuild is doing. You also probably
-want to play around a bit yourself by just getting it up and running before you
-dive too much into the actual build system itself.
-
-After that, each module in rustbuild should have enough documentation to keep
-you up and running. Some general areas that you may be interested in modifying
-are:
-
-* Adding a new build tool? Take a look at `build/step.rs` for examples of other
-  tools, as well as `build/mod.rs`.
-* Adding a new compiler crate? Look no further! Adding crates can be done by
-  adding a new directory with `Cargo.toml` followed by configuring all
-  `Cargo.toml` files accordingly.
-* Adding a new dependency from crates.io? We're still working on that, so hold
-  off on that for now.
-* Adding a new configuration option? Take a look at `build/config.rs` or perhaps
-  `build/flags.rs` and then modify the build elsewhere to read that option.
-* Adding a sanity check? Take a look at `build/sanity.rs`.
-
-If you have any questions feel free to reach out on `#rust-internals` on IRC or
-open an issue in the bug tracker!