---

yaml
---
r: 217527
b: refs/heads/tmp
c: d6159b7
h: refs/heads/master
i:
  217525: 7b3bd53
  217523: 1903cfd
  217519: 0114e62
v: v3

Author: saser

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: 2ad26e850ed5dfedda8c96d7315aee50145ceedd
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 34f35a535aa45d17688bc977dd826e2e1d79cef4
+refs/heads/tmp: d6159b7fe0ce668b6875d4551019d3946ed8388c
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: a5286998df566e736b32f6795bfc3803bdaf453d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/.gitignore

@@ -19,7 +19,6 @@
 *.exe
 *.fn
 *.html
-*.kdev4
 *.ky
 *.ll
 *.llvm

branches/tmp/Makefile.in

@@ -62,7 +62,6 @@
 #   * 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
 # ultimate power of The Rust Build System.
@@ -91,7 +90,7 @@
 #
 # # Rust recipes for build system success
 #
-#     // Modifying libstd? Use this command to run unit tests just on your change
+#     // Modifying libstd? Use this comment to run unit tests just on your change
 #     make check-stage1-std NO_REBUILD=1 NO_BENCH=1
 #
 #     // Added a run-pass test? Use this to test running your test

branches/tmp/configure

@@ -1114,7 +1114,7 @@ do
             fi
             ;;
 
-        *-msvc)
+        x86_64-*-msvc)
             # Currently the build system is not configured to build jemalloc
             # with MSVC, so we omit this optional dependency.
             step_msg "targeting MSVC, disabling jemalloc"
@@ -1154,45 +1154,22 @@ do
             CFG_MSVC_ROOT=$(echo "$install" | grep InstallDir | sed 's/.*REG_SZ[ ]*//')
             CFG_MSVC_ROOT=$(dirname "$CFG_MSVC_ROOT")
             CFG_MSVC_ROOT=$(dirname "$CFG_MSVC_ROOT")
-            putvar CFG_MSVC_ROOT
-
-            case $i in
-                x86_64-*)
-                    bits=x86_64
-                    msvc_part=amd64
-                    ;;
-                i686-*)
-                    bits=i386
-                    msvc_part=
-                    ;;
-                *)
-                    err "can only target x86 targets for MSVC"
-                    ;;
-            esac
-            bindir="${CFG_MSVC_ROOT}/VC/bin"
-            if [ ! -z "$msvc_part" ]; then
-                bindir="$bindir/$msvc_part"
-            fi
-            eval CFG_MSVC_BINDIR_$bits="\"$bindir\""
-            eval CFG_MSVC_CL_$bits="\"$bindir/cl.exe\""
-            eval CFG_MSVC_LIB_$bits="\"$bindir/lib.exe\""
-            eval CFG_MSVC_LINK_$bits="\"$bindir/link.exe\""
+            CFG_MSVC_CL="${CFG_MSVC_ROOT}/VC/bin/amd64/cl.exe"
+            CFG_MSVC_LIB="${CFG_MSVC_ROOT}/VC/bin/amd64/lib.exe"
+            CFG_MSVC_LINK="${CFG_MSVC_ROOT}/VC/bin/amd64/link.exe"
 
             vcvarsall="${CFG_MSVC_ROOT}/VC/vcvarsall.bat"
-            include_path=$(cmd /c "\"$vcvarsall\" $msvc_part && cmd /c echo %INCLUDE%")
+            CFG_MSVC_INCLUDE_PATH=$(cmd /c "\"$vcvarsall\" amd64 && cmd /c echo %INCLUDE%")
             need_ok "failed to learn about MSVC's INCLUDE"
-            lib_path=$(cmd /c "\"$vcvarsall\" $msvc_part && cmd /c echo %LIB%")
+            CFG_MSVC_LIB_PATH=$(cmd /c "\"$vcvarsall\" amd64 && cmd /c echo %LIB%")
             need_ok "failed to learn about MSVC's LIB"
 
-            eval CFG_MSVC_INCLUDE_PATH_${bits}="\"$include_path\""
-            eval CFG_MSVC_LIB_PATH_${bits}="\"$lib_path\""
-
-            putvar CFG_MSVC_BINDIR_${bits}
-            putvar CFG_MSVC_CL_${bits}
-            putvar CFG_MSVC_LIB_${bits}
-            putvar CFG_MSVC_LINK_${bits}
-            putvar CFG_MSVC_INCLUDE_PATH_${bits}
-            putvar CFG_MSVC_LIB_PATH_${bits}
+            putvar CFG_MSVC_ROOT
+            putvar CFG_MSVC_CL
+            putvar CFG_MSVC_LIB
+            putvar CFG_MSVC_LINK
+            putvar CFG_MSVC_INCLUDE_PATH
+            putvar CFG_MSVC_LIB_PATH
             ;;
 
         *)
