---

yaml
---
r: 273759
b: refs/heads/beta
c: 0af3e70
h: refs/heads/master
i:
  273757: 36ee25e
  273755: 9b3c5a1
  273751: ae3e7be
  273743: 816ca60
  273727: 340206b

Author: durka

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 102a5be7126ef8f1e79086b98d1d9faf47ba8ece
+refs/heads/beta: 0af3e708423ebac50b40e3288d4afcfe75f91cf3
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/configure

@@ -1252,7 +1252,7 @@ $ pacman -R cmake && pacman -S mingw-w64-x86_64-cmake
                     bits=x86_64
                     msvc_part=amd64
                     ;;
-                i*86-*)
+                i686-*)
                     bits=i386
                     msvc_part=
                     ;;

branches/beta/mk/crates.mk

@@ -53,12 +53,11 @@ TARGET_CRATES := libc std term \
                  getopts collections test rand \
                  core alloc \
                  rustc_unicode rustc_bitflags \
-		 alloc_system alloc_jemalloc
+		 alloc_system alloc_jemalloc rustc_const_eval
 RUSTC_CRATES := rustc rustc_typeck rustc_mir rustc_borrowck rustc_resolve rustc_driver \
                 rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
                 rustc_data_structures rustc_front rustc_platform_intrinsics \
-                rustc_plugin rustc_metadata rustc_passes rustc_save_analysis \
-                rustc_const_eval
+                rustc_plugin rustc_metadata rustc_passes rustc_save_analysis
 HOST_CRATES := syntax syntax_ext $(RUSTC_CRATES) rustdoc fmt_macros \
 		flate arena graphviz rbml log serialize
 TOOLS := compiletest rustdoc rustc rustbook error_index_generator
@@ -95,9 +94,9 @@ DEPS_syntax_ext := syntax fmt_macros
 DEPS_rustc_const_eval := std syntax
 
 DEPS_rustc := syntax fmt_macros flate arena serialize getopts rbml rustc_front\
-              log graphviz rustc_back rustc_data_structures\
+              log graphviz rustc_llvm rustc_back rustc_data_structures\
 		  	  rustc_const_eval
-DEPS_rustc_back := std syntax rustc_front flate log libc
+DEPS_rustc_back := std syntax rustc_llvm rustc_front flate log libc
 DEPS_rustc_borrowck := rustc rustc_front rustc_mir log graphviz syntax
 DEPS_rustc_data_structures := std log serialize
 DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
@@ -111,7 +110,7 @@ DEPS_rustc_metadata := rustc rustc_front syntax rbml rustc_const_eval
 DEPS_rustc_passes := syntax rustc core rustc_front
 DEPS_rustc_mir := rustc rustc_front syntax rustc_const_eval
 DEPS_rustc_resolve := arena rustc rustc_front log syntax
-DEPS_rustc_platform_intrinsics := std
+DEPS_rustc_platform_intrinsics := rustc rustc_llvm
 DEPS_rustc_plugin := rustc rustc_metadata syntax rustc_mir
 DEPS_rustc_privacy := rustc rustc_front log syntax
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back rustc_mir \

branches/beta/mk/main.mk

@@ -493,7 +493,7 @@ endif
 LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3) := \
     $$(CURDIR)/$$(HLIB$(1)_H_$(3)):$$(CFG_LLVM_INST_DIR_$(3))/lib
 LD_LIBRARY_PATH_ENV_TARGETDIR$(1)_T_$(2)_H_$(3) := \
-    $$(CURDIR)/$$(TLIB$(1)_T_$(2)_H_$(3))
+    $$(CURDIR)/$$(TLIB$(1)_T_$(2)_H_$(CFG_BUILD))
 
 HOST_RPATH_VAR$(1)_T_$(2)_H_$(3) := \
   $$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))=$$(LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3)):$$$$$$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))
@@ -506,14 +506,18 @@ RPATH_VAR$(1)_T_$(2)_H_$(3) := $$(HOST_RPATH_VAR$(1)_T_$(2)_H_$(3))
 # if you're building a cross config, the host->* parts are
 # effectively stage1, since it uses the just-built stage0.
 #
-# Also be sure to use the right rpath because we're loading libraries from the
-# CFG_BUILD's stage1 directory for our target, so switch this one instance of
-# `RPATH_VAR` to get the bootstrap working.
+# This logic is similar to how the LD_LIBRARY_PATH variable must
+# change be slightly different when doing cross compilations.
+# The build doesn't copy over all target libraries into
+# a new directory, so we need to point the library path at
+# the build directory where all the target libraries came
+# from (the stage0 build host). Otherwise the relative rpaths
+# inside of the rustc binary won't get resolved correctly.
 ifeq ($(1),0)
 ifneq ($(strip $(CFG_BUILD)),$(strip $(3)))
 CFGFLAG$(1)_T_$(2)_H_$(3) = stage1
 
-RPATH_VAR$(1)_T_$(2)_H_$(3) := $$(TARGET_RPATH_VAR1_T_$(2)_H_$$(CFG_BUILD))
+RPATH_VAR$(1)_T_$(2)_H_$(3) := $$(TARGET_RPATH_VAR$(1)_T_$(2)_H_$(3))
 endif
 endif
 

