---

yaml
---
r: 154620
b: refs/heads/try2
c: 34d607f
h: refs/heads/master
v: v3

Author: nrc

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 1cad4089ba0dc46248da2459af904e38243f294d
+refs/heads/try2: 34d607f9c9e3c103fc7f98b4c6fa18ff71905bb6
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcollections/slice.rs

@@ -92,6 +92,8 @@ use core::iter::{range_step, MultiplicativeIterator};
 
 use MutableSeq;
 use vec::Vec;
+#[cfg(not(stage0))]
+use raw::Slice;
 
 pub use core::slice::{Chunks, Slice, ImmutableSlice, ImmutablePartialEqSlice};
 pub use core::slice::{ImmutableOrdSlice, MutableSlice, Items, MutItems};
@@ -282,6 +284,64 @@ pub trait CloneableVector<T> {
 
 impl<'a, T: Clone> CloneableVector<T> for &'a [T] {
     /// Returns a copy of `v`.
+    #[cfg(not(stage0))]
+    fn to_owned(&self) -> ~[T] {
+        use num::CheckedMul;
+        use option::Expect;
+
+        let len = self.len();
+
+        if len == 0 {
+            unsafe {
+                let slice: Slice<T> = Slice{data: 0 as *T, len: 0};
+                mem::transmute(slice)
+            }
+        } else {
+            let unit_size = mem::size_of::<T>();
+            let data_size = if unit_size == 0 {
+                len
+            } else {
+                let data_size = len.checked_mul(&unit_size);
+                data_size.expect("overflow in from_iter()")
+            };
+
+            unsafe {
+                // this should pass the real required alignment
+                let ret = allocate(data_size, 8) as *mut T;
+
+                if unit_size > 0 {
+                    // Be careful with the following loop. We want it to be optimized
+                    // to a memcpy (or something similarly fast) when T is Copy. LLVM
+                    // is easily confused, so any extra operations during the loop can
+                    // prevent this optimization.
+                    let mut i = 0;
+                    let p = &mut (*ret) as *mut _ as *mut T;
+                    try_finally(
+                        &mut i, (),
+                        |i, ()| while *i < len {
+                            mem::move_val_init(
+                                &mut(*p.offset(*i as int)),
+                                self.unsafe_ref(*i).clone());
+                            *i += 1;
+                        },
+                        |i| if *i < len {
+                            // we must be failing, clean up after ourselves
+                            for j in range(0, *i as int) {
+                                ptr::read(&*p.offset(j));
+                            }
+                            // FIXME: #13994 (should pass align and size here)
+                            deallocate(ret as *mut u8, 0, 8);
+                        });
+                }
+                let slice: Slice<T> = Slice{data: ret as *T, len: len};
+                mem::transmute(slice)
+            }
+        }
+    }
+
+    /// Returns a copy of `v`.
+    // NOTE: remove after snapshot
+    #[cfg(stage0)]
     #[inline]
     fn to_vec(&self) -> Vec<T> { Vec::from_slice(*self) }
 

branches/try2/src/libcore/mem.rs

@@ -174,7 +174,7 @@ pub unsafe fn overwrite<T>(dst: *mut T, src: T) {
 
 /// Deprecated, use `overwrite` instead
 #[inline]
-#[deprecated = "use ptr::write"]
+#[deprecated = "this function has been renamed to overwrite()"]
 pub unsafe fn move_val_init<T>(dst: &mut T, src: T) {
     ptr::write(dst, src)
 }

branches/try2/src/librustc/middle/expr_use_visitor.rs

@@ -234,7 +234,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {
                          decl: &ast::FnDecl,
                          body: &ast::Block) {
         for arg in decl.inputs.iter() {
-            let arg_ty = return_if_err!(self.typer.node_ty(arg.pat.id));
+            let arg_ty = ty::node_id_to_type(self.tcx(), arg.pat.id);
 
             let arg_cmt = self.mc.cat_rvalue(
                 arg.id,
@@ -414,7 +414,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {
 
                 // Fetch the type of the value that the iteration yields to
                 // produce the pattern's categorized mutable type.
-                let pattern_type = return_if_err!(self.typer.node_ty(pat.id));
+                let pattern_type = ty::node_id_to_type(self.tcx(), pat.id);
                 let pat_cmt = self.mc.cat_rvalue(pat.id,
                                                  pat.span,
                                                  ty::ReScope(blk.id),
@@ -828,7 +828,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {
                        pat.repr(tcx));
 
                 // pat_ty: the type of the binding being produced.
-                let pat_ty = return_if_err!(typer.node_ty(pat.id));
+                let pat_ty = ty::node_id_to_type(tcx, pat.id);
 
                 // Each match binding is effectively an assignment to the
                 // binding being produced.
@@ -971,7 +971,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {
         // Create the cmt for the variable being borrowed, from the
         // caller's perspective
         let var_id = upvar_def.def_id().node;
-        let var_ty = try!(self.typer.node_ty(var_id));
+        let var_ty = ty::node_id_to_type(self.tcx(), var_id);
         self.mc.cat_def(closure_id, closure_span, var_ty, upvar_def)
     }
 }

branches/try2/src/librustc/middle/trans/adt.rs

@@ -305,8 +305,7 @@ impl Case {
 
                 // Box<T> could either be a thin or fat pointer depending on T
                 ty::ty_uniq(t) => match ty::get(t).sty {
-                    // Box<[T]>/Box<str> might be FatPointer in a post DST world
-                    ty::ty_vec(_, None) | ty::ty_str => continue,
+                    ty::ty_vec(_, None) | return Some(FatPointer(i, slice_elt_base)),
 
                     // Box<Trait> is a pair of pointers: the actual object and a vtable
                     ty::ty_trait(..) => return Some(FatPointer(i, trt_field_box)),
@@ -326,7 +325,6 @@ impl Case {
 
                 // Anything else is not a pointer
                 _ => continue
-
             }
         }
 

branches/try2/src/librustc/middle/trans/base.rs

@@ -195,6 +195,16 @@ pub fn decl_fn(ccx: &CrateContext, name: &str, cc: llvm::CallConv,
                                                llvm::NoReturnAttribute as uint64_t)
             }
         }
+        // `~` pointer return values never alias because ownership is transferred
+        ty::ty_uniq(t)
+            => match ty::get(t).sty {
+                ty::ty_vec(_, None) | ty::ty_str | ty::ty_trait(..) => {}
+                _ => unsafe {
+                    llvm::LLVMAddReturnAttribute(llfn,
+                                                 lib::llvm::NoAliasAttribute as c_uint,
+                                                 lib::llvm::NoReturnAttribute as uint64_t);
+                }
+            },
         _ => {}
     }
 
@@ -364,20 +374,19 @@ fn require_alloc_fn(bcx: &Block, info_ty: ty::t, it: LangItem) -> ast::DefId {
 // a given type, but with a potentially dynamic size.
 
 pub fn malloc_raw_dyn<'a>(bcx: &'a Block<'a>,
-                          ptr_ty: ty::t,
+                          llty_ptr: Type,
+                          info_ty: ty::t,
                           size: ValueRef,
                           align: ValueRef)
                           -> Result<'a> {
     let _icx = push_ctxt("malloc_raw_exchange");
-    let ccx = bcx.ccx();
 
     // Allocate space:
     let r = callee::trans_lang_call(bcx,
-        require_alloc_fn(bcx, ptr_ty, ExchangeMallocFnLangItem),
+        require_alloc_fn(bcx, info_ty, ExchangeMallocFnLangItem),
         [size, align],
         None);
 
-    let llty_ptr = type_of::type_of(ccx, ptr_ty);
     Result::new(r.bcx, PointerCast(r.bcx, r.val, llty_ptr))
 }
 
@@ -731,8 +740,8 @@ pub fn iter_structural_ty<'r,
           }
       }
       ty::ty_vec(_, Some(n)) => {
+        let (base, len) = tvec::get_fixed_base_and_len(cx, av, n);
         let unit_ty = ty::sequence_element_type(cx.tcx(), t);
-        let (base, len) = tvec::get_fixed_base_and_byte_len(cx, av, unit_ty, n);
         cx = tvec::iter_vec_raw(cx, base, unit_ty, len, f);
       }
       ty::ty_tup(ref args) => {

branches/try2/src/librustc/middle/trans/debuginfo.rs

@@ -2718,81 +2718,6 @@ fn fixed_vec_metadata(cx: &CrateContext,
     return MetadataCreationResult::new(metadata, false);
 }
 
-fn heap_vec_metadata(cx: &CrateContext,
-                     vec_pointer_type: ty::t,
-                     element_type: ty::t,
-                     unique_type_id: UniqueTypeId,
-                     span: Span)
-                  -> MetadataCreationResult {
-    let element_type_metadata = type_metadata(cx, element_type, span);
-    let element_llvm_type = type_of::type_of(cx, element_type);
-    let (element_size, element_align) = size_and_align_of(cx, element_llvm_type);
-
-    return_if_metadata_created_in_meantime!(cx, unique_type_id);
-
-    let vecbox_llvm_type = Type::vec(cx, &element_llvm_type);
-    let vec_pointer_type_name = compute_debuginfo_type_name(cx,
-                                                            vec_pointer_type,
-                                                            true);
-    let vec_pointer_type_name = vec_pointer_type_name.as_slice();
-
-    let member_llvm_types = vecbox_llvm_type.field_types();
-
-    let int_type_metadata = type_metadata(cx, ty::mk_int(), span);
-    let array_type_metadata = unsafe {
-        llvm::LLVMDIBuilderCreateArrayType(
-            DIB(cx),
-            bytes_to_bits(element_size),
-            bytes_to_bits(element_align),
-            element_type_metadata,
-            create_DIArray(DIB(cx), [llvm::LLVMDIBuilderGetOrCreateSubrange(DIB(cx), 0, 0)]))
-    };
-
-    let member_descriptions = [
-        MemberDescription {
-            name: "fill".to_string(),
-            llvm_type: *member_llvm_types.get(0),
-            type_metadata: int_type_metadata,
-            offset: ComputedMemberOffset,
-        },
-        MemberDescription {
-            name: "alloc".to_string(),
-            llvm_type: *member_llvm_types.get(1),
-            type_metadata: int_type_metadata,
-            offset: ComputedMemberOffset,
-        },
-        MemberDescription {
-            name: "elements".to_string(),
-            llvm_type: *member_llvm_types.get(2),
-            type_metadata: array_type_metadata,
-            offset: ComputedMemberOffset,
-        }
-    ];
-
-    assert!(member_descriptions.len() == member_llvm_types.len());
-
-    let loc = span_start(cx, span);
-    let file_metadata = file_metadata(cx, loc.file.name.as_slice());
-
-    let vec_box_unique_id = debug_context(cx).type_map
-                                             .borrow_mut()
-                                             .get_unique_type_id_of_heap_vec_box(cx,
-                                                                                 element_type);
-
-    let vecbox_metadata = composite_type_metadata(cx,
-                                                  vecbox_llvm_type,
-                                                  vec_pointer_type_name,
-                                                  vec_box_unique_id,
-                                                  member_descriptions,
-                                                  UNKNOWN_SCOPE_METADATA,
-                                                  file_metadata,
-                                                  span);
-
-    MetadataCreationResult::new(pointer_type_metadata(cx,
-                                                      vec_pointer_type,
-                                                      vecbox_metadata), false)
-}
-
 fn vec_slice_metadata(cx: &CrateContext,
                       vec_type: ty::t,
                       element_type: ty::t,
@@ -2995,11 +2920,13 @@ fn type_metadata(cx: &CrateContext,
         ty::ty_uniq(pointee_type) => {
             match ty::get(pointee_type).sty {
                 ty::ty_vec(ref mt, None) => {
-                    heap_vec_metadata(cx, pointee_type, mt.ty, unique_type_id, usage_site_span)
+                    let vec_metadata = vec_slice_metadata(cx, t, mt.ty, usage_site_span);
+                    pointer_type_metadata(cx, t, vec_metadata)
                 }
                 ty::ty_str => {
                     let i8_t = ty::mk_i8();
-                    heap_vec_metadata(cx, pointee_type, i8_t, unique_type_id, usage_site_span)
+                    let vec_metadata = vec_slice_metadata(cx, t, i8_t, usage_site_span);
+                    pointer_type_metadata(cx, t, vec_metadata)
                 }
                 ty::ty_trait(..) => {
                     MetadataCreationResult::new(

branches/try2/src/librustc/middle/trans/expr.rs

@@ -395,8 +395,8 @@ fn trans_datum_unadjusted<'a>(bcx: &'a Block<'a>,
         ast::ExprField(ref base, ident, _) => {
             trans_rec_field(bcx, &**base, ident.node)
         }
-        ast::ExprIndex(ref base, ref idx) => {
-            trans_index(bcx, expr, &**base, &**idx, MethodCall::expr(expr.id))
+        ast::ExprIndex(base, idx) => {
+            trans_index(bcx, expr.span, &**base, &**idx, MethodCall::expr(expr.id))
         }
         ast::ExprVstore(ref contents, ast::ExprVstoreUniq) => {
             fcx.push_ast_cleanup_scope(contents.id);
@@ -465,7 +465,7 @@ fn trans_rec_field<'a>(bcx: &'a Block<'a>,
 }
 
 fn trans_index<'a>(bcx: &'a Block<'a>,
-                   index_expr: &ast::Expr,
+                   sp: codemap::Span,
                    base: &ast::Expr,
                    idx: &ast::Expr,
                    method_call: MethodCall)
@@ -1256,10 +1256,8 @@ fn trans_uniq_expr<'a>(bcx: &'a Block<'a>,
     let llty = type_of::type_of(bcx.ccx(), contents_ty);
     let size = llsize_of(bcx.ccx(), llty);
     let align = C_uint(bcx.ccx(), llalign_of_min(bcx.ccx(), llty) as uint);
-    // We need to a make a pointer type because box_ty is ty_bot
-    // if content_ty is, e.g. box fail!().
-    let real_box_ty = ty::mk_uniq(bcx.tcx(), contents_ty);
-    let Result { bcx, val } = malloc_raw_dyn(bcx, real_box_ty, size, align);
+    let llty_ptr = llty.ptr_to();
+    let Result { bcx, val } = malloc_raw_dyn(bcx, llty_ptr, box_ty, size, align);
     // Unique boxes do not allocate for zero-size types. The standard library
     // may assume that `free` is never called on the pointer returned for
     // `Box<ZeroSizeType>`.

branches/try2/src/librustc/middle/trans/glue.rs

@@ -51,7 +51,7 @@ pub fn trans_free<'a>(cx: &'a Block<'a>, v: ValueRef) -> &'a Block<'a> {
         Some(expr::Ignore)).bcx
 }
 
-fn trans_exchange_free<'a>(cx: &'a Block<'a>, v: ValueRef, size: u64,
+pub fn trans_exchange_free<'a>(cx: &'a Block<'a>, v: ValueRef, size: u64,
                                align: u64) -> &'a Block<'a> {
     let _icx = push_ctxt("trans_exchange_free");
     let ccx = cx.ccx();
@@ -120,8 +120,8 @@ pub fn drop_ty<'a>(bcx: &'a Block<'a>, v: ValueRef, t: ty::t)
                -> &'a Block<'a> {
     // NB: v is an *alias* of type t here, not a direct value.
     let _icx = push_ctxt("drop_ty");
-    let ccx = bcx.ccx();
     if ty::type_needs_drop(bcx.tcx(), t) {
+        let ccx = bcx.ccx();
         let glue = get_drop_glue(ccx, t);
         let glue_type = get_drop_glue_type(ccx, t);
         let ptr = if glue_type != t {
@@ -277,23 +277,11 @@ fn make_drop_glue<'a>(bcx: &'a Block<'a>, v0: ValueRef, t: ty::t) -> &'a Block<'
         ty::ty_uniq(content_ty) => {
             match ty::get(content_ty).sty {
                 ty::ty_vec(mt, None) => {
-                    let llbox = Load(bcx, v0);
-                    let not_null = IsNotNull(bcx, llbox);
-                    with_cond(bcx, not_null, |bcx| {
-                        let bcx = tvec::make_drop_glue_unboxed(bcx, llbox, mt.ty);
-                        // FIXME: #13994: the old `Box<[T]>` will not support sized deallocation
-                        trans_exchange_free(bcx, llbox, 0, 8)
-                    })
+                    tvec::make_drop_glue_unboxed(bcx, v0, mt.ty)
                 }
                 ty::ty_str => {
-                    let llbox = Load(bcx, v0);
-                    let not_null = IsNotNull(bcx, llbox);
-                    with_cond(bcx, not_null, |bcx| {
-                        let unit_ty = ty::sequence_element_type(bcx.tcx(), t);
-                        let bcx = tvec::make_drop_glue_unboxed(bcx, llbox, unit_ty);
-                        // FIXME: #13994: the old `Box<str>` will not support sized deallocation
-                        trans_exchange_free(bcx, llbox, 0, 8)
-                    })
+                    let unit_ty = ty::sequence_element_type(bcx.tcx(), t);
+                    tvec::make_drop_glue_unboxed(bcx, v0, unit_ty)
                 }
                 ty::ty_trait(..) => {
                     let lluniquevalue = GEPi(bcx, v0, [0, abi::trt_field_box]);