---

yaml
---
r: 102084
b: refs/heads/master
c: 4687e1d
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4995a85f401e17ea7a9b8eab32335b5fd13ce248
+refs/heads/master: 4687e1d67d2601c3a408b74224f5ceb353c77b71
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/.travis.yml

@@ -604,7 +604,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[2-5]svn|3.[2-5])
+        (3.[2-4]svn|3.[2-4])
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)
@@ -626,7 +626,7 @@ then
                       | cut -d ' ' -f 2)
 
     case $CFG_CLANG_VERSION in
-        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* | 3.5* )
+        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* )
         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
         CFG_C_COMPILER="clang"
         ;;

trunk/configure

@@ -218,12 +218,8 @@ LLVM_TOOLS=bugpoint llc llvm-ar llvm-as llvm-dis llvm-mc opt llvm-extract
 define DEF_LLVM_VARS
 # The configure script defines these variables with the target triples
 # separated by Z. This defines new ones with the expected format.
-ifeq ($$(CFG_LLVM_ROOT),)
 CFG_LLVM_BUILD_DIR_$(1):=$$(CFG_LLVM_BUILD_DIR_$(subst -,_,$(1)))
 CFG_LLVM_INST_DIR_$(1):=$$(CFG_LLVM_INST_DIR_$(subst -,_,$(1)))
-else
-CFG_LLVM_INST_DIR_$(1):=$$(CFG_LLVM_ROOT)
-endif
 
 # Any rules that depend on LLVM should depend on LLVM_CONFIG
 LLVM_CONFIG_$(1):=$$(CFG_LLVM_INST_DIR_$(1))/bin/llvm-config$$(X_$(1))

trunk/mk/main.mk

@@ -16,7 +16,7 @@
 #
 # It requires the following variables to be set:
 #
-#   PREPARE_HOST - the host triple
+#   PREPARE_HOST - the host triple 
 #   PREPARE_TARGETS - the target triples, space separated
 #   PREPARE_DEST_DIR - the directory to put the image
 
@@ -172,10 +172,7 @@ prepare-target-$(2)-host-$(3)-$(1): \
         $$(if $$(findstring $(2),$$(CFG_HOST)), \
           $$(foreach crate,$$(HOST_CRATES), \
             $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate)),)
-# Only install if this host and target combo is being prepared. Also be sure to
-# *not* install the rlibs for host crates because there's no need to statically
-# link against most of them. They just produce a large amount of extra size
-# bloat.
+# Only install if this host and target combo is being prepared
 	$$(if $$(findstring $(1), $$(PREPARE_STAGE)),\
       $$(if $$(findstring $(2), $$(PREPARE_TARGETS)),\
         $$(if $$(findstring $(3), $$(PREPARE_HOST)),\
@@ -185,7 +182,8 @@ prepare-target-$(2)-host-$(3)-$(1): \
             $$(call PREPARE_LIB,$$(call CFG_RLIB_GLOB,$$(crate))))\
           $$(if $$(findstring $(2),$$(CFG_HOST)),\
             $$(foreach crate,$$(HOST_CRATES),\
-              $$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))),)\
+              $$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))\
+              $$(call PREPARE_LIB,$$(call CFG_RLIB_GLOB,$$(crate)))),)\
           $$(call PREPARE_LIB,libmorestack.a) \
           $$(call PREPARE_LIB,libcompiler-rt.a),),),)
 endef

trunk/mk/prepare.mk

@@ -119,8 +119,7 @@ def write_file(name, string):
                               ('Clone', [], 1), ('DeepClone', ['Clone'], 1),
                               ('Eq', [], 2), ('Ord', [], 8),
                               ('TotalEq', [], 1), ('TotalOrd', ['TotalEq'], 1),
-                              ('Show', [], 1),
-                              ('Hash', [], 1)]:
+                              ('Show', [], 1)]:
     traits[trait] = (ALL, supers, errs)
 
 for (trait, (types, super_traits, error_count)) in traits.items():

trunk/src/etc/generate-deriving-span-tests.py

@@ -31,6 +31,7 @@ use std::cast::{transmute, transmute_mut, transmute_mut_region};
 use std::cast;
 use std::cell::{Cell, RefCell};
 use std::mem;
+use std::ptr::read;
 use std::cmp;
 use std::num;
 use std::kinds::marker;
@@ -345,37 +346,32 @@ pub struct TypedArena<T> {
     /// reached, a new chunk is allocated.
     priv end: *T,
 
-    /// The type descriptor of the objects in the arena. This should not be
-    /// necessary, but is until generic destructors are supported.
-    priv tydesc: *TyDesc,
-
     /// A pointer to the first arena segment.
-    priv first: Option<~TypedArenaChunk>,
+    priv first: Option<~TypedArenaChunk<T>>,
 }
 
