---

yaml
---
r: 81274
b: refs/heads/snap-stage3
c: 350b543
h: refs/heads/master
v: v3

Author: crabtw

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 23cb72b4599f61fbeab4d8f0af8937e76a3cb364
+refs/heads/snap-stage3: 350b5438cd0b2a9ed33c0cdb1b36d7e4cbe1ab2b
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/platform.mk

@@ -343,7 +343,7 @@ CFG_PATH_MUNGE_mips-unknown-linux-gnu := true
 CFG_LDPATH_mips-unknown-linux-gnu :=
 CFG_RUN_mips-unknown-linux-gnu=
 CFG_RUN_TARG_mips-unknown-linux-gnu=
-RUSTC_FLAGS_mips-unknown-linux-gnu := --linker=$(CXX_mips-unknown-linux-gnu) --target-cpu mips32r2 --target-feature +mips32r2,+o32
+RUSTC_FLAGS_mips-unknown-linux-gnu := --linker=$(CXX_mips-unknown-linux-gnu) --target-cpu mips32r2 --target-feature +mips32r2,+o32 -Z soft-float
 
 # i686-pc-mingw32 configuration
 CC_i686-pc-mingw32=$(CC)

branches/snap-stage3/src/librustc/back/link.rs

@@ -264,6 +264,7 @@ pub mod write {
               session::Default => lib::llvm::CodeGenLevelDefault,
               session::Aggressive => lib::llvm::CodeGenLevelAggressive,
             };
+            let use_softfp = sess.opts.debugging_opts & session::use_softfp != 0;
 
             let tm = do sess.targ_cfg.target_strs.target_triple.with_c_str |T| {
                 do sess.opts.target_cpu.with_c_str |CPU| {
@@ -273,7 +274,8 @@ pub mod write {
                             lib::llvm::CodeModelDefault,
                             lib::llvm::RelocPIC,
                             OptLevel,
-                            true
+                            true,
+                            use_softfp
                         )
                     }
                 }

branches/snap-stage3/src/librustc/driver/session.rs

@@ -80,6 +80,7 @@ pub static print_llvm_passes:       uint = 1 << 26;
 pub static no_vectorize_loops:      uint = 1 << 27;
 pub static no_vectorize_slp:        uint = 1 << 28;
 pub static no_prepopulate_passes:   uint = 1 << 29;
+pub static use_softfp:              uint = 1 << 30;
 
 pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
     ~[(~"verbose", ~"in general, enable more debug printouts", verbose),
@@ -135,6 +136,7 @@ pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
      (~"no-vectorize-slp",
       ~"Don't run LLVM's SLP vectorization passes",
       no_vectorize_slp),
+     (~"soft-float", ~"Generate software floating point library calls", use_softfp),
     ]
 }
 

branches/snap-stage3/src/librustc/lib/llvm.rs

