use element count in slices, not size in bytes

This allows the indexing bounds check or other comparisons against an element length to avoid a multiplication by the size.
2013-10-15 00:37:32 -04:00 · 2013-10-15 00:37:32 -04:00 · e1a26ad271
commit e1a26ad271
parent aa93381e14
10 changed files with 154 additions and 76 deletions
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@ -1059,7 +1059,7 @@ fn extract_vec_elems(bcx: @mut Block,
        Store(bcx, slice_begin,
            GEPi(bcx, scratch.val, [0u, abi::slice_elt_base])
        );
-        Store(bcx, slice_len,
+        Store(bcx, UDiv(bcx, slice_len, vt.llunit_size),
            GEPi(bcx, scratch.val, [0u, abi::slice_elt_len])
        );
        elems[n] = scratch.val;
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@ -54,7 +54,7 @@
 use middle::trans::inline;
 use middle::trans::llrepr::LlvmRepr;
 use middle::trans::machine;
-use middle::trans::machine::{llalign_of_min, llsize_of, llsize_of_alloc};
+use middle::trans::machine::{llalign_of_min, llsize_of};
 use middle::trans::meth;
 use middle::trans::monomorphize;
 use middle::trans::tvec;
@ -2910,7 +2910,7 @@ pub fn decl_gc_metadata(ccx: &mut CrateContext, llmod_id: &str) {
    }
 }

-pub fn create_module_map(ccx: &mut CrateContext) -> (ValueRef, uint, uint) {
+pub fn create_module_map(ccx: &mut CrateContext) -> (ValueRef, uint) {
    let str_slice_type = Type::struct_([Type::i8p(), ccx.int_type], false);
    let elttype = Type::struct_([str_slice_type, ccx.int_type], false);
    let maptype = Type::array(&elttype, ccx.module_data.len() as u64);
@ -2942,7 +2942,7 @@ pub fn create_module_map(ccx: &mut CrateContext) -> (ValueRef, uint, uint) {
    unsafe {
        llvm::LLVMSetInitializer(map, C_array(elttype, elts));
    }
-    return (map, keys.len(), llsize_of_alloc(ccx, elttype));
+    return (map, keys.len())
 }


@ -3004,19 +3004,17 @@ pub fn fill_crate_map(ccx: &mut CrateContext, map: ValueRef) {
        lib::llvm::SetLinkage(vec_elements, lib::llvm::InternalLinkage);

        llvm::LLVMSetInitializer(vec_elements, C_array(ccx.int_type, subcrates));
-        let (mod_map, mod_count, mod_struct_size) = create_module_map(ccx);
+        let (mod_map, mod_count) = create_module_map(ccx);

        llvm::LLVMSetInitializer(map, C_struct(
            [C_i32(2),
             C_struct([
                p2i(ccx, mod_map),
-                // byte size of the module map array, an entry consists of two integers
-                C_int(ccx, ((mod_count * mod_struct_size) as int))
+                C_uint(ccx, mod_count)
             ], false),
             C_struct([
                p2i(ccx, vec_elements),
-                // byte size of the subcrates array, an entry consists of an integer
-                C_int(ccx, (subcrates.len() * llsize_of_alloc(ccx, ccx.int_type)) as int)
+                C_uint(ccx, subcrates.len())
             ], false)
        ], false));
    }
--- a/src/librustc/middle/trans/consts.rs
+++ b/src/librustc/middle/trans/consts.rs
@ -83,23 +83,18 @@ pub fn const_ptrcast(cx: &mut CrateContext, a: ValueRef, t: Type) -> ValueRef {
    }
 }

-pub fn const_vec(cx: @mut CrateContext, e: &ast::Expr, es: &[@ast::Expr])
-    -> (ValueRef, ValueRef, Type, bool) {
-    unsafe {
-        let vec_ty = ty::expr_ty(cx.tcx, e);
-        let unit_ty = ty::sequence_element_type(cx.tcx, vec_ty);
-        let llunitty = type_of::type_of(cx, unit_ty);
-        let unit_sz = machine::llsize_of(cx, llunitty);
-        let sz = llvm::LLVMConstMul(C_uint(cx, es.len()), unit_sz);
-        let (vs, inlineable) = vec::unzip(es.iter().map(|e| const_expr(cx, *e)));
-        // If the vector contains enums, an LLVM array won't work.
-        let v = if vs.iter().any(|vi| val_ty(*vi) != llunitty) {
-            C_struct(vs, false)
-        } else {
-            C_array(llunitty, vs)
-        };
-        return (v, sz, llunitty, inlineable.iter().fold(true, |a, &b| a && b));
-    }
+fn const_vec(cx: @mut CrateContext, e: &ast::Expr, es: &[@ast::Expr]) -> (ValueRef, Type, bool) {
+    let vec_ty = ty::expr_ty(cx.tcx, e);
+    let unit_ty = ty::sequence_element_type(cx.tcx, vec_ty);
+    let llunitty = type_of::type_of(cx, unit_ty);
+    let (vs, inlineable) = vec::unzip(es.iter().map(|e| const_expr(cx, *e)));
+    // If the vector contains enums, an LLVM array won't work.
+    let v = if vs.iter().any(|vi| val_ty(*vi) != llunitty) {
+        C_struct(vs, false)
+    } else {
+        C_array(llunitty, vs)
+    };
+    (v, llunitty, inlineable.iter().fold(true, |a, &b| a && b))
 }

 fn const_addr_of(cx: &mut CrateContext, cv: ValueRef) -> ValueRef {
@ -225,9 +220,8 @@ pub fn const_expr(cx: @mut CrateContext, e: &ast::Expr) -> (ValueRef, bool) {
                            assert_eq!(abi::slice_elt_len, 1);

                            match ty::get(ty).sty {
-                                ty::ty_evec(_, ty::vstore_fixed(*)) => {
-                                    let size = machine::llsize_of(cx, val_ty(llconst));
-                                    llconst = C_struct([llptr, size], false);
+                                ty::ty_evec(_, ty::vstore_fixed(len)) => {
+                                    llconst = C_struct([llptr, C_uint(cx, len)], false);
                                }
                                _ => {}
                            }
@ -412,14 +406,8 @@ fn map_list(cx: @mut CrateContext,
                          (bv, C_uint(cx, u)),

                      ty::vstore_slice(_) => {
-                          let unit_ty = ty::sequence_element_type(cx.tcx, bt);
-                          let llunitty = type_of::type_of(cx, unit_ty);
-                          let unit_sz = machine::llsize_of(cx, llunitty);
-
                          let e1 = const_get_elt(cx, bv, [0]);
-                          (const_deref_ptr(cx, e1),
-                           llvm::LLVMConstUDiv(const_get_elt(cx, bv, [1]),
-                                               unit_sz))
+                          (const_deref_ptr(cx, e1), const_get_elt(cx, bv, [1]))
                      },
                      _ => cx.sess.span_bug(base.span,
                                            "index-expr base must be fixed-size or slice")
@ -538,7 +526,7 @@ fn map_list(cx: @mut CrateContext,
              }
          }
          ast::ExprVec(ref es, ast::MutImmutable) => {
-            let (v, _, _, inlineable) = const_vec(cx, e, *es);
+            let (v, _, inlineable) = const_vec(cx, e, *es);
            (v, inlineable)
          }
          ast::ExprVstore(sub, ast::ExprVstoreSlice) => {
@ -550,7 +538,7 @@ fn map_list(cx: @mut CrateContext,
                }
              }
              ast::ExprVec(ref es, ast::MutImmutable) => {
-                let (cv, sz, llunitty, _) = const_vec(cx, e, *es);
+                let (cv, llunitty, _) = const_vec(cx, e, *es);
                let llty = val_ty(cv);
                let gv = do "const".with_c_str |name| {
                    llvm::LLVMAddGlobal(cx.llmod, llty.to_ref(), name)
@ -559,7 +547,7 @@ fn map_list(cx: @mut CrateContext,
                llvm::LLVMSetGlobalConstant(gv, True);
                SetLinkage(gv, PrivateLinkage);
                let p = const_ptrcast(cx, gv, llunitty);
-                (C_struct([p, sz], false), false)
+                (C_struct([p, C_uint(cx, es.len())], false), false)
              }
              _ => cx.sess.span_bug(e.span, "bad const-slice expr")
            }
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@ -1865,7 +1865,7 @@ fn vec_slice_metadata(cx: &mut CrateContext,
            offset: ComputedMemberOffset,
        },
        MemberDescription {
-            name: @"size_in_bytes",
+            name: @"length",
            llvm_type: member_llvm_types[1],
            type_metadata: type_metadata(cx, ty::mk_uint(), span),
            offset: ComputedMemberOffset,
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@ -274,8 +274,12 @@ fn auto_slice(bcx: @mut Block,
                                   ty::vstore_slice(ty::re_static));

        let scratch = scratch_datum(bcx, slice_ty, "__adjust", false);
+
+        let vt = tvec::vec_types(bcx, datum.ty);
+        let unscaled_len = UDiv(bcx, len, vt.llunit_size);
+
        Store(bcx, base, GEPi(bcx, scratch.val, [0u, abi::slice_elt_base]));
-        Store(bcx, len, GEPi(bcx, scratch.val, [0u, abi::slice_elt_len]));
+        Store(bcx, unscaled_len, GEPi(bcx, scratch.val, [0u, abi::slice_elt_len]));
        DatumBlock {bcx: bcx, datum: scratch}
    }

--- a/src/librustc/middle/trans/tvec.rs
+++ b/src/librustc/middle/trans/tvec.rs
@ -237,8 +237,7 @@ pub fn trans_slice_vstore(bcx: @mut Block,
        Ignore => {}
        SaveIn(lldest) => {
            Store(bcx, llfixed, GEPi(bcx, lldest, [0u, abi::slice_elt_base]));
-            let lllen = Mul(bcx, llcount, vt.llunit_size);
-            Store(bcx, lllen, GEPi(bcx, lldest, [0u, abi::slice_elt_len]));
+            Store(bcx, llcount, GEPi(bcx, lldest, [0u, abi::slice_elt_len]));
        }
    }

@ -529,7 +528,8 @@ pub fn get_base_and_len(bcx: @mut Block,
        }
        ty::vstore_slice(_) => {
            let base = Load(bcx, GEPi(bcx, llval, [0u, abi::slice_elt_base]));
-            let len = Load(bcx, GEPi(bcx, llval, [0u, abi::slice_elt_len]));
+            let count = Load(bcx, GEPi(bcx, llval, [0u, abi::slice_elt_len]));
+            let len = Mul(bcx, count, vt.llunit_size);
            (base, len)
        }
        ty::vstore_uniq | ty::vstore_box => {
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@ -52,6 +52,8 @@ fn main () {
 ```
 */

+use sys::size_of;
+use unstable::raw::Slice;
 use cast;
 use container::Container;
 use iter::{Iterator, range};
@ -133,10 +135,10 @@ fn next_u64(&mut self) -> u64 {
    ///    println!("{:?}", v);
    /// }
    /// ```
-    fn fill_bytes(&mut self, mut dest: &mut [u8]) {
-        // this relies on the lengths being transferred correctly when
-        // transmuting between vectors like this.
-        let as_u64: &mut &mut [u64] = unsafe { cast::transmute(&mut dest) };
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        let mut slice: Slice<u64> = unsafe { cast::transmute_copy(&dest) };
+        slice.len /= size_of::<u64>();
+        let as_u64: &mut [u64] = unsafe { cast::transmute(slice) };
        for dest in as_u64.mut_iter() {
            *dest = self.next_u64();
        }
@ -147,7 +149,9 @@ fn fill_bytes(&mut self, mut dest: &mut [u8]) {

        // space for a u32
        if remaining >= 4 {
-            let as_u32: &mut &mut [u32] = unsafe { cast::transmute(&mut dest) };
+            let mut slice: Slice<u32> = unsafe { cast::transmute_copy(&dest) };
+            slice.len /= size_of::<u32>();
+            let as_u32: &mut [u32] = unsafe { cast::transmute(slice) };
            as_u32[as_u32.len() - 1] = self.next_u32();
            remaining -= 4;
        }
--- a/src/libstd/repr.rs
+++ b/src/libstd/repr.rs
@ -186,12 +186,7 @@ pub fn write_mut_qualifier(&mut self, mtbl: uint) {
        }
    }

-    pub fn write_vec_range(&mut self,
-                           _mtbl: uint,
-                           ptr: *(),
-                           len: uint,
-                           inner: *TyDesc)
-                           -> bool {
+    pub fn write_vec_range(&mut self, ptr: *(), len: uint, inner: *TyDesc) -> bool {
        let mut p = ptr as *u8;
        let (sz, al) = unsafe { ((*inner).size, (*inner).align) };
        self.writer.write(['[' as u8]);
@ -213,13 +208,8 @@ pub fn write_vec_range(&mut self,
        true
    }

-    pub fn write_unboxed_vec_repr(&mut self,
-                                  mtbl: uint,
-                                  v: &raw::Vec<()>,
-                                  inner: *TyDesc)
-                                  -> bool {
-        self.write_vec_range(mtbl, ptr::to_unsafe_ptr(&v.data),
-                             v.fill, inner)
+    pub fn write_unboxed_vec_repr(&mut self, _: uint, v: &raw::Vec<()>, inner: *TyDesc) -> bool {
+        self.write_vec_range(ptr::to_unsafe_ptr(&v.data), v.fill, inner)
    }

    fn write_escaped_char(&mut self, ch: char, is_str: bool) {
@ -377,19 +367,32 @@ fn visit_evec_uniq_managed(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
        }
    }

+    #[cfg(stage0)]
    fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
        do self.get::<raw::Slice<()>> |this, s| {
            this.writer.write(['&' as u8]);
            this.write_mut_qualifier(mtbl);
-            this.write_vec_range(mtbl, s.data, s.len, inner);
+            this.write_vec_range(s.data, s.len, inner);
+        }
+    }
+
+    #[cfg(not(stage0))]
+    fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
+        do self.get::<raw::Slice<()>> |this, s| {
+            this.writer.write(['&' as u8]);
+            this.write_mut_qualifier(mtbl);
+            let size = unsafe {
+                if (*inner).size == 0 { 1 } else { (*inner).size }
+            };
+            this.write_vec_range(s.data, s.len * size, inner);
        }
    }

    fn visit_evec_fixed(&mut self, n: uint, sz: uint, _align: uint,
-                        mtbl: uint, inner: *TyDesc) -> bool {
+                        _: uint, inner: *TyDesc) -> bool {
        let assumed_size = if sz == 0 { n } else { sz };
        do self.get::<()> |this, b| {
-            this.write_vec_range(mtbl, ptr::to_unsafe_ptr(b), assumed_size, inner);
+            this.write_vec_range(ptr::to_unsafe_ptr(b), assumed_size, inner);
        }
    }

--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@ -974,6 +974,7 @@ pub trait ImmutableVector<'self, T> {

 impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
    #[inline]
+    #[cfg(stage0)]
    fn slice(&self, start: uint, end: uint) -> &'self [T] {
        assert!(start <= end);
        assert!(end <= self.len());
@ -986,10 +987,27 @@ fn slice(&self, start: uint, end: uint) -> &'self [T] {
            }
        }
    }
+
+    #[inline]
+    #[cfg(not(stage0))]
+    fn slice(&self, start: uint, end: uint) -> &'self [T] {
+        assert!(start <= end);
+        assert!(end <= self.len());
+        do self.as_imm_buf |p, _len| {
+            unsafe {
+                cast::transmute(Slice {
+                    data: ptr::offset(p, start as int),
+                    len: (end - start)
+                })
+            }
+        }
+    }
+
    #[inline]
    fn slice_from(&self, start: uint) -> &'self [T] {
        self.slice(start, self.len())
    }
+
    #[inline]
    fn slice_to(&self, end: uint) -> &'self [T] {
        self.slice(0, end)
@ -1130,10 +1148,18 @@ fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U] {
    }

    #[inline]
+    #[cfg(stage0)]
    fn as_imm_buf<U>(&self, f: &fn(*T, uint) -> U) -> U {
        let s = self.repr();
        f(s.data, s.len / sys::nonzero_size_of::<T>())
    }
+
+    #[inline]
+    #[cfg(not(stage0))]
+    fn as_imm_buf<U>(&self, f: &fn(*T, uint) -> U) -> U {
+        let s = self.repr();
+        f(s.data, s.len)
+    }
 }

 /// Extension methods for vectors contain `Eq` elements.
@ -1899,6 +1925,7 @@ fn mut_split(self, mid: uint) -> (&'self mut [T],

 impl<'self,T> MutableVector<'self, T> for &'self mut [T] {
    #[inline]
+    #[cfg(stage0)]
    fn mut_slice(self, start: uint, end: uint) -> &'self mut [T] {
        assert!(start <= end);
        assert!(end <= self.len());
@ -1912,6 +1939,21 @@ fn mut_slice(self, start: uint, end: uint) -> &'self mut [T] {
        }
    }

+    #[inline]
+    #[cfg(not(stage0))]
+    fn mut_slice(self, start: uint, end: uint) -> &'self mut [T] {
+        assert!(start <= end);
+        assert!(end <= self.len());
+        do self.as_mut_buf |p, _len| {
+            unsafe {
+                cast::transmute(Slice {
+                    data: ptr::mut_offset(p, start as int) as *T,
+                    len: (end - start)
+                })
+            }
+        }
+    }
+
    #[inline]
    fn mut_slice_from(self, start: uint) -> &'self mut [T] {
        let len = self.len();
@ -1991,11 +2033,18 @@ unsafe fn unsafe_set(self, index: uint, val: T) {
    }

    #[inline]
+    #[cfg(stage0)]
    fn as_mut_buf<U>(self, f: &fn(*mut T, uint) -> U) -> U {
        let Slice{ data, len } = self.repr();
        f(data as *mut T, len / sys::nonzero_size_of::<T>())
    }

+    #[inline]
+    #[cfg(not(stage0))]
+    fn as_mut_buf<U>(self, f: &fn(*mut T, uint) -> U) -> U {
+        let Slice{ data, len } = self.repr();
+        f(data as *mut T, len)
+    }
 }

 /// Trait for &[T] where T is Cloneable
@ -2083,6 +2132,7 @@ pub fn to_mut_ptr<T>(v: &mut [T]) -> *mut T {
     * not bytes).
     */
    #[inline]
+    #[cfg(stage0)]
    pub unsafe fn buf_as_slice<T,U>(p: *T,
                                    len: uint,
                                    f: &fn(v: &[T]) -> U) -> U {
@ -2097,6 +2147,22 @@ pub unsafe fn buf_as_slice<T,U>(p: *T,
     * not bytes).
     */
    #[inline]
+    #[cfg(not(stage0))]
+    pub unsafe fn buf_as_slice<T,U>(p: *T,
+                                    len: uint,
+                                    f: &fn(v: &[T]) -> U) -> U {
+        f(cast::transmute(Slice {
+            data: p,
+            len: len
+        }))
+    }
+
+    /**
+     * Form a slice from a pointer and length (as a number of units,
+     * not bytes).
+     */
+    #[inline]
+    #[cfg(stage0)]
    pub unsafe fn mut_buf_as_slice<T,U>(p: *mut T,
                                        len: uint,
                                        f: &fn(v: &mut [T]) -> U) -> U {
@ -2106,6 +2172,21 @@ pub unsafe fn mut_buf_as_slice<T,U>(p: *mut T,
        }))
    }

