---

yaml
---
r: 60061
b: refs/heads/master
c: 19d2ba3
h: refs/heads/master
i:
  60059: 592d7ca
v: v3

Author: bors

[refs]

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

trunk/src/libcore/core.rc

@@ -164,7 +164,6 @@ pub mod nil;
 pub mod bool;
 pub mod char;
 pub mod tuple;
-pub mod simd;
 
 pub mod vec;
 pub mod at_vec;

trunk/src/libcore/simd.rs

@@ -991,7 +991,7 @@ pub fn connect<T:Copy>(v: &[~[T]], sep: &T) -> ~[T] {
  * ~~~
  *
  */
-pub fn foldl<T, U>(z: T, v: &[U], p: &fn(t: T, u: &U) -> T) -> T {
+pub fn foldl<'a, T, U>(z: T, v: &'a [U], p: &fn(t: T, u: &'a U) -> T) -> T {
     let mut accum = z;
     let mut i = 0;
     let l = v.len();
@@ -1023,12 +1023,13 @@ pub fn foldl<T, U>(z: T, v: &[U], p: &fn(t: T, u: &U) -> T) -> T {
  * ~~~
  *
  */
-pub fn foldr<T, U: Copy>(v: &[T], z: U, p: &fn(t: &T, u: U) -> U) -> U {
-    let mut accum = z;
-    for v.each_reverse |elt| {
-        accum = p(elt, accum);
+pub fn foldr<'a, T, U>(v: &'a [T], mut z: U, p: &fn(t: &'a T, u: U) -> U) -> U {
+    let mut i = v.len();
+    while i > 0 {
+        i -= 1;
+        z = p(&v[i], z);
     }
-    accum
+    return z;
 }
 
 /**
@@ -1848,7 +1849,7 @@ pub trait ImmutableVector<'self, T> {
     fn last_opt(&self) -> Option<&'self T>;
     fn each_reverse(&self, blk: &fn(&T) -> bool);
     fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool);
-    fn foldr<U: Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U;
+    fn foldr<'a, U>(&'a self, z: U, p: &fn(t: &'a T, u: U) -> U) -> U;
     fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U];
     fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U];
     fn map_r<U>(&self, f: &fn(x: &T) -> U) -> ~[U];
@@ -1921,7 +1922,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
 
     /// Reduce a vector from right to left
     #[inline]
-    fn foldr<U:Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U {
+    fn foldr<'a, U>(&'a self, z: U, p: &fn(t: &'a T, u: U) -> U) -> U {
         foldr(*self, z, p)
     }
 

trunk/src/libcore/vec.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) {
@@ -3053,35 +3047,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],

trunk/src/librustc/middle/typeck/check/mod.rs

@@ -379,6 +379,7 @@ pub mod reader {
         fn read_int(&mut self) -> int {
             let v = doc_as_u64(self.next_doc(EsInt)) as i64;
             if v > (int::max_value as i64) || v < (int::min_value as i64) {
+                debug!("FIXME #6122: Removing this makes this function miscompile");
                 fail!(fmt!("int %? out of range for this architecture", v));
             }
             v as int

trunk/src/libstd/ebml.rs

@@ -0,0 +1,14 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    let box1 = @mut 42;
+    let _x = *(&mut *box1) == 42 || *(&mut *box1) == 31337;
+}