@@ -1431,19 +1408,8 @@ do
 
         msg "configuring LLVM with:"
         msg "$CMAKE_ARGS"
-        case "$t" in
-            x86_64-*)
-                generator="Visual Studio 12 2013 Win64"
-                ;;
-            i686-*)
-                generator="Visual Studio 12 2013"
-                ;;
-            *)
-                err "can only build LLVM for x86 platforms"
-                ;;
-        esac
         (cd $LLVM_BUILD_DIR && "$CFG_CMAKE" $CFG_LLVM_SRC_DIR \
-                                            -G "$generator" \
+                                            -G "Visual Studio 12 2013 Win64" \
                                             $CMAKE_ARGS)
         need_ok "LLVM cmake configure failed"
     fi

branches/tmp/mk/cfg/i686-pc-windows-msvc.mk

@@ -1,9 +1,9 @@
 # x86_64-pc-windows-msvc configuration
-CC_x86_64-pc-windows-msvc="$(CFG_MSVC_CL_x86_64)" -nologo
-LINK_x86_64-pc-windows-msvc="$(CFG_MSVC_LINK_x86_64)" -nologo
-CXX_x86_64-pc-windows-msvc="$(CFG_MSVC_CL_x86_64)" -nologo
-CPP_x86_64-pc-windows-msvc="$(CFG_MSVC_CL_x86_64)" -nologo
-AR_x86_64-pc-windows-msvc="$(CFG_MSVC_LIB_x86_64)" -nologo
+CC_x86_64-pc-windows-msvc="$(CFG_MSVC_CL)" -nologo
+LINK_x86_64-pc-windows-msvc="$(CFG_MSVC_LINK)" -nologo
+CXX_x86_64-pc-windows-msvc="$(CFG_MSVC_CL)" -nologo
+CPP_x86_64-pc-windows-msvc="$(CFG_MSVC_CL)" -nologo
+AR_x86_64-pc-windows-msvc="$(CFG_MSVC_LIB)" -nologo
 CFG_LIB_NAME_x86_64-pc-windows-msvc=$(1).dll
 CFG_STATIC_LIB_NAME_x86_64-pc-windows-msvc=$(1).lib
 CFG_LIB_GLOB_x86_64-pc-windows-msvc=$(1)-*.{dll,lib}

branches/tmp/mk/cfg/x86_64-pc-windows-msvc.mk

@@ -239,6 +239,23 @@ endef
 $(foreach target,$(CFG_TARGET), \
   $(eval $(call CFG_MAKE_TOOLCHAIN,$(target))))
 
+# These two environment variables are scraped by the `./configure` script and
+# are necessary for `cl.exe` to find standard headers (the INCLUDE variable) and
+# for `link.exe` to find standard libraries (the LIB variable).
+ifdef CFG_MSVC_INCLUDE_PATH
+export INCLUDE := $(CFG_MSVC_INCLUDE_PATH)
+endif
+ifdef CFG_MSVC_LIB_PATH
+export LIB := $(CFG_MSVC_LIB_PATH)
+endif
+
+# Unfortunately `link.exe` is also a program in `/usr/bin` on MinGW installs,
+# but it's not the one that we want. As a result we make sure that our detected
+# `link.exe` shows up in PATH first.
+ifdef CFG_MSVC_LINK
+export PATH := $(CFG_MSVC_ROOT)/VC/bin/amd64:$(PATH)
+endif
+
 # There are more comments about this available in the target specification for
 # Windows MSVC in the compiler, but the gist of it is that we use `llvm-ar.exe`
 # instead of `lib.exe` for assembling archives, so we need to inject this custom
@@ -290,4 +307,3 @@ endef
 
 $(foreach target,$(CFG_TARGET), \
   $(eval $(call ADD_RUSTC_LLVM_DEF_TO_MSVC,$(target))))
-

branches/tmp/mk/platform.mk

@@ -55,11 +55,7 @@ NATIVE_DEPS_rust_builtin_$(1) := rust_builtin.c \
 			rust_android_dummy.c
 NATIVE_DEPS_rustrt_native_$(1) := arch/$$(HOST_$(1))/record_sp.S
 ifeq ($$(findstring msvc,$(1)),msvc)