@@ -2149,7 +2149,8 @@ pub mod llvm {
                                            Model: CodeGenModel,
                                            Reloc: RelocMode,
                                            Level: CodeGenOptLevel,
-                                           EnableSegstk: bool) -> TargetMachineRef;
+                                           EnableSegstk: bool,
+                                           UseSoftFP: bool) -> TargetMachineRef;
         pub fn LLVMRustDisposeTargetMachine(T: TargetMachineRef);
         pub fn LLVMRustAddAnalysisPasses(T: TargetMachineRef,
                                          PM: PassManagerRef,

branches/snap-stage3/src/librustc/metadata/encoder.rs

@@ -1574,7 +1574,7 @@ fn encode_crate_deps(ecx: &EncodeContext,
 fn encode_lang_items(ecx: &EncodeContext, ebml_w: &mut writer::Encoder) {
     ebml_w.start_tag(tag_lang_items);
 
-    for (i, def_id) in ecx.tcx.lang_items.items() {
+    do ecx.tcx.lang_items.each_item |def_id, i| {
         for id in def_id.iter() {
             if id.crate == LOCAL_CRATE {
                 ebml_w.start_tag(tag_lang_items_item);
@@ -1590,7 +1590,8 @@ fn encode_lang_items(ecx: &EncodeContext, ebml_w: &mut writer::Encoder) {
                 ebml_w.end_tag();   // tag_lang_items_item
             }
         }
-    }
+        true
+    };
 
     ebml_w.end_tag();   // tag_lang_items
 }

branches/snap-stage3/src/librustc/middle/lang_items.rs

@@ -32,8 +32,6 @@ use syntax::visit;
 use syntax::visit::Visitor;
 
 use std::hashmap::HashMap;
-use std::iter::Enumerate;
-use std::vec;
 
 pub enum LangItem {
     FreezeTraitLangItem,               // 0
@@ -94,8 +92,8 @@ impl LanguageItems {
         }
     }
 
-    pub fn items<'a>(&'a self) -> Enumerate<vec::VecIterator<'a, Option<DefId>>> {
-        self.items.iter().enumerate()
+    pub fn each_item(&self, f: &fn(Option<DefId>, uint) -> bool) -> bool {
+        self.items.iter().enumerate().advance(|(i, &item)| f(item, i))
     }
 
     pub fn item_name(index: uint) -> &'static str {
@@ -300,7 +298,7 @@ struct LanguageItemCollector<'self> {
     crate: &'self Crate,
     session: Session,
 
-    item_refs: HashMap<&'static str, uint>,
+    item_refs: HashMap<@str, uint>,
 }
 
 struct LanguageItemVisitor<'self> {
@@ -329,51 +327,51 @@ impl<'self> LanguageItemCollector<'self> {
                    -> LanguageItemCollector<'a> {
         let mut item_refs = HashMap::new();
 
-        item_refs.insert("freeze", FreezeTraitLangItem as uint);
-        item_refs.insert("send", SendTraitLangItem as uint);
-        item_refs.insert("sized", SizedTraitLangItem as uint);
-
-        item_refs.insert("drop", DropTraitLangItem as uint);
-
-        item_refs.insert("add", AddTraitLangItem as uint);
-        item_refs.insert("sub", SubTraitLangItem as uint);
-        item_refs.insert("mul", MulTraitLangItem as uint);
-        item_refs.insert("div", DivTraitLangItem as uint);
-        item_refs.insert("rem", RemTraitLangItem as uint);
-        item_refs.insert("neg", NegTraitLangItem as uint);
-        item_refs.insert("not", NotTraitLangItem as uint);
-        item_refs.insert("bitxor", BitXorTraitLangItem as uint);
-        item_refs.insert("bitand", BitAndTraitLangItem as uint);
-        item_refs.insert("bitor", BitOrTraitLangItem as uint);
-        item_refs.insert("shl", ShlTraitLangItem as uint);
-        item_refs.insert("shr", ShrTraitLangItem as uint);
-        item_refs.insert("index", IndexTraitLangItem as uint);
-
-        item_refs.insert("eq", EqTraitLangItem as uint);
-        item_refs.insert("ord", OrdTraitLangItem as uint);
-
-        item_refs.insert("str_eq", StrEqFnLangItem as uint);
-        item_refs.insert("uniq_str_eq", UniqStrEqFnLangItem as uint);
-        item_refs.insert("fail_", FailFnLangItem as uint);
-        item_refs.insert("fail_bounds_check",
+        item_refs.insert(@"freeze", FreezeTraitLangItem as uint);
+        item_refs.insert(@"send", SendTraitLangItem as uint);
+        item_refs.insert(@"sized", SizedTraitLangItem as uint);
+
+        item_refs.insert(@"drop", DropTraitLangItem as uint);
+
+        item_refs.insert(@"add", AddTraitLangItem as uint);
+        item_refs.insert(@"sub", SubTraitLangItem as uint);
+        item_refs.insert(@"mul", MulTraitLangItem as uint);
+        item_refs.insert(@"div", DivTraitLangItem as uint);
+        item_refs.insert(@"rem", RemTraitLangItem as uint);
+        item_refs.insert(@"neg", NegTraitLangItem as uint);
+        item_refs.insert(@"not", NotTraitLangItem as uint);
+        item_refs.insert(@"bitxor", BitXorTraitLangItem as uint);
+        item_refs.insert(@"bitand", BitAndTraitLangItem as uint);
+        item_refs.insert(@"bitor", BitOrTraitLangItem as uint);
+        item_refs.insert(@"shl", ShlTraitLangItem as uint);
+        item_refs.insert(@"shr", ShrTraitLangItem as uint);
+        item_refs.insert(@"index", IndexTraitLangItem as uint);
+
+        item_refs.insert(@"eq", EqTraitLangItem as uint);
+        item_refs.insert(@"ord", OrdTraitLangItem as uint);
+
+        item_refs.insert(@"str_eq", StrEqFnLangItem as uint);
+        item_refs.insert(@"uniq_str_eq", UniqStrEqFnLangItem as uint);
+        item_refs.insert(@"fail_", FailFnLangItem as uint);
+        item_refs.insert(@"fail_bounds_check",
                          FailBoundsCheckFnLangItem as uint);
-        item_refs.insert("exchange_malloc", ExchangeMallocFnLangItem as uint);
-        item_refs.insert("closure_exchange_malloc", ClosureExchangeMallocFnLangItem as uint);
-        item_refs.insert("exchange_free", ExchangeFreeFnLangItem as uint);
-        item_refs.insert("malloc", MallocFnLangItem as uint);
-        item_refs.insert("free", FreeFnLangItem as uint);
-        item_refs.insert("borrow_as_imm", BorrowAsImmFnLangItem as uint);
-        item_refs.insert("borrow_as_mut", BorrowAsMutFnLangItem as uint);
-        item_refs.insert("return_to_mut", ReturnToMutFnLangItem as uint);
-        item_refs.insert("check_not_borrowed",
+        item_refs.insert(@"exchange_malloc", ExchangeMallocFnLangItem as uint);
+        item_refs.insert(@"closure_exchange_malloc", ClosureExchangeMallocFnLangItem as uint);
+        item_refs.insert(@"exchange_free", ExchangeFreeFnLangItem as uint);
+        item_refs.insert(@"malloc", MallocFnLangItem as uint);
+        item_refs.insert(@"free", FreeFnLangItem as uint);
+        item_refs.insert(@"borrow_as_imm", BorrowAsImmFnLangItem as uint);
+        item_refs.insert(@"borrow_as_mut", BorrowAsMutFnLangItem as uint);
+        item_refs.insert(@"return_to_mut", ReturnToMutFnLangItem as uint);
+        item_refs.insert(@"check_not_borrowed",
                          CheckNotBorrowedFnLangItem as uint);
-        item_refs.insert("strdup_uniq", StrDupUniqFnLangItem as uint);
-        item_refs.insert("record_borrow", RecordBorrowFnLangItem as uint);
-        item_refs.insert("unrecord_borrow", UnrecordBorrowFnLangItem as uint);
-        item_refs.insert("start", StartFnLangItem as uint);
-        item_refs.insert("ty_desc", TyDescStructLangItem as uint);
-        item_refs.insert("ty_visitor", TyVisitorTraitLangItem as uint);
-        item_refs.insert("opaque", OpaqueStructLangItem as uint);
+        item_refs.insert(@"strdup_uniq", StrDupUniqFnLangItem as uint);
+        item_refs.insert(@"record_borrow", RecordBorrowFnLangItem as uint);
+        item_refs.insert(@"unrecord_borrow", UnrecordBorrowFnLangItem as uint);
+        item_refs.insert(@"start", StartFnLangItem as uint);
+        item_refs.insert(@"ty_desc", TyDescStructLangItem as uint);
+        item_refs.insert(@"ty_visitor", TyVisitorTraitLangItem as uint);
+        item_refs.insert(@"opaque", OpaqueStructLangItem as uint);
 
         LanguageItemCollector {
             crate: crate,
@@ -418,8 +416,8 @@ impl<'self> LanguageItemCollector<'self> {
             return;    // Didn't match.
         }
 
-        let item_index = self.item_refs.find_equiv(&value).map_move(|x| *x);
-        // prevent borrow checker from considering         ^~~~~~~~~~~
+        let item_index = self.item_refs.find(&value).map_move(|x| *x);
+        // prevent borrow checker from considering   ^~~~~~~~~~~
         // self to be borrowed (annoying)
 
         match item_index {

branches/snap-stage3/src/libstd/fmt/mod.rs

@@ -40,7 +40,7 @@ format!("The number is {:d}", 1)  // => ~"The number is 1"
 format!("{:?}", ~[3, 4])          // => ~"~[3, 4]"
 format!("{value}", value=4)       // => ~"4"
 format!("{} {}", 1, 2)            // => ~"1 2"
-```
+ ```
 
 From these, you can see that the first argument is a format string. It is
 required by the compiler for this to be a string literal; it cannot be a
@@ -56,21 +56,6 @@ example, the format string `{} {} {}` would take three parameters, and they
 would be formatted in the same order as they're given. The format string
 `{2} {1} {0}`, however, would format arguments in reverse order.
 
-Things can get a little tricky once you start intermingling the two types of
-positional specifiers. The "next argument" specifier can be thought of as an
-iterator over the argument. Each time a "next argument" specifier is seen, the
-iterator advances. This leads to behavior like this:
-
-```rust
-format!("{1} {} {0} {}", 1, 2) // => ~"2 1 1 2"
-```
-
-The internal iterator over the argument has not been advanced by the time the
-first `{}` is seen, so it prints the first argument. Then upon reaching the
-second `{}`, the iterator has advanced forward to the second argument.
-Essentially, parameters which explicitly name their argument do not affect
-parameters which do not name an argument in terms of positional specifiers.
-
 A format string is required to use all of its arguments, otherwise it is a
 compile-time error. You may refer to the same argument more than once in the
 format string, although it must always be referred to with the same type.
@@ -82,17 +67,9 @@ function, but the `format!` macro is a syntax extension which allows it to
 leverage named parameters. Named parameters are listed at the end of the
 argument list and have the syntax:
 
-```
+ ```
 identifier '=' expression
-```
-
-For example, the following `format!` expressions all use named argument:
-
-```rust
-format!("{argument}", argument = "test")       // => ~"test"
-format!("{name} {}", 1, name = 2)              // => ~"2 1"
-format!("{a:s} {c:d} {b:?}", a="a", b=(), c=3) // => ~"a 3 ()"
-```
+ ```
 
 It is illegal to put positional parameters (those without names) after arguments
 which have names. Like positional parameters, it is illegal to provided named
@@ -107,9 +84,9 @@ and if all references to one argument do not provide a type, then the format `?`
 is used (the type's rust-representation is printed). For example, this is an
 invalid format string:
 
-```
+ ```
 {0:d} {0:s}
-```
+ ```
 
 Because the first argument is both referred to as an integer as well as a
 string.
@@ -123,9 +100,9 @@ must have the type `uint`. Although a `uint` can be printed with `{:u}`, it is
 illegal to reference an argument as such. For example, this is another invalid
 format string:
 
-```
+ ```
 {:.*s} {0:u}
-```
+ ```
 
 ### Formatting traits
 
@@ -159,7 +136,7 @@ method of the signature:
 
 ```rust
 fn fmt(value: &T, f: &mut std::fmt::Formatter);
-```
+ ```
 
 Your type will be passed by-reference in `value`, and then the function should
 emit output into the `f.buf` stream. It is up to each format trait
@@ -180,7 +157,7 @@ writeln!     // same as write but appends a newline
 print!       // the format string is printed to the standard output
 println!     // same as print but appends a newline
 format_args! // described below.
-```
+ ```
 
 
 #### `write!`
@@ -195,7 +172,7 @@ use std::rt::io;
 
 let mut w = io::mem::MemWriter::new();
 write!(&mut w as &mut io::Writer, "Hello {}!", "world");
-```
+ ```
 
 #### `print!`
 
@@ -206,7 +183,7 @@ output. Example usage is:
 ```rust
 print!("Hello {}!", "world");
 println!("I have a newline {}", "character at the end");
-```
+ ```
 
 #### `format_args!`
 This is a curious macro which is used to safely pass around
@@ -222,7 +199,7 @@ use std::fmt;
 format_args!(fmt::format, "this returns {}", "~str");
 format_args!(|args| { fmt::write(my_writer, args) }, "some {}", "args");
 format_args!(my_fn, "format {}", "string");
-```
+ ```
 
 The first argument of the `format_args!` macro is a function (or closure) which
 takes one argument of type `&fmt::Arguments`. This structure can then be
@@ -261,7 +238,7 @@ example:
 
 ```rust
 format!("{0, select, other{#}}", "hello") // => ~"hello"
-```
+ ```
 
 This example is the equivalent of `{0:s}` essentially.
 
@@ -270,9 +247,9 @@ This example is the equivalent of `{0:s}` essentially.
 The select method is a switch over a `&str` parameter, and the parameter *must*
 be of the type `&str`. An example of the syntax is:
 
-```
+ ```
 {0, select, male{...} female{...} other{...}}
-```
+ ```
 
 Breaking this down, the `0`-th argument is selected upon with the `select`
 method, and then a number of cases follow. Each case is preceded by an
@@ -289,9 +266,9 @@ The plural method is a switch statement over a `uint` parameter, and the
 parameter *must* be a `uint`. A plural method in its full glory can be specified
 as:
 
-```
+ ```
 {0, plural, offset=1 =1{...} two{...} many{...} other{...}}
-```
+ ```
 
 To break this down, the first `0` indicates that this method is selecting over
 the value of the first positional parameter to the format string. Next, the
@@ -317,7 +294,7 @@ should not be too alien. Arguments are formatted with python-like syntax,
 meaning that arguments are surrounded by `{}` instead of the C-like `%`. The
 actual grammar for the formatting syntax is:
 
-```
+ ```
 format_string := <text> [ format <text> ] *
 format := '{' [ argument ] [ ':' format_spec ] [ ',' function_spec ] '}'
 argument := integer | identifier
@@ -338,7 +315,7 @@ plural := 'plural' ',' [ 'offset:' integer ] ( selector arm ) *
 selector := '=' integer | keyword
 keyword := 'zero' | 'one' | 'two' | 'few' | 'many' | 'other'
 arm := '{' format_string '}'
-```
+ ```
 
 ## Formatting Parameters