+    /**
+     * Form a slice from a pointer and length (as a number of units,
+     * not bytes).
+     */
+    #[inline]
+    #[cfg(not(stage0))]
+    pub unsafe fn mut_buf_as_slice<T,U>(p: *mut T,
+                                        len: uint,
+                                        f: &fn(v: &mut [T]) -> U) -> U {
+        f(cast::transmute(Slice {
+            data: p as *T,
+            len: len
+        }))
+    }
+
    /**
     * Unchecked vector indexing.
     */
--- a/src/test/debug-info/vec-slices.rs
+++ b/src/test/debug-info/vec-slices.rs
@ -13,33 +13,33 @@
 // debugger:rbreak zzz
 // debugger:run
 // debugger:finish
-// debugger:print empty.size_in_bytes
+// debugger:print empty.length
 // check:$1 = 0

-// debugger:print singleton.size_in_bytes
-// check:$2 = 8
+// debugger:print singleton.length
+// check:$2 = 1
 // debugger:print *((int64_t[1]*)(singleton.data_ptr))
 // check:$3 = {1}

-// debugger:print multiple.size_in_bytes
-// check:$4 = 32
+// debugger:print multiple.length
+// check:$4 = 4
 // debugger:print *((int64_t[4]*)(multiple.data_ptr))
 // check:$5 = {2, 3, 4, 5}

-// debugger:print slice_of_slice.size_in_bytes
-// check:$6 = 16
+// debugger:print slice_of_slice.length
+// check:$6 = 2
 // debugger:print *((int64_t[2]*)(slice_of_slice.data_ptr))
 // check:$7 = {3, 4}

-// debugger:print padded_tuple.size_in_bytes
-// check:$8 = 16
+// debugger:print padded_tuple.length
+// check:$8 = 2
 // debugger:print padded_tuple.data_ptr[0]
 // check:$9 = {6, 7}
 // debugger:print padded_tuple.data_ptr[1]
 // check:$10 = {8, 9}

-// debugger:print padded_struct.size_in_bytes
-// check:$11 = 24
+// debugger:print padded_struct.length
+// check:$11 = 2
 // debugger:print padded_struct.data_ptr[0]
 // check:$12 = {x = 10, y = 11, z = 12}
 // debugger:print padded_struct.data_ptr[1]