-ifeq ($$(findstring i686,$(1)),i686)
-NATIVE_DEPS_rustrt_native_$(1) += rust_try_msvc_32.ll
-else
 NATIVE_DEPS_rustrt_native_$(1) += rust_try_msvc_64.ll
-endif
 else
 NATIVE_DEPS_rustrt_native_$(1) += rust_try.ll
 endif
@@ -97,17 +93,6 @@ $$(RT_OUTPUT_DIR_$(1))/%.o: $(S)src/rt/%.S $$(MKFILE_DEPS) \
 	@mkdir -p $$(@D)
 	@$$(call E, compile: $$@)
 	$$(Q)$$(call CFG_ASSEMBLE_$(1),$$@,$$<)
-
-# On MSVC targets the compiler's default include path (e.g. where to find system
-# headers) is specified by the INCLUDE environment variable. This may not be set
-# so the ./configure script scraped the relevant values and this is the location
-# that we put them into cl.exe's environment.
-ifeq ($$(findstring msvc,$(1)),msvc)
-$$(RT_OUTPUT_DIR_$(1))/%.o: \
-	export INCLUDE := $$(CFG_MSVC_INCLUDE_PATH_$$(HOST_$(1)))
-$(1)/rustllvm/%.o: \
-	export INCLUDE := $$(CFG_MSVC_INCLUDE_PATH_$$(HOST_$(1)))
-endif
 endef
 
 $(foreach target,$(CFG_TARGET),$(eval $(call NATIVE_LIBRARIES,$(target))))
@@ -255,12 +240,8 @@ COMPRT_CFLAGS_$(1) := $$(CFG_GCCISH_CFLAGS_$(1))
 ifeq ($$(findstring msvc,$(1)),msvc)
 COMPRT_CC_$(1) := gcc
 COMPRT_AR_$(1) := ar
-ifeq ($$(findstring i686,$(1)),i686)
-COMPRT_CFLAGS_$(1) := $$(CFG_GCCISH_CFLAGS_$(1)) -m32
-else
 COMPRT_CFLAGS_$(1) := $$(CFG_GCCISH_CFLAGS_$(1)) -m64
 endif
-endif
 
 $$(COMPRT_LIB_$(1)): $$(COMPRT_DEPS) $$(MKFILE_DEPS)
 	@$$(call E, make: compiler-rt)

branches/tmp/mk/rt.mk

@@ -220,40 +220,3 @@ $(foreach target,$(CFG_TARGET), \
  $(foreach crate,$(CRATES), \
   $(foreach tool,$(NATIVE_TOOL_DEPS_$(crate)_T_$(target)), \
    $(eval $(call MOVE_TOOLS_TO_SNAPSHOT_HOST_DIR,0,$(target),$(BOOTSTRAP_FROM_$(target)),$(crate),$(tool))))))
-
-# For MSVC targets we need to set up some environment variables for the linker
-# to work correctly when building Rust crates. These two variables are:
-#
-# - LIB tells the linker the default search path for finding system libraries,
-#   for example kernel32.dll
-# - PATH needs to be modified to ensure that MSVC's link.exe is first in the
-#   path instead of MinGW's /usr/bin/link.exe (entirely unrelated)
-#
-# The values for these variables are detected by the configure script.
-define SETUP_LIB_MSVC_ENV_VARS
-ifeq ($$(findstring msvc,$(2)),msvc)
-$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
-	export LIB := $$(CFG_MSVC_LIB_PATH_$$(HOST_$(2)))
-$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
-	export PATH := $$(CFG_MSVC_BINDIR_$$(HOST_$(2))):$$(PATH)
-endif
-endef
-define SETUP_TOOL_MSVC_ENV_VARS
-ifeq ($$(findstring msvc,$(2)),msvc)
-$$(TBIN$(1)_T_$(2)_H_$(3))/$(4)$$(X_$(2)): \
-	export LIB := $$(CFG_MSVC_LIB_PATH_$$(HOST_$(2)))
-$$(TBIN$(1)_T_$(2)_H_$(3))/$(4)$$(X_$(2)): \
-	export PATH := $$(CFG_MSVC_BINDIR_$$(HOST_$(2))):$$(PATH)
-endif
-endef
-
-$(foreach host,$(CFG_HOST), \
- $(foreach target,$(CFG_TARGET), \
-  $(foreach stage,$(STAGES), \
-   $(foreach crate,$(CRATES), \
-    $(eval $(call SETUP_LIB_MSVC_ENV_VARS,$(stage),$(target),$(host),$(crate)))))))
-$(foreach host,$(CFG_HOST), \
- $(foreach target,$(CFG_TARGET), \
-  $(foreach stage,$(STAGES), \
-   $(foreach tool,$(TOOLS), \
-    $(eval $(call SETUP_TOOL_MSVC_ENV_VARS,$(stage),$(target),$(host),$(tool)))))))