-struct TypedArenaChunk {
+struct TypedArenaChunk<T> {
     /// Pointer to the next arena segment.
-    next: Option<~TypedArenaChunk>,
+    next: Option<~TypedArenaChunk<T>>,
 
     /// The number of elements that this chunk can hold.
     capacity: uint,
 
     // Objects follow here, suitably aligned.
 }
 
-impl TypedArenaChunk {
+impl<T> TypedArenaChunk<T> {
     #[inline]
-    fn new<T>(next: Option<~TypedArenaChunk>, capacity: uint)
-           -> ~TypedArenaChunk {
-        let mut size = mem::size_of::<TypedArenaChunk>();
+    fn new(next: Option<~TypedArenaChunk<T>>, capacity: uint) -> ~TypedArenaChunk<T> {
+        let mut size = mem::size_of::<TypedArenaChunk<T>>();
         size = round_up(size, mem::min_align_of::<T>());
         let elem_size = mem::size_of::<T>();
         let elems_size = elem_size.checked_mul(&capacity).unwrap();
         size = size.checked_add(&elems_size).unwrap();
 
         let mut chunk = unsafe {
             let chunk = global_heap::exchange_malloc(size);
-            let mut chunk: ~TypedArenaChunk = cast::transmute(chunk);
+            let mut chunk: ~TypedArenaChunk<T> = cast::transmute(chunk);
             mem::move_val_init(&mut chunk.next, next);
             chunk
         };
@@ -387,16 +383,13 @@ impl TypedArenaChunk {
     /// Destroys this arena chunk. If the type descriptor is supplied, the
     /// drop glue is called; otherwise, drop glue is not called.
     #[inline]
-    unsafe fn destroy(&mut self, len: uint, opt_tydesc: Option<*TyDesc>) {
+    unsafe fn destroy(&mut self, len: uint) {
         // Destroy all the allocated objects.
-        match opt_tydesc {
-            None => {}
-            Some(tydesc) => {
-                let mut start = self.start(tydesc);
-                for _ in range(0, len) {
-                    ((*tydesc).drop_glue)(start as *i8);
-                    start = start.offset((*tydesc).size as int)
-                }
+        if intrinsics::needs_drop::<T>() {
+            let mut start = self.start();
+            for _ in range(0, len) {
+                read(start as *T); // run the destructor on the pointer
+                start = start.offset(mem::size_of::<T>() as int)
             }
         }
 
@@ -406,26 +399,26 @@ impl TypedArenaChunk {
             None => {}
             Some(mut next) => {
                 // We assume that the next chunk is completely filled.
-                next.destroy(next.capacity, opt_tydesc)
+                next.destroy(next.capacity)
             }
         }
     }
 
     // Returns a pointer to the first allocated object.
     #[inline]
-    fn start(&self, tydesc: *TyDesc) -> *u8 {
-        let this: *TypedArenaChunk = self;
+    fn start(&self) -> *u8 {
+        let this: *TypedArenaChunk<T> = self;
         unsafe {
-            cast::transmute(round_up(this.offset(1) as uint, (*tydesc).align))
+            cast::transmute(round_up(this.offset(1) as uint, mem::min_align_of::<T>()))
         }
     }
 
     // Returns a pointer to the end of the allocated space.
     #[inline]
-    fn end(&self, tydesc: *TyDesc) -> *u8 {
+    fn end(&self) -> *u8 {
         unsafe {
-            let size = (*tydesc).size.checked_mul(&self.capacity).unwrap();
-            self.start(tydesc).offset(size as int)
+            let size = mem::size_of::<T>().checked_mul(&self.capacity).unwrap();
+            self.start().offset(size as int)
         }
     }
 }
@@ -441,14 +434,10 @@ impl<T> TypedArena<T> {
     /// objects.
     #[inline]
     pub fn with_capacity(capacity: uint) -> TypedArena<T> {
-        let chunk = TypedArenaChunk::new::<T>(None, capacity);
-        let tydesc = unsafe {
-            intrinsics::get_tydesc::<T>()
-        };
+        let chunk = TypedArenaChunk::<T>::new(None, capacity);
         TypedArena {
-            ptr: chunk.start(tydesc) as *T,
-            end: chunk.end(tydesc) as *T,
-            tydesc: tydesc,
+            ptr: chunk.start() as *T,
+            end: chunk.end() as *T,
             first: Some(chunk),
         }
     }
@@ -475,9 +464,9 @@ impl<T> TypedArena<T> {
     fn grow(&mut self) {
         let chunk = self.first.take_unwrap();
         let new_capacity = chunk.capacity.checked_mul(&2).unwrap();
-        let chunk = TypedArenaChunk::new::<T>(Some(chunk), new_capacity);
-        self.ptr = chunk.start(self.tydesc) as *T;
-        self.end = chunk.end(self.tydesc) as *T;
+        let chunk = TypedArenaChunk::<T>::new(Some(chunk), new_capacity);
+        self.ptr = chunk.start() as *T;
+        self.end = chunk.end() as *T;
         self.first = Some(chunk)
     }
 }
@@ -486,18 +475,13 @@ impl<T> TypedArena<T> {
 impl<T> Drop for TypedArena<T> {
     fn drop(&mut self) {
         // Determine how much was filled.
-        let start = self.first.get_ref().start(self.tydesc) as uint;
+        let start = self.first.get_ref().start() as uint;
         let end = self.ptr as uint;
         let diff = (end - start) / mem::size_of::<T>();
 
         // Pass that to the `destroy` method.
         unsafe {
-            let opt_tydesc = if intrinsics::needs_drop::<T>() {
-                Some(self.tydesc)
-            } else {
-                None
-            };
-            self.first.get_mut_ref().destroy(diff, opt_tydesc)
+            self.first.get_mut_ref().destroy(diff)
         }
     }
 }

trunk/src/libarena/lib.rs

@@ -11,7 +11,6 @@
 #[allow(missing_doc)];
 
 use std::cmp;
-use std::hash_old::Hash;
 use std::hashmap;
 use std::io;
 use std::mem;

trunk/src/libextra/stats.rs

@@ -34,7 +34,6 @@ use std::run;
 use std::str;
 use std::io;
 use std::io::fs;
-use flate;
 use serialize::hex::ToHex;
 use extra::tempfile::TempDir;
 use syntax::abi;
@@ -943,15 +942,6 @@ fn link_rlib(sess: Session,
             // For LTO purposes, the bytecode of this library is also inserted
             // into the archive.
             let bc = obj_filename.with_extension("bc");
-            match fs::File::open(&bc).read_to_end().and_then(|data| {
-                fs::File::create(&bc).write(flate::deflate_bytes(data))
-            }) {
-                Ok(()) => {}
-                Err(e) => {
-                    sess.err(format!("failed to compress bytecode: {}", e));
-                    sess.abort_if_errors()
-                }
-            }
             a.add_file(&bc, false);
             if !sess.opts.cg.save_temps &&
                !sess.opts.output_types.contains(&OutputTypeBitcode) {

trunk/src/librustc/back/link.rs

@@ -16,7 +16,6 @@ use metadata::cstore;
 use util::common::time;
 
 use std::libc;
-use flate;
 
 pub fn run(sess: session::Session, llmod: ModuleRef,
            tm: TargetMachineRef, reachable: &[~str]) {
@@ -56,8 +55,6 @@ pub fn run(sess: session::Session, llmod: ModuleRef,
         let bc = time(sess.time_passes(), format!("read {}.bc", name), (), |_|
                       archive.read(format!("{}.bc", name)));
         let bc = bc.expect("missing bytecode in archive!");
-        let bc = time(sess.time_passes(), format!("inflate {}.bc", name), (), |_|
-                      flate::inflate_bytes(bc));
         let ptr = bc.as_ptr();
         debug!("linking {}", name);
         time(sess.time_passes(), format!("ll link {}", name), (), |()| unsafe {

trunk/src/librustc/back/lto.rs

@@ -27,7 +27,6 @@ use middle::typeck;
 use middle::astencode::vtable_decoder_helpers;
 
 use std::u64;
-use std::hash_old::Hash;
 use std::io;
 use std::io::extensions::u64_from_be_bytes;
 use std::option;

trunk/src/librustc/metadata/decoder.rs

@@ -26,7 +26,6 @@ use middle;
 use serialize::Encodable;
 use std::cast;
 use std::cell::{Cell, RefCell};
-use std::hash_old::Hash;
 use std::hashmap::{HashMap, HashSet};
 use std::io::MemWriter;
 use std::str;

trunk/src/librustc/metadata/encoder.rs

@@ -407,8 +407,11 @@ fn get_metadata_section_imp(os: Os, filename: &Path) -> Option<MetadataBlob> {
                 debug!("checking {} bytes of metadata-version stamp",
                        vlen);
                 let minsz = cmp::min(vlen, csz);
-                let version_ok = vec::raw::buf_as_slice(cvbuf, minsz,
-                    |buf0| buf0 == encoder::metadata_encoding_version);
+                let mut version_ok = false;
+                vec::raw::buf_as_slice(cvbuf, minsz, |buf0| {
+                    version_ok = (buf0 ==
+                                  encoder::metadata_encoding_version);
+                });
                 if !version_ok { return None; }
 
                 let cvbuf1 = cvbuf.offset(vlen as int);

trunk/src/librustc/metadata/loader.rs

@@ -95,10 +95,11 @@ impl<'a> GuaranteeLifetimeContext<'a> {
                 let base_scope = self.scope(base);
 
                 // L-Deref-Managed-Imm-User-Root
-                let omit_root =
+                let omit_root = (
                     self.bccx.is_subregion_of(self.loan_region, base_scope) &&
                     self.is_rvalue_or_immutable(base) &&
-                    !self.is_moved(base);
+                    !self.is_moved(base)
+                );
 
                 if !omit_root {
                     // L-Deref-Managed-Imm-Compiler-Root

trunk/src/librustc/middle/borrowck/gather_loans/lifetime.rs

@@ -891,7 +891,7 @@ fn bitwise(out_vec: &mut [uint], in_vec: &[uint], op: |uint, uint| -> uint)
         let old_val = *out_elt;
         let new_val = op(old_val, *in_elt);
         *out_elt = new_val;
-        changed |= old_val != new_val;
+        changed |= (old_val != new_val);
     }
     changed
 }