---

yaml
---
r: 105975
b: refs/heads/auto
c: 770b6e2
h: refs/heads/master
i:
  105973: e29e3c1
  105971: 3d20ca3
  105967: 9fa06cb
v: v3

Author: alexcrichton

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 76e0e26603d723038dae1ad06161cade47e53a55
+refs/heads/auto: 770b6e2fc2f8749466487e4c2ae031b8ceecae04
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/guide-tasks.md

@@ -351,6 +351,8 @@ fn pnorm(nums: &~[f64], p: uint) -> f64 {
 
 fn main() {
     let numbers = vec::from_fn(1000000, |_| rand::random::<f64>());
+    println!("Inf-norm = {}",  *numbers.iter().max().unwrap());
+
     let numbers_arc = Arc::new(numbers);
 
     for num in range(1u, 10) {

branches/auto/src/libgreen/context.rs

@@ -283,8 +283,6 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
     unsafe { *sp = 0; }
 
     regs[4] = arg as uint;
-    regs[5] = procedure.code as uint;
-    regs[6] = procedure.env as uint;
     regs[29] = sp as uint;
     regs[25] = fptr as uint;
     regs[31] = fptr as uint;

branches/auto/src/librustc/back/mips.rs

@@ -22,39 +22,39 @@ pub fn get_target_strs(target_triple: ~str, target_os: abi::Os) -> target_strs::
 
         data_layout: match target_os {
           abi::OsMacos => {
-            ~"E-p:32:32:32" +
+            ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
           abi::OsWin32 => {
-            ~"E-p:32:32:32" +
+            ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
           abi::OsLinux => {
-            ~"E-p:32:32:32" +
+            ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
           abi::OsAndroid => {
-            ~"E-p:32:32:32" +
+            ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +
                 "-a0:0:64-n32"
           }
 
           abi::OsFreebsd => {
-            ~"E-p:32:32:32" +
+            ~"e-p:32:32:32" +
                 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" +
                 "-f32:32:32-f64:64:64" +
                 "-v64:64:64-v128:64:128" +

branches/auto/src/libstd/cmp.rs

@@ -184,12 +184,12 @@ pub trait Equiv<T> {
 }
 
 #[inline]
-pub fn min<T: TotalOrd>(v1: T, v2: T) -> T {
+pub fn min<T:Ord>(v1: T, v2: T) -> T {
     if v1 < v2 { v1 } else { v2 }
 }
 
 #[inline]
-pub fn max<T: TotalOrd>(v1: T, v2: T) -> T {
+pub fn max<T:Ord>(v1: T, v2: T) -> T {
     if v1 > v2 { v1 } else { v2 }
 }
 

branches/auto/src/libstd/iter.rs

@@ -68,7 +68,7 @@ use cmp;
 use num::{Zero, One, CheckedAdd, CheckedSub, Saturating, ToPrimitive, Int};
 use option::{Option, Some, None};
 use ops::{Add, Mul, Sub};
-use cmp::{Eq, Ord, TotalOrd};
+use cmp::{Eq, Ord};
 use clone::Clone;
 use uint;
 use mem;
@@ -626,7 +626,7 @@ pub trait Iterator<A> {
     /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
     /// ```
     #[inline]
-    fn max_by<B: TotalOrd>(&mut self, f: |&A| -> B) -> Option<A> {
+    fn max_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A> {
         self.fold(None, |max: Option<(A, B)>, x| {
             let x_val = f(&x);
             match max {
@@ -650,7 +650,7 @@ pub trait Iterator<A> {
     /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
     /// ```
     #[inline]
-    fn min_by<B: TotalOrd>(&mut self, f: |&A| -> B) -> Option<A> {
+    fn min_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A> {
         self.fold(None, |min: Option<(A, B)>, x| {
             let x_val = f(&x);
             match min {
@@ -917,7 +917,7 @@ pub trait OrdIterator<A> {
     fn min_max(&mut self) -> MinMaxResult<A>;
 }
 
-impl<A: TotalOrd, T: Iterator<A>> OrdIterator<A> for T {
+impl<A: Ord, T: Iterator<A>> OrdIterator<A> for T {
     #[inline]
     fn max(&mut self) -> Option<A> {
         self.fold(None, |max, x| {

branches/auto/src/libstd/libc.rs

@@ -2137,7 +2137,7 @@ pub mod consts {
             pub static MAP_SHARED : c_int = 0x0001;
             pub static MAP_PRIVATE : c_int = 0x0002;
             pub static MAP_FIXED : c_int = 0x0010;
-            pub static MAP_ANON : c_int = 0x0800;
+            pub static MAP_ANON : c_int = 0x0020;
 
             pub static MAP_FAILED : *c_void = -1 as *c_void;
 
@@ -2433,19 +2433,20 @@ pub mod consts {
             pub static O_DSYNC : c_int = 16;
             pub static O_SYNC : c_int = 16400;
 
-            pub static PROT_GROWSDOWN : c_int = 0x01000000;
-            pub static PROT_GROWSUP : c_int = 0x02000000;
+            pub static PROT_GROWSDOWN : c_int = 0x010000000;
+            pub static PROT_GROWSUP : c_int = 0x020000000;
 
             pub static MAP_TYPE : c_int = 0x000f;
-            pub static MAP_ANONONYMOUS : c_int = 0x0800;
-            pub static MAP_GROWSDOWN : c_int = 0x01000;
-            pub static MAP_DENYWRITE : c_int = 0x02000;
-            pub static MAP_EXECUTABLE : c_int = 0x04000;
-            pub static MAP_LOCKED : c_int = 0x08000;
-            pub static MAP_NONRESERVE : c_int = 0x0400;
-            pub static MAP_POPULATE : c_int = 0x010000;
-            pub static MAP_NONBLOCK : c_int = 0x020000;
-            pub static MAP_STACK : c_int = 0x040000;
+            pub static MAP_ANONONYMOUS : c_int = 0x0020;
+            pub static MAP_32BIT : c_int = 0x0040;
+            pub static MAP_GROWSDOWN : c_int = 0x0100;
+            pub static MAP_DENYWRITE : c_int = 0x0800;
+            pub static MAP_EXECUTABLE : c_int = 0x01000;
+            pub static MAP_LOCKED : c_int = 0x02000;
+            pub static MAP_NONRESERVE : c_int = 0x04000;
+            pub static MAP_POPULATE : c_int = 0x08000;
+            pub static MAP_NONBLOCK : c_int = 0x010000;
+            pub static MAP_STACK : c_int = 0x020000;
         }
         #[cfg(target_os = "linux")]
         pub mod sysconf {

branches/auto/src/libstd/option.rs

@@ -104,7 +104,7 @@ impl<T> Option<T> {
         }
     }
 
-    /// Convert from `Option<T>` to `&mut [T]` (without copying)
+    /// Convert from `Option<T>` to `&[T]` (without copying)
     #[inline]
     pub fn as_mut_slice<'r>(&'r mut self) -> &'r mut [T] {
         match *self {
@@ -211,13 +211,19 @@ impl<T> Option<T> {
     /// Return an iterator over the possibly contained value
     #[inline]
     pub fn iter<'r>(&'r self) -> Item<&'r T> {
-        Item{opt: self.as_ref()}
+        match *self {
+            Some(ref x) => Item{opt: Some(x)},
+            None => Item{opt: None}
+        }
     }
 
     /// Return a mutable iterator over the possibly contained value
     #[inline]
     pub fn mut_iter<'r>(&'r mut self) -> Item<&'r mut T> {
-        Item{opt: self.as_mut()}
+        match *self {
+            Some(ref mut x) => Item{opt: Some(x)},
+            None => Item{opt: None}
+        }
     }
 
     /// Return a consuming iterator over the possibly contained value

branches/auto/src/libstd/rt/libunwind.rs

@@ -65,9 +65,6 @@ pub static unwinder_private_data_size: int = 2;
 #[cfg(target_arch = "arm")]
 pub static unwinder_private_data_size: int = 20;
 
-#[cfg(target_arch = "mips")]
-pub static unwinder_private_data_size: int = 2;
-
 pub struct _Unwind_Exception {
     exception_class: _Unwind_Exception_Class,
     exception_cleanup: _Unwind_Exception_Cleanup_Fn,

branches/auto/src/libstd/sync/atomics.rs

@@ -225,10 +225,6 @@ impl AtomicInt {
     }
 }
 
-// temporary workaround
-// it causes link failure on MIPS target
-// libgcc doesn't implement 64-bit atomic operations for MIPS32
-#[cfg(not(target_arch = "mips"))]
 impl AtomicU64 {
     pub fn new(v: u64) -> AtomicU64 {
         AtomicU64 { v:v, nopod: marker::NoPod }

branches/auto/src/libstd/unstable/mutex.rs

@@ -324,16 +324,12 @@ mod imp {
         static __SIZEOF_PTHREAD_MUTEX_T: uint = 24 - 8;
         #[cfg(target_arch = "arm")]
         static __SIZEOF_PTHREAD_MUTEX_T: uint = 24 - 8;
-        #[cfg(target_arch = "mips")]
-        static __SIZEOF_PTHREAD_MUTEX_T: uint = 24 - 8;
         #[cfg(target_arch = "x86_64")]
         static __SIZEOF_PTHREAD_COND_T: uint = 48 - 8;
         #[cfg(target_arch = "x86")]
         static __SIZEOF_PTHREAD_COND_T: uint = 48 - 8;
         #[cfg(target_arch = "arm")]
         static __SIZEOF_PTHREAD_COND_T: uint = 48 - 8;
-        #[cfg(target_arch = "mips")]
-        static __SIZEOF_PTHREAD_COND_T: uint = 48 - 8;
 
         pub struct pthread_mutex_t {
             __align: libc::c_longlong,

branches/auto/src/libsyntax/attr.rs

@@ -317,9 +317,9 @@ pub fn test_cfg<AM: AttrMetaMethods, It: Iterator<AM>>
                                 debug!("not!");
                                 // inside #[cfg(not(...))], so these need to all
                                 // not match.
-                                not_cfgs.iter().all(|mi| {
+                                !not_cfgs.iter().all(|mi| {
                                     debug!("cfg(not({}[...]))", mi.name());
-                                    !contains(cfg, *mi)
+                                    contains(cfg, *mi)
                                 })
                             }
                             _ => contains(cfg, *cfg_mi)

branches/auto/src/libtest/lib.rs

@@ -1070,7 +1070,7 @@ impl MetricMap {
                     if delta.abs() <= noise {
                         LikelyNoise
                     } else {
-                        let pct = delta.abs() / vold.value.max(f64::EPSILON) * 100.0;
+                        let pct = delta.abs() / cmp::max(vold.value, f64::EPSILON) * 100.0;
                         if vold.noise < 0.0 {
                             // When 'noise' is negative, it means we want
                             // to see deltas that go up over time, and can

branches/auto/src/rt/arch/mips/morestack.S

@@ -19,21 +19,38 @@ __morestack:
         .set noreorder
         .set nomacro
 
-        addiu $29, $29, -4
-        sw $30, 0($29)
+        // n.b. most of this is probably unnecessary. I know very little mips
+        //      assembly, and I didn't have anything to test on, so I wasn't
+        //      brave enough to try to trim this down.
 
-        // 16 = 4 (current) + 12 (previous)
-        .cfi_def_cfa_offset 16
+        addiu $29, $29, -12
+        sw $31, 8($29)
+        sw $30, 4($29)
+        sw $23, 0($29)
+
+        // 24 = 12 (current) + 12 (previous)
+        .cfi_def_cfa_offset 24
         .cfi_offset 31, -4
-        .cfi_offset 30, -16
+        .cfi_offset 30, -20
+        .cfi_offset 23, -24
 
+        move $23, $28
         move $30, $29
         .cfi_def_cfa_register 30
 
-        // O32 ABI always reserves 16 bytes for arguments
-        addiu $29, $29, -16
+        // Save argument registers of the original function
+        addiu $29, $29, -32
+        sw $4, 16($29)
+        sw $5, 20($29)
+        sw $6, 24($29)
+        sw $7, 28($29)
+
+        move $4, $14     // Size of stack arguments
+        addu $5, $30, 24 // Address of stack arguments
+        move $6, $15     // The amount of stack needed
 
-        lw $25, %call16(rust_stack_exhausted)($28)
+        move $28, $23
+        lw $25, %call16(rust_stack_exhausted)($23)
         jalr $25
         nop
 

branches/auto/src/test/run-pass/cfgs-on-items.rs

@@ -16,16 +16,24 @@
 fn foo1() -> int { 1 }
 
 // !fooA AND !bar
-#[cfg(not(fooA, bar))]
+#[cfg(not(fooA), not(bar))]
 fn foo2() -> int { 2 }
 
 // fooC OR (fooB AND !bar)
 #[cfg(fooC)]
 #[cfg(fooB, not(bar))]
 fn foo2() -> int { 3 }
 
+// fooA AND bar
+#[cfg(fooA, bar)]
+fn foo3() -> int { 2 }
+
+// !(fooA AND bar)
+#[cfg(not(fooA, bar))]
+fn foo3() -> int { 3 }
 
 pub fn main() {
     assert_eq!(1, foo1());
     assert_eq!(3, foo2());
+    assert_eq!(3, foo3());
 }

branches/auto/src/test/run-pass/tcp-stress.rs

@@ -28,10 +28,10 @@ fn main() {
     });
 
     let addr = SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 0 };
-    let (tx, rx) = channel();
+    let (p, c) = Chan::new();
     spawn(proc() {
         let mut listener = TcpListener::bind(addr).unwrap();
-        tx.send(listener.socket_name().unwrap());
+        c.send(listener.socket_name().unwrap());
         let mut acceptor = listener.listen();
         loop {
             let mut stream = match acceptor.accept() {
@@ -45,11 +45,11 @@ fn main() {
             stream.write([2]);
         }
     });
-    let addr = rx.recv();
+    let addr = p.recv();
 
-    let (tx, rx) = channel();
+    let (p, c) = Chan::new();
     for _ in range(0, 1000) {
-        let tx = tx.clone();
+        let c = c.clone();
         spawn(proc() {
             match TcpStream::connect(addr) {
                 Ok(stream) => {
@@ -60,15 +60,15 @@ fn main() {
                 },
                 Err(e) => debug!("{:?}", e)
             }
-            tx.send(());
+            c.send(());
         });
     }
 
     // Wait for all clients to exit, but don't wait for the server to exit. The
     // server just runs infinitely.
-    drop(tx);
+    drop(c);
     for _ in range(0, 1000) {
-        rx.recv();
+        p.recv();
     }
     unsafe { libc::exit(0) }
 }