branches/tmp/mk/target.mk

@@ -20,13 +20,6 @@ series of small examples.
 
 [rbe]: http://rustbyexample.com/
 
-# The Standard Library
-
-We have [API documentation for the entire standard
-library](std/index.html). There's a list of crates on the left with more
-specific sections, or you can use the search bar at the top to search for
-something if you know its name.
-
 # Community & Getting Help
 
 If you need help with something, or just want to talk about Rust with others,
@@ -82,6 +75,13 @@ There are questions that are asked quite often, so we've made FAQs for them:
 * [Project FAQ](complement-project-faq.html)
 * [How to submit a bug report](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports)
 
+# The Standard Library
+
+We have [API documentation for the entire standard
+library](std/index.html). There's a list of crates on the left with more
+specific sections, or you can use the search bar at the top to search for
+something if you know its name.
+
 # The Error Index
 
 If you encounter an error while compiling your code you may be able to look it

branches/tmp/src/doc/index.md

@@ -1047,8 +1047,11 @@ This is a list of behavior not considered *unsafe* in Rust terms, but that may
 be undesired.
 
 * Deadlocks
+* Reading data from private fields (`std::repr`)
 * Leaks of memory and other resources
 * Exiting without calling destructors
+* Sending signals
+* Accessing/modifying the file system
 * Integer overflow
   - Overflow is considered "unexpected" behavior and is always user-error,
     unless the `wrapping` primitives are used. In non-optimized builds, the compiler

branches/tmp/src/doc/reference.md

@@ -336,7 +336,9 @@ In other words, `y` is only valid for the scope where `x` exists. As soon as
 the borrow ‘doesn’t live long enough’ because it’s not valid for the right
 amount of time.
 
-The same problem occurs when the reference is declared _before_ the variable it refers to:
+The same problem occurs when the reference is declared _before_ the variable it
+refers to. This is because resources within the same scope are freed in the
+opposite order they were declared:
 
 ```rust,ignore
 let y: &i32;
@@ -369,3 +371,6 @@ statement 1 at 3:14
     println!("{}", y);
 }
 ```
+
+In the above example, `y` is declared before `x`, meaning that `y` lives longer
+than `x`, which is not allowed.

branches/tmp/src/doc/trpl/references-and-borrowing.md

@@ -12,7 +12,7 @@ two contexts. The first one is to mark a function as unsafe:
 
 ```rust
 unsafe fn danger_will_robinson() {
-    // scary stuff
+    // scary stuff 
 }
 ```
 
@@ -68,8 +68,11 @@ Whew! That’s a bunch of stuff. It’s also important to notice all kinds of
 behaviors that are certainly bad, but are expressly _not_ unsafe:
 
 * Deadlocks
-* Leaks of memory or other resources
+* Reading data from private fields
+* Leaks due to reference count cycles
 * Exiting without calling destructors
+* Sending signals
+* Accessing/modifying the file system
 * Integer overflow
 
 Rust cannot prevent all kinds of software problems. Buggy code can and will be

branches/tmp/src/doc/trpl/unsafe.md

@@ -155,7 +155,7 @@ pub fn size_of_val<T: ?Sized>(val: &T) -> usize {
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(reason = "use `align_of` instead", since = "1.2.0")]
+#[deprecated(reason = "use `align_of` instead", since = "1.1.0")]
 pub fn min_align_of<T>() -> usize {
     unsafe { intrinsics::min_align_of::<T>() }
 }
@@ -171,7 +171,7 @@ pub fn min_align_of<T>() -> usize {
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[deprecated(reason = "use `align_of_val` instead", since = "1.2.0")]
+#[deprecated(reason = "use `align_of_val` instead", since = "1.1.0")]
 pub fn min_align_of_val<T: ?Sized>(val: &T) -> usize {
     unsafe { intrinsics::min_align_of_val(val) }
 }