branches/beta/mk/rt.mk

@@ -236,11 +236,11 @@ COMPRT_LIB_$(1) := $$(RT_OUTPUT_DIR_$(1))/$$(COMPRT_NAME_$(1))
 COMPRT_BUILD_DIR_$(1) := $$(RT_OUTPUT_DIR_$(1))/compiler-rt
 
 ifeq ($$(findstring msvc,$(1)),msvc)
-$$(COMPRT_LIB_$(1)): $$(COMPRT_DEPS) $$(MKFILE_DEPS) $$(LLVM_CONFIG_$$(CFG_BUILD))
+$$(COMPRT_LIB_$(1)): $$(COMPRT_DEPS) $$(MKFILE_DEPS) $$(LLVM_CONFIG_$(1))
 	@$$(call E, cmake: compiler-rt)
 	$$(Q)cd "$$(COMPRT_BUILD_DIR_$(1))"; $$(CFG_CMAKE) "$(S)src/compiler-rt" \
 		-DCMAKE_BUILD_TYPE=$$(LLVM_BUILD_CONFIG_MODE) \
-		-DLLVM_CONFIG_PATH=$$(LLVM_CONFIG_$$(CFG_BUILD)) \
+		-DLLVM_CONFIG_PATH=$$(LLVM_CONFIG_$(1)) \
 		-G"$$(CFG_CMAKE_GENERATOR)"
 	$$(Q)$$(CFG_CMAKE) --build "$$(COMPRT_BUILD_DIR_$(1))" \
 		--target lib/builtins/builtins \

branches/beta/src/etc/platform-intrinsics/generator.py

@@ -759,11 +759,12 @@ def open(self, platform):
 
 use {{Intrinsic, Type}};
 use IntrinsicDef::Named;
+use rustc::middle::ty::TyCtxt;
 
 // The default inlining settings trigger a pathological behaviour in
 // LLVM, which causes makes compilation very slow. See #28273.
 #[inline(never)]
