---

yaml
---
r: 139975
b: refs/heads/try2
c: 93c0888
h: refs/heads/master
i:
  139973: f4a3416
  139971: 0f91b3c
  139967: ba8009b
v: v3

Author: huonw

[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: 2b09267b762398a3c851ecfd55d5d01aee906352
+refs/heads/try2: 93c0888b6c6111c645d5aa2ef78da6fe8ab2c307
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/iterator.rs

@@ -39,8 +39,6 @@ pub trait IteratorUtil<A> {
     fn take_while<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhileIterator<'r, A, Self>;
     fn skip(self, n: uint) -> SkipIterator<Self>;
     fn take(self, n: uint) -> TakeIterator<Self>;
-    fn scan<'r, St, B>(self, initial_state: St, f: &'r fn(&mut St, A) -> Option<B>)
-        -> ScanIterator<'r, A, B, Self, St>;
     fn advance(&mut self, f: &fn(A) -> bool);
 }
 
@@ -95,12 +93,6 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
         TakeIterator{iter: self, n: n}
     }
 
-    #[inline(always)]
-    fn scan<'r, St, B>(self, initial_state: St, f: &'r fn(&mut St, A) -> Option<B>)
-        -> ScanIterator<'r, A, B, T, St> {
-        ScanIterator{iter: self, f: f, state: initial_state}
-    }
-
     /// A shim implementing the `for` loop iteration protocol for iterator objects
     #[inline]
     fn advance(&mut self, f: &fn(A) -> bool) {
@@ -314,13 +306,12 @@ impl<A, T: Iterator<A>> Iterator<A> for TakeIterator<T> {
 
 pub struct UnfoldrIterator<'self, A, St> {
     priv f: &'self fn(&mut St) -> Option<A>,
-    state: St
+    priv state: St
 }
 
 pub impl<'self, A, St> UnfoldrIterator<'self, A, St> {
     #[inline]
-    fn new(f: &'self fn(&mut St) -> Option<A>, initial_state: St)
-        -> UnfoldrIterator<'self, A, St> {
+    fn new(f: &'self fn(&mut St) -> Option<A>, initial_state: St) -> UnfoldrIterator<'self, A, St> {
         UnfoldrIterator {
             f: f,
             state: initial_state
@@ -335,19 +326,6 @@ impl<'self, A, St> Iterator<A> for UnfoldrIterator<'self, A, St> {
     }
 }
 
-pub struct ScanIterator<'self, A, B, T, St> {
-    priv iter: T,
-    priv f: &'self fn(&mut St, A) -> Option<B>,
-    state: St
-}
-
-impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B, T, St> {
-    #[inline]
-    fn next(&mut self) -> Option<B> {
-        self.iter.next().chain(|a| (self.f)(&mut self.state, a))
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -428,25 +406,6 @@ mod tests {
         assert_eq!(i, ys.len());
     }
 
-    #[test]
-    fn test_iterator_scan() {
-        // test the type inference
-        fn add(old: &mut int, new: &uint) -> Option<float> {
-            *old += *new as int;
-            Some(*old as float)
-        }
-        let xs = [0u, 1, 2, 3, 4];
-        let ys = [0f, 1f, 3f, 6f, 10f];
-
-        let mut it = xs.iter().scan(0, add);
-        let mut i = 0;
-        for it.advance |x| {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-        assert_eq!(i, ys.len());
-    }
-
     #[test]
     fn test_unfoldr() {
         fn count(st: &mut uint) -> Option<uint> {

branches/try2/src/libcore/sys.rs

@@ -83,24 +83,12 @@ pub fn get_type_desc<T>() -> *TypeDesc {
     unsafe { rusti::get_tydesc::<T>() as *TypeDesc }
 }
 
-/// Returns a pointer to a type descriptor.
-#[inline(always)]
-pub fn get_type_desc_val<T>(_val: &T) -> *TypeDesc {
-    get_type_desc::<T>()
-}
-
 /// Returns the size of a type
 #[inline(always)]
 pub fn size_of<T>() -> uint {
     unsafe { rusti::size_of::<T>() }
 }
 
-/// Returns the size of the type that `_val` points to
-#[inline(always)]
-pub fn size_of_val<T>(_val: &T) -> uint {
-    size_of::<T>()
-}
-
 /**
  * Returns the size of a type, or 1 if the actual size is zero.
  *
@@ -112,13 +100,6 @@ pub fn nonzero_size_of<T>() -> uint {
     if s == 0 { 1 } else { s }
 }
 
-/// Returns the size of the type of the value that `_val` points to
-#[inline(always)]
-pub fn nonzero_size_of_val<T>(_val: &T) -> uint {
-    nonzero_size_of::<T>()
-}
-
-
 /**
  * Returns the ABI-required minimum alignment of a type
  *
@@ -130,26 +111,12 @@ pub fn min_align_of<T>() -> uint {
     unsafe { rusti::min_align_of::<T>() }
 }
 
-/// Returns the ABI-required minimum alignment of the type of the value that
-/// `_val` points to
-#[inline(always)]
-pub fn min_align_of_val<T>(_val: &T) -> uint {
-    min_align_of::<T>()
-}
-
 /// Returns the preferred alignment of a type
 #[inline(always)]
 pub fn pref_align_of<T>() -> uint {
     unsafe { rusti::pref_align_of::<T>() }
 }
 
-/// Returns the preferred alignment of the type of the value that
-/// `_val` points to
-#[inline(always)]
-pub fn pref_align_of_val<T>(_val: &T) -> uint {
-    pref_align_of::<T>()
-}
-
 /// Returns the refcount of a shared box (as just before calling this)
 #[inline(always)]
 pub fn refcount<T>(t: @T) -> uint {
@@ -195,7 +162,7 @@ pub fn fail_assert(msg: &str, file: &str, line: uint) -> ! {
 #[cfg(test)]
 mod tests {
     use cast;
-    use sys::*;
+    use sys::{Closure, pref_align_of, size_of, nonzero_size_of};
 
     #[test]
     fn size_of_basic() {
@@ -221,14 +188,6 @@ mod tests {
         assert!(size_of::<*uint>() == 8u);
     }
 
-    #[test]
-    fn size_of_val_basic() {
-        assert_eq!(size_of_val(&1u8), 1);
-        assert_eq!(size_of_val(&1u16), 2);
-        assert_eq!(size_of_val(&1u32), 4);
-        assert_eq!(size_of_val(&1u64), 8);
-    }
-
     #[test]
     fn nonzero_size_of_basic() {
         type Z = [i8, ..0];
@@ -237,14 +196,6 @@ mod tests {
         assert!(nonzero_size_of::<uint>() == size_of::<uint>());
     }
 
-    #[test]
-    fn nonzero_size_of_val_basic() {
-        let z = [0u8, ..0];
-        assert_eq!(size_of_val(&z), 0u);
-        assert_eq!(nonzero_size_of_val(&z), 1u);
-        assert_eq!(nonzero_size_of_val(&1u), size_of_val(&1u));
-    }
-
     #[test]
     fn align_of_basic() {
         assert!(pref_align_of::<u8>() == 1u);
@@ -268,13 +219,6 @@ mod tests {
         assert!(pref_align_of::<*uint>() == 8u);
     }
 
-    #[test]
-    fn align_of_val_basic() {
-        assert_eq!(pref_align_of_val(&1u8), 1u);
-        assert_eq!(pref_align_of_val(&1u16), 2u);
-        assert_eq!(pref_align_of_val(&1u32), 4u);
-    }
-
     #[test]
     fn synthesize_closure() {
         unsafe {

branches/try2/src/libcore/unstable/intrinsics.rs

@@ -70,16 +70,28 @@ pub extern "rust-intrinsic" {
     pub fn powif32(a: f32, x: i32) -> f32;
     pub fn powif64(a: f64, x: i32) -> f64;
 
+    // the following kill the stack canary without
+    // `fixed_stack_segment`. This possibly only affects the f64
+    // variants, but it's hard to be sure since it seems to only
+    // occur with fairly specific arguments.
+    #[fixed_stack_segment]
     pub fn sinf32(x: f32) -> f32;
+    #[fixed_stack_segment]
     pub fn sinf64(x: f64) -> f64;
 
+    #[fixed_stack_segment]
     pub fn cosf32(x: f32) -> f32;
+    #[fixed_stack_segment]
     pub fn cosf64(x: f64) -> f64;
 
+    #[fixed_stack_segment]
     pub fn powf32(a: f32, x: f32) -> f32;
+    #[fixed_stack_segment]
     pub fn powf64(a: f64, x: f64) -> f64;
 
+    #[fixed_stack_segment]
     pub fn expf32(x: f32) -> f32;
+    #[fixed_stack_segment]
     pub fn expf64(x: f64) -> f64;
 
     pub fn exp2f32(x: f32) -> f32;
@@ -128,4 +140,3 @@ pub extern "rust-intrinsic" {
     pub fn bswap32(x: i32) -> i32;
     pub fn bswap64(x: i64) -> i64;
 }
-

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

@@ -546,6 +546,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                        item: @ast::foreign_item,
                        path: ast_map::path,
                        substs: @param_substs,
+                       attributes: &[ast::attribute],
                        ref_id: Option<ast::node_id>) {
     debug!("trans_intrinsic(item.ident=%s)", *ccx.sess.str_of(item.ident));
 
@@ -561,6 +562,11 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                                Some(copy substs),
                                Some(item.span));
 
+    // Set the fixed stack segment flag if necessary.
+    if attr::attrs_contains_name(attributes, "fixed_stack_segment") {
+        set_fixed_stack_segment(fcx.llfn);
+    }
+
     let mut bcx = top_scope_block(fcx, None), lltop = bcx.llbb;
     match *ccx.sess.str_of(item.ident) {
         ~"atomic_cxchg" => {

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

@@ -212,7 +212,7 @@ pub fn monomorphic_fn(ccx: @CrateContext,
       }
       ast_map::node_foreign_item(i, _, _, _) => {
           let d = mk_lldecl();
-          foreign::trans_intrinsic(ccx, d, i, pt, psubsts.get(),
+          foreign::trans_intrinsic(ccx, d, i, pt, psubsts.get(), i.attrs,
                                 ref_id);
           d
       }