---

yaml
---
r: 60106
b: refs/heads/master
c: 0c02d0f
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5a65f51d666855d7685850808cc06e49c3d21c72
+refs/heads/master: 0c02d0f92ecabb9486482c3e4d660e736346803b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589

trunk/src/libcore/iter.rs

@@ -17,8 +17,7 @@ breaking out of iteration. The adaptors in the module work with any such iterato
 tied to specific traits. For example:
 
 ~~~~
-use core::iter::iter_to_vec;
-println(iter_to_vec(|f| uint::range(0, 20, f)).to_str());
+println(iter::to_vec(|f| uint::range(0, 20, f)).to_str());
 ~~~~
 
 An external iterator object implementing the interface in the `iterator` module can be used as an
@@ -55,12 +54,12 @@ pub trait Times {
  *
  * ~~~
  * let xs = ~[1, 2, 3];
- * let ys = do iter_to_vec |f| { xs.each(|x| f(*x)) };
+ * let ys = do iter::to_vec |f| { xs.each(|x| f(*x)) };
  * assert_eq!(xs, ys);
  * ~~~
  */
 #[inline(always)]
-pub fn iter_to_vec<T>(iter: &fn(f: &fn(T) -> bool)) -> ~[T] {
+pub fn to_vec<T>(iter: &fn(f: &fn(T) -> bool)) -> ~[T] {
     let mut v = ~[];
     for iter |x| { v.push(x) }
     v
@@ -185,9 +184,9 @@ mod tests {
     use prelude::*;
 
     #[test]
-    fn test_iter_to_vec() {
+    fn test_to_vec() {
         let xs = ~[1, 2, 3];
-        let ys = do iter_to_vec |f| { xs.each(|x| f(*x)) };
+        let ys = do to_vec |f| { xs.each(|x| f(*x)) };
         assert_eq!(xs, ys);
     }
 

trunk/src/libcore/iterator.rs

@@ -378,7 +378,7 @@ mod tests {
     #[test]
     fn test_counter_to_vec() {
         let mut it = Counter::new(0, 5).take(10);
-        let xs = iter::iter_to_vec(|f| it.advance(f));
+        let xs = iter::to_vec(|f| it.advance(f));
         assert_eq!(xs, ~[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
     }
 

trunk/src/libcore/unstable.rs

@@ -30,8 +30,6 @@ pub mod weak_task;
 pub mod exchange_alloc;
 #[path = "unstable/intrinsics.rs"]
 pub mod intrinsics;
-#[path = "unstable/simd.rs"]
-pub mod simd;
 #[path = "unstable/extfmt.rs"]
 pub mod extfmt;
 #[path = "unstable/lang.rs"]

trunk/src/libcore/unstable/simd.rs

@@ -963,28 +963,20 @@ pub fn ExtractElement(cx: block, VecVal: ValueRef, Index: ValueRef) ->
 }
 
 pub fn InsertElement(cx: block, VecVal: ValueRef, EltVal: ValueRef,
-                     Index: ValueRef) -> ValueRef {
+                 Index: ValueRef) {
     unsafe {
-        if cx.unreachable { return llvm::LLVMGetUndef(T_nil()); }
+        if cx.unreachable { return; }
         count_insn(cx, "insertelement");
-        llvm::LLVMBuildInsertElement(B(cx), VecVal, EltVal, Index, noname())
+        llvm::LLVMBuildInsertElement(B(cx), VecVal, EltVal, Index, noname());
     }
 }
 
 pub fn ShuffleVector(cx: block, V1: ValueRef, V2: ValueRef,
-                     Mask: ValueRef) -> ValueRef {
+                     Mask: ValueRef) {
     unsafe {
-        if cx.unreachable { return llvm::LLVMGetUndef(T_nil()); }
+        if cx.unreachable { return; }
         count_insn(cx, "shufflevector");
-        llvm::LLVMBuildShuffleVector(B(cx), V1, V2, Mask, noname())
-    }
-}
-
-pub fn VectorSplat(cx: block, NumElts: uint, EltVal: ValueRef) -> ValueRef {
-    unsafe {
-        let Undef = llvm::LLVMGetUndef(T_vector(val_ty(EltVal), NumElts));
-        let VecVal = InsertElement(cx, Undef, EltVal, C_i32(0));
-        ShuffleVector(cx, VecVal, Undef, C_null(T_vector(T_i32(), NumElts)))
+        llvm::LLVMBuildShuffleVector(B(cx), V1, V2, Mask, noname());
     }
 }
 

trunk/src/librustc/middle/trans/build.rs

@@ -984,12 +984,6 @@ pub fn T_array(t: TypeRef, n: uint) -> TypeRef {
     }
 }
 
-pub fn T_vector(t: TypeRef, n: uint) -> TypeRef {
-    unsafe {
-        return llvm::LLVMVectorType(t, n as c_uint);
-    }
-}
-
 // Interior vector.
 pub fn T_vec2(targ_cfg: @session::config, t: TypeRef) -> TypeRef {
     return T_struct(~[T_int(targ_cfg), // fill

trunk/src/librustc/middle/trans/common.rs

@@ -155,15 +155,9 @@ pub fn sizing_type_of(cx: @CrateContext, t: ty::t) -> TypeRef {
         }
 
         ty::ty_struct(did, _) => {
-            if ty::type_is_simd(cx.tcx, t) {
-                let et = ty::simd_type(cx.tcx, t);
-                let n = ty::simd_size(cx.tcx, t);
-                T_vector(type_of(cx, et), n)
-            } else {
-                let repr = adt::represent_type(cx, t);
-                let packed = ty::lookup_packed(cx.tcx, did);
-                T_struct(adt::sizing_fields_of(cx, repr), packed)
-            }
+            let repr = adt::represent_type(cx, t);
+            let packed = ty::lookup_packed(cx.tcx, did);
+            T_struct(adt::sizing_fields_of(cx, repr), packed)
         }
 
         ty::ty_self(_) | ty::ty_infer(*) | ty::ty_param(*) | ty::ty_err(*) => {
@@ -269,19 +263,14 @@ pub fn type_of(cx: @CrateContext, t: ty::t) -> TypeRef {
       }
       ty::ty_opaque_closure_ptr(_) => T_opaque_box_ptr(cx),
       ty::ty_struct(did, ref substs) => {
-        if ty::type_is_simd(cx.tcx, t) {
-          let et = ty::simd_type(cx.tcx, t);
-          let n = ty::simd_size(cx.tcx, t);
-          T_vector(type_of(cx, et), n)
-        } else {
-          // Only create the named struct, but don't fill it in. We fill it
-          // in *after* placing it into the type cache. This prevents
-          // infinite recursion with recursive struct types.
-          T_named_struct(llvm_type_name(cx,
-                                        a_struct,
-                                        did,
-                                        /*bad*/ copy substs.tps))
-        }
+        // Only create the named struct, but don't fill it in. We fill it
+        // in *after* placing it into the type cache. This prevents
+        // infinite recursion with recursive struct types.
+
+        common::T_named_struct(llvm_type_name(cx,
+                                              a_struct,
+                                              did,
+                                              /*bad*/ copy substs.tps))
       }
       ty::ty_self(*) => cx.tcx.sess.unimpl(~"type_of: ty_self"),
       ty::ty_infer(*) => cx.tcx.sess.bug(~"type_of with ty_infer"),
@@ -300,12 +289,10 @@ pub fn type_of(cx: @CrateContext, t: ty::t) -> TypeRef {
       }
 
       ty::ty_struct(did, _) => {
-        if !ty::type_is_simd(cx.tcx, t) {
-          let repr = adt::represent_type(cx, t);
-          let packed = ty::lookup_packed(cx.tcx, did);
-          common::set_struct_body(llty, adt::fields_of(cx, repr),
-                                  packed);
-        }
+        let repr = adt::represent_type(cx, t);
+        let packed = ty::lookup_packed(cx.tcx, did);
+        common::set_struct_body(llty, adt::fields_of(cx, repr),
+                                packed);
       }
       _ => ()
     }

trunk/src/librustc/middle/trans/type_of.rs

@@ -1567,13 +1567,6 @@ pub fn type_is_sequence(ty: t) -> bool {
     }
 }
 
-pub fn type_is_simd(cx: ctxt, ty: t) -> bool {
-    match get(ty).sty {
-        ty_struct(did, _) => lookup_simd(cx, did),
-        _ => false
-    }
-}
-
 pub fn type_is_str(ty: t) -> bool {
     match get(ty).sty {
       ty_estr(_) => true,
@@ -1590,26 +1583,6 @@ pub fn sequence_element_type(cx: ctxt, ty: t) -> t {
     }
 }
 
-pub fn simd_type(cx: ctxt, ty: t) -> t {
-    match get(ty).sty {
-        ty_struct(did, ref substs) => {
-            let fields = lookup_struct_fields(cx, did);
-            lookup_field_type(cx, did, fields[0].id, substs)
-        }
-        _ => fail!(~"simd_type called on invalid type")
-    }
-}
-
-pub fn simd_size(cx: ctxt, ty: t) -> uint {
-    match get(ty).sty {
-        ty_struct(did, _) => {
-            let fields = lookup_struct_fields(cx, did);
-            fields.len()
-        }
-        _ => fail!(~"simd_size called on invalid type")
-    }
-}
-
 pub fn get_element_type(ty: t, i: uint) -> t {
     match get(ty).sty {
       ty_tup(ref ts) => return ts[i],
@@ -2408,14 +2381,6 @@ pub fn type_is_signed(ty: t) -> bool {
     }
 }
 
-pub fn type_is_machine(ty: t) -> bool {
-    match get(ty).sty {
-        ty_int(ast::ty_i) | ty_uint(ast::ty_u) | ty_float(ast::ty_f) => false,
-        ty_int(*) | ty_uint(*) | ty_float(*) => true,
-        _ => false
-    }
-}
-
 // Whether a type is Plain Old Data -- meaning it does not contain pointers
 // that the cycle collector might care about.
 pub fn type_is_pod(cx: ctxt, ty: t) -> bool {
@@ -3931,7 +3896,7 @@ pub fn has_attr(tcx: ctxt, did: def_id, attr: &str) -> bool {
                     attrs: ref attrs,
                     _
                 }, _)) => attr::attrs_contains_name(*attrs, attr),
-            _ => tcx.sess.bug(fmt!("has_attr: %? is not an item",
+            _ => tcx.sess.bug(fmt!("lookup_packed: %? is not an item",
                                    did))
         }
     } else {
@@ -3943,16 +3908,11 @@ pub fn has_attr(tcx: ctxt, did: def_id, attr: &str) -> bool {
     }
 }
 
-/// Determine whether an item is annotated with `#[packed]`
+/// Determine whether an item is annotated with `#[packed]` or not
 pub fn lookup_packed(tcx: ctxt, did: def_id) -> bool {
     has_attr(tcx, did, "packed")
 }
 
-/// Determine whether an item is annotated with `#[simd]`
-pub fn lookup_simd(tcx: ctxt, did: def_id) -> bool {
-    has_attr(tcx, did, "simd")
-}
-
 // Look up a field ID, whether or not it's local
 // Takes a list of type substs in case the struct is generic
 pub fn lookup_field_type(tcx: ctxt,

trunk/src/librustc/middle/ty.rs

@@ -561,14 +561,8 @@ pub fn check_no_duplicate_fields(tcx: ty::ctxt,
 }
 
 pub fn check_struct(ccx: @mut CrateCtxt, id: ast::node_id, span: span) {
-    let tcx = ccx.tcx;
-
     // Check that the class is instantiable
-    check_instantiable(tcx, span, id);
-
-    if ty::lookup_simd(tcx, local_def(id)) {
-        check_simd(tcx, span, id);
-    }
+    check_instantiable(ccx.tcx, span, id);
 }
 
 pub fn check_item(ccx: @mut CrateCtxt, it: @ast::item) {
@@ -3040,35 +3034,6 @@ pub fn check_instantiable(tcx: ty::ctxt,
     }
 }
 
-pub fn check_simd(tcx: ty::ctxt, sp: span, id: ast::node_id) {
-    let t = ty::node_id_to_type(tcx, id);
-    if ty::type_needs_subst(t) {
-        tcx.sess.span_err(sp, "SIMD vector cannot be generic");
-        return;
-    }
-    match ty::get(t).sty {
-        ty::ty_struct(did, ref substs) => {
-            let fields = ty::lookup_struct_fields(tcx, did);
-            if fields.is_empty() {
-                tcx.sess.span_err(sp, "SIMD vector cannot be empty");
-                return;
-            }
-            let e = ty::lookup_field_type(tcx, did, fields[0].id, substs);
-            if !vec::all(fields,
-                         |f| ty::lookup_field_type(tcx, did, f.id, substs) == e) {
-                tcx.sess.span_err(sp, "SIMD vector should be homogeneous");
-                return;
-            }
-            if !ty::type_is_machine(e) {
-                tcx.sess.span_err(sp, "SIMD vector element type should be \
-                                       machine type");
-                return;
-            }
-        }
-        _ => ()
-    }
-}
-
 pub fn check_enum_variants(ccx: @mut CrateCtxt,
                            sp: span,
                            vs: &[ast::variant],