-pub fn find(name: &str) -> Option<Intrinsic> {{
+pub fn find<'tcx>(_tcx: &TyCtxt<'tcx>, name: &str) -> Option<Intrinsic> {{
     if !name.starts_with("{0}") {{ return None }}
     Some(match &name["{0}".len()..] {{'''.format(platform.intrinsic_prefix())
 

branches/beta/src/libcollections/binary_heap.rs

@@ -173,7 +173,7 @@ use vec::{self, Vec};
 /// ```
 /// use std::collections::BinaryHeap;
 ///
-/// // Type inference lets us omit an explicit type signature (which
+/// // type inference lets us omit an explicit type signature (which
 /// // would be `BinaryHeap<i32>` in this example).
 /// let mut heap = BinaryHeap::new();
 ///

branches/beta/src/libcore/convert.rs

@@ -19,14 +19,14 @@
 //!
 //! - Impl the `As*` traits for reference-to-reference conversions
 //! - Impl the `Into` trait when you want to consume the value in the conversion
-//! - The `From` trait is the most flexible, useful for values _and_ references conversions
+//! - The `From` trait is the most flexible, useful for value _and_ reference conversions
 //!
-//! As a library writer, you should prefer implementing `From<T>` rather than
-//! `Into<U>`, as `From` provides greater flexibility and offer the equivalent `Into`
+//! As a library author, you should prefer implementing `From<T>` rather than
+//! `Into<U>`, as `From` provides greater flexibility and offers an equivalent `Into`
 //! implementation for free, thanks to a blanket implementation in the standard library.
 //!
 //! **Note: these traits must not fail**. If the conversion can fail, you must use a dedicated
-//! method which return an `Option<T>` or a `Result<T, E>`.
+//! method which returns an `Option<T>` or a `Result<T, E>`.
 //!
 //! # Generic impl
 //!
@@ -49,7 +49,7 @@ use marker::Sized;
 /// [book]: ../../book/borrow-and-asref.html
 ///
 /// **Note: this trait must not fail**. If the conversion can fail, use a dedicated method which
-/// return an `Option<T>` or a `Result<T, E>`.
+/// returns an `Option<T>` or a `Result<T, E>`.
 ///
 /// # Examples
 ///
@@ -82,7 +82,7 @@ pub trait AsRef<T: ?Sized> {
 /// A cheap, mutable reference-to-mutable reference conversion.
 ///
 /// **Note: this trait must not fail**. If the conversion can fail, use a dedicated method which
-/// return an `Option<T>` or a `Result<T, E>`.
+/// returns an `Option<T>` or a `Result<T, E>`.
 ///
 /// # Generic Impls
 ///
@@ -99,10 +99,10 @@ pub trait AsMut<T: ?Sized> {
 /// A conversion that consumes `self`, which may or may not be expensive.
 ///
 /// **Note: this trait must not fail**. If the conversion can fail, use a dedicated method which
-/// return an `Option<T>` or a `Result<T, E>`.
+/// returns an `Option<T>` or a `Result<T, E>`.
 ///
-/// Library writer should not implement directly this trait, but should prefer the implementation
-/// of the `From` trait, which offer greater flexibility and provide the equivalent `Into`
+/// Library authors should not directly implement this trait, but should prefer implementing
+/// the `From` trait, which offers greater flexibility and provides an equivalent `Into`
 /// implementation for free, thanks to a blanket implementation in the standard library.
 ///
 /// # Examples
@@ -134,7 +134,7 @@ pub trait Into<T>: Sized {
 /// Construct `Self` via a conversion.
 ///
 /// **Note: this trait must not fail**. If the conversion can fail, use a dedicated method which
-/// return an `Option<T>` or a `Result<T, E>`.
+/// returns an `Option<T>` or a `Result<T, E>`.
 ///
 /// # Examples
 ///

branches/beta/src/libcore/ptr.rs

@@ -212,16 +212,6 @@ pub unsafe fn write_volatile<T>(dst: *mut T, src: T) {
 #[lang = "const_ptr"]
 impl<T: ?Sized> *const T {
     /// Returns true if the pointer is null.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s: &str = "Follow the rabbit";
-    /// let ptr: *const u8 = s.as_ptr();
-    /// assert!(ptr.is_null() == false);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn is_null(self) -> bool where T: Sized {
@@ -237,20 +227,6 @@ impl<T: ?Sized> *const T {
     /// null-safety, it is important to note that this is still an unsafe
     /// operation because the returned value could be pointing to invalid
     /// memory.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```ignore
-    /// let val: *const u8 = &10u8 as *const u8;
-    ///
-    /// unsafe {
-    ///     if let Some(val_back) = val.as_ref() {
-    ///         println!("We got back the value: {}!", val_back);
-    ///     }
-    /// }
-    /// ```
     #[unstable(feature = "ptr_as_ref",
                reason = "Option is not clearly the right return type, and we \
                          may want to tie the return lifetime to a borrow of \
@@ -274,20 +250,6 @@ impl<T: ?Sized> *const T {
     /// byte past the end of an allocated object. If either pointer is out of
     /// bounds or arithmetic overflow occurs then
     /// any further use of the returned value will result in undefined behavior.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s: &str = "123";
-    /// let ptr: *const u8 = s.as_ptr();
-    ///
-    /// unsafe {
-    ///     println!("{}", *ptr.offset(1) as char);
-    ///     println!("{}", *ptr.offset(2) as char);
-    /// }
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub unsafe fn offset(self, count: isize) -> *const T where T: Sized {
@@ -298,16 +260,6 @@ impl<T: ?Sized> *const T {
 #[lang = "mut_ptr"]
 impl<T: ?Sized> *mut T {
     /// Returns true if the pointer is null.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = [1, 2, 3];
-    /// let ptr: *mut u32 = s.as_mut_ptr();
-    /// assert!(ptr.is_null() == false);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn is_null(self) -> bool where T: Sized {
@@ -323,20 +275,6 @@ impl<T: ?Sized> *mut T {
     /// null-safety, it is important to note that this is still an unsafe
     /// operation because the returned value could be pointing to invalid
     /// memory.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```ignore
-    /// let val: *mut u8 = &mut 10u8 as *mut u8;
-    ///
-    /// unsafe {
-    ///     if let Some(val_back) = val.as_ref() {
-    ///         println!("We got back the value: {}!", val_back);
-    ///     }
-    /// }
-    /// ```
     #[unstable(feature = "ptr_as_ref",
                reason = "Option is not clearly the right return type, and we \
                          may want to tie the return lifetime to a borrow of \
@@ -359,20 +297,6 @@ impl<T: ?Sized> *mut T {
     /// The offset must be in-bounds of the object, or one-byte-past-the-end.
     /// Otherwise `offset` invokes Undefined Behavior, regardless of whether
     /// the pointer is used.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = [1, 2, 3];
-    /// let ptr: *mut u32 = s.as_mut_ptr();
-    ///
-    /// unsafe {
-    ///     println!("{}", *ptr.offset(1));
-    ///     println!("{}", *ptr.offset(2));
-    /// }
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub unsafe fn offset(self, count: isize) -> *mut T where T: Sized {
@@ -386,15 +310,6 @@ impl<T: ?Sized> *mut T {
     ///
     /// As with `as_ref`, this is unsafe because it cannot verify the validity
     /// of the returned pointer.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = [1, 2, 3];
-    /// let ptr: *mut u32 = s.as_mut_ptr();
-    /// ```
     #[unstable(feature = "ptr_as_ref",
                reason = "return value does not necessarily convey all possible \
                          information",

branches/beta/src/librustc/Cargo.toml

@@ -21,5 +21,6 @@ rustc_bitflags = { path = "../librustc_bitflags" }
 rustc_const_eval = { path = "../librustc_const_eval" }
 rustc_data_structures = { path = "../librustc_data_structures" }
 rustc_front = { path = "../librustc_front" }
+rustc_llvm = { path = "../librustc_llvm" }
 serialize = { path = "../libserialize" }
 syntax = { path = "../libsyntax" }