From e1a26ad2713994ccba65d62ca64a2eb5db4eaf81 Mon Sep 17 00:00:00 2001 From: Daniel Micay Date: Tue, 15 Oct 2013 00:37:32 -0400 Subject: [PATCH] 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. --- src/librustc/middle/trans/_match.rs | 2 +- src/librustc/middle/trans/base.rs | 14 ++--- src/librustc/middle/trans/consts.rs | 48 ++++++--------- src/librustc/middle/trans/debuginfo.rs | 2 +- src/librustc/middle/trans/expr.rs | 6 +- src/librustc/middle/trans/tvec.rs | 6 +- src/libstd/rand/mod.rs | 14 +++-- src/libstd/repr.rs | 35 ++++++----- src/libstd/vec.rs | 81 ++++++++++++++++++++++++++ src/test/debug-info/vec-slices.rs | 22 +++---- 10 files changed, 154 insertions(+), 76 deletions(-) diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index a159512aee5b..15c1f8ea339d 100644 --- 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; diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 1822237f45ca..d9f16a4efe65 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -54,7 +54,7 @@ use middle::trans::glue; 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)); } diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index 00431501e642..f85b8de35dd5 100644 --- 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 const_expr_unadjusted(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 const_expr_unadjusted(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 const_expr_unadjusted(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 const_expr_unadjusted(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") } diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index a982a4767fdc..5ebecca0562b 100644 --- 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, diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 12bb71d19ed2..a58151fb265f 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -274,8 +274,12 @@ pub fn trans_to_datum(bcx: @mut Block, expr: &ast::Expr) -> DatumBlock { 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} } diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs index 7bcbedf50f75..0340779d0c53 100644 --- 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 => { diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index b800c7b03af3..1e76effd0d24 100644 --- 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 @@ pub trait Rng { /// 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 = unsafe { cast::transmute_copy(&dest) }; + slice.len /= size_of::(); + let as_u64: &mut [u64] = unsafe { cast::transmute(slice) }; for dest in as_u64.mut_iter() { *dest = self.next_u64(); } @@ -147,7 +149,9 @@ pub trait Rng { // space for a u32 if remaining >= 4 { - let as_u32: &mut &mut [u32] = unsafe { cast::transmute(&mut dest) }; + let mut slice: Slice = unsafe { cast::transmute_copy(&dest) }; + slice.len /= size_of::(); + let as_u32: &mut [u32] = unsafe { cast::transmute(slice) }; as_u32[as_u32.len() - 1] = self.next_u32(); remaining -= 4; } diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs index ff2663fb1f73..49d5bb3918b8 100644 --- a/src/libstd/repr.rs +++ b/src/libstd/repr.rs @@ -186,12 +186,7 @@ impl<'self> ReprVisitor<'self> { } } - 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 @@ impl<'self> ReprVisitor<'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 @@ impl<'self> TyVisitor for ReprVisitor<'self> { } } + #[cfg(stage0)] fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool { do self.get::> |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::> |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); } } diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 77e38b480676..93374d97db55 100644 --- 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 @@ impl<'self,T> ImmutableVector<'self, T> for &'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 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { } #[inline] + #[cfg(stage0)] fn as_imm_buf(&self, f: &fn(*T, uint) -> U) -> U { let s = self.repr(); f(s.data, s.len / sys::nonzero_size_of::()) } + + #[inline] + #[cfg(not(stage0))] + fn as_imm_buf(&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 @@ pub trait MutableVector<'self, 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 @@ impl<'self,T> MutableVector<'self, T> for &'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 @@ impl<'self,T> MutableVector<'self, T> for &'self mut [T] { } #[inline] + #[cfg(stage0)] fn as_mut_buf(self, f: &fn(*mut T, uint) -> U) -> U { let Slice{ data, len } = self.repr(); f(data as *mut T, len / sys::nonzero_size_of::()) } + #[inline] + #[cfg(not(stage0))] + fn as_mut_buf(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 mod raw { * not bytes). */ #[inline] + #[cfg(stage0)] pub unsafe fn buf_as_slice(p: *T, len: uint, f: &fn(v: &[T]) -> U) -> U { @@ -2097,6 +2147,22 @@ pub mod raw { * not bytes). */ #[inline] + #[cfg(not(stage0))] + pub unsafe fn buf_as_slice(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(p: *mut T, len: uint, f: &fn(v: &mut [T]) -> U) -> U { @@ -2106,6 +2172,21 @@ pub mod raw { })) } + /** + * 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(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. */ diff --git a/src/test/debug-info/vec-slices.rs b/src/test/debug-info/vec-slices.rs index 9e5fb9236db6..1b6dfaecfcd9 100644 --- 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]