---

yaml
---
r: 42387
b: refs/heads/master
c: 8c32cd2
h: refs/heads/master
i:
  42385: 5c23076
  42383: e1bff77
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e8fc4b347d3526d1adb21a5ff184c032fa2982c1
+refs/heads/master: 8c32cd2dc8de2dcadb020a51aa5254098f851ea1
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/src/libcargo/cargo.rc

@@ -495,7 +495,7 @@ pub fn try_parse_sources(filename: &Path,
     let c = io::read_whole_file_str(filename);
     match json::from_str(c.get()) {
         Ok(json::Object(j)) => {
-            for j.each |k, v| {
+            for j.each |&(k, v)| {
                 sources.insert(copy *k, parse_source(*k, v));
                 debug!("source: %s", *k);
             }

trunk/src/libcore/container.rs

@@ -29,9 +29,6 @@ pub trait Map<K, V>: Mutable {
     /// Return true if the map contains a value for the specified key
     pure fn contains_key(&self, key: &K) -> bool;
 
-    /// Visit all key-value pairs
-    pure fn each(&self, f: fn(&K, &V) -> bool);
-
     /// Visit all keys
     pure fn each_key(&self, f: fn(&K) -> bool);
 

trunk/src/libcore/hashmap.rs

@@ -235,6 +235,23 @@ pub mod linear {
         }
     }
 
+    impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: BaseIter<(&K, &V)> {
+        /// Visit all key-value pairs
+        pure fn each(&self, blk: fn(&(&self/K, &self/V)) -> bool) {
+            for uint::range(0, self.buckets.len()) |i| {
+                let mut broke = false;
+                do self.buckets[i].map |bucket| {
+                    if !blk(&(&bucket.key, &bucket.value)) {
+                        broke = true; // FIXME(#3064) just write "break;"
+                    }
+                };
+                if broke { break; }
+            }
+        }
+        pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
+    }
+
+
     impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: Container {
         /// Return the number of elements in the map
         pure fn len(&self) -> uint { self.size }
@@ -262,27 +279,14 @@ pub mod linear {
             }
         }
 
-        /// Visit all key-value pairs
-        pure fn each(&self, blk: fn(k: &K, v: &V) -> bool) {
-            for self.buckets.each |slot| {
-                let mut broke = false;
-                do slot.iter |bucket| {
-                    if !blk(&bucket.key, &bucket.value) {
-                        broke = true; // FIXME(#3064) just write "break;"
-                    }
-                }
-                if broke { break; }
-            }
-        }
-
         /// Visit all keys
         pure fn each_key(&self, blk: fn(k: &K) -> bool) {
-            self.each(|k, _| blk(k))
+            self.each(|&(k, _)| blk(k))
         }
 
         /// Visit all values
         pure fn each_value(&self, blk: fn(v: &V) -> bool) {
-            self.each(|_, v| blk(v))
+            self.each(|&(_, v)| blk(v))
         }
 
         /// Return the value corresponding to the key in the map
@@ -388,7 +392,7 @@ pub mod linear {
         pure fn eq(&self, other: &LinearMap<K, V>) -> bool {
             if self.len() != other.len() { return false; }
 
-            for self.each |key, value| {
+            for self.each |&(key, value)| {
                 match other.find(key) {
                     None => return false,
                     Some(v) => if value != v { return false },
@@ -603,7 +607,7 @@ mod test_map {
             assert m.insert(i, i*2);
         }
         let mut observed = 0;
-        for m.each |k, v| {
+        for m.each |&(k, v)| {
             assert *v == *k * 2;
             observed |= (1 << *k);
         }

trunk/src/libcore/iter.rs

@@ -27,6 +27,10 @@ pub trait BaseIter<A> {
     pure fn size_hint(&self) -> Option<uint>;
 }
 
+pub trait ReverseIter<A>: BaseIter<A> {
+    pure fn each_reverse(&self, blk: fn(&A) -> bool);
+}
+
 pub trait ExtendedIter<A> {
     pure fn eachi(&self, blk: fn(uint, v: &A) -> bool);
     pure fn all(&self, blk: fn(&A) -> bool) -> bool;

trunk/src/libcore/option.rs

@@ -102,7 +102,7 @@ pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
 }
 
 #[inline(always)]
-pub pure fn map<T, U>(opt: &Option<T>, f: fn(x: &T) -> U) -> Option<U> {
+pub pure fn map<T, U>(opt: &r/Option<T>, f: fn(x: &r/T) -> U) -> Option<U> {
     //! Maps a `some` value by reference from one type to another
 
     match *opt { Some(ref x) => Some(f(x)), None => None }
@@ -193,8 +193,8 @@ pub pure fn get_or_default<T: Copy>(opt: Option<T>, def: T) -> T {
 }
 
 #[inline(always)]
-pub pure fn map_default<T, U>(opt: &Option<T>, def: U,
-                              f: fn(x: &T) -> U) -> U {
+pub pure fn map_default<T, U>(opt: &r/Option<T>, def: U,
+                              f: fn(&r/T) -> U) -> U {
     //! Applies a function to the contained value or returns a default
 
     match *opt { None => move def, Some(ref t) => f(t) }
@@ -273,7 +273,7 @@ impl<T> Option<T> {
 
     /// Maps a `some` value from one type to another by reference
     #[inline(always)]
-    pure fn map<U>(&self, f: fn(x: &T) -> U) -> Option<U> { map(self, f) }
+    pure fn map<U>(&self, f: fn(&self/T) -> U) -> Option<U> { map(self, f) }
 
     /// As `map`, but consumes the option and gives `f` ownership to avoid
     /// copying.
@@ -284,7 +284,7 @@ impl<T> Option<T> {
 
     /// Applies a function to the contained value or returns a default
     #[inline(always)]
-    pure fn map_default<U>(&self, def: U, f: fn(x: &T) -> U) -> U {
+    pure fn map_default<U>(&self, def: U, f: fn(&self/T) -> U) -> U {
         map_default(self, move def, f)
     }
 

trunk/src/librustc/driver/driver.rs

@@ -521,6 +521,9 @@ pub fn build_session_options(+binary: ~str,
     } else {
         session::unknown_crate
     };
+    let static = opt_present(matches, ~"static");
+    let gc = opt_present(matches, ~"gc");
+
     let parse_only = opt_present(matches, ~"parse-only");
     let no_trans = opt_present(matches, ~"no-trans");
 
@@ -567,6 +570,7 @@ pub fn build_session_options(+binary: ~str,
         }
     }
 
+    let jit = opt_present(matches, ~"jit");
     let output_type =
         if parse_only || no_trans {
             link::output_type_none
@@ -580,6 +584,8 @@ pub fn build_session_options(+binary: ~str,
         } else if opt_present(matches, ~"emit-llvm") {
             link::output_type_bitcode
         } else { link::output_type_exe };
+    let extra_debuginfo = opt_present(matches, ~"xg");
+    let debuginfo = opt_present(matches, ~"g") || extra_debuginfo;
     let sysroot_opt = getopts::opt_maybe_str(matches, ~"sysroot");
     let sysroot_opt = sysroot_opt.map(|m| Path(*m));
     let target_opt = getopts::opt_maybe_str(matches, ~"target");
@@ -610,12 +616,6 @@ pub fn build_session_options(+binary: ~str,
             }
         } else { No }
     };
-    let gc = debugging_opts & session::gc != 0;
-    let jit = debugging_opts & session::jit != 0;
-    let extra_debuginfo = debugging_opts & session::extra_debug_info != 0;
-    let debuginfo = debugging_opts & session::debug_info != 0 ||
-        extra_debuginfo;
-    let static = debugging_opts & session::static != 0;
     let target =
         match target_opt {
             None => host_triple(),
@@ -714,11 +714,14 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
                           environment", ~"SPEC"),
   optflag(~"",  ~"emit-llvm",
                         ~"Produce an LLVM bitcode file"),
+  optflag(~"g", ~"",    ~"Produce debug info (experimental)"),
+  optflag(~"",  ~"gc",  ~"Garbage collect shared data (experimental)"),
   optflag(~"h", ~"help",~"Display this message"),
   optmulti(~"L", ~"",   ~"Add a directory to the library search path",
                               ~"PATH"),
   optflag(~"",  ~"lib", ~"Compile a library crate"),
   optflag(~"",  ~"ls",  ~"List the symbols defined by a library crate"),
+  optflag(~"",  ~"jit", ~"Execute using JIT (experimental)"),
   optflag(~"", ~"no-trans",
                         ~"Run all passes except translation; no output"),
   optflag(~"O", ~"",    ~"Equivalent to --opt-level=2"),
@@ -738,9 +741,13 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
                           or identified (fully parenthesized,
                           AST nodes and blocks with IDs)", ~"TYPE"),
   optflag(~"S", ~"",    ~"Compile only; do not assemble or link"),
+  optflag(~"", ~"xg",   ~"Extra debugging info (experimental)"),
   optflag(~"", ~"save-temps",
                         ~"Write intermediate files (.bc, .opt.bc, .o)
                           in addition to normal output"),
+  optflag(~"", ~"static",
+                        ~"Use or produce static libraries or binaries
+                         (experimental)"),
   optopt(~"", ~"sysroot",
                         ~"Override the system root", ~"PATH"),
   optflag(~"", ~"test", ~"Build a test harness"),

trunk/src/librustc/driver/session.rs

@@ -75,11 +75,6 @@ pub const count_type_sizes: uint = 1 << 14;
 pub const meta_stats: uint = 1 << 15;
 pub const no_opt: uint = 1 << 16;
 pub const no_monomorphic_collapse: uint = 1 << 17;
-pub const gc: uint = 1 << 18;
-pub const jit: uint = 1 << 19;
-pub const debug_info: uint = 1 << 20;
-pub const extra_debug_info: uint = 1 << 21;
-pub const static: uint = 1 << 22;
 
 pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
     ~[(~"verbose", ~"in general, enable more debug printouts", verbose),
@@ -107,13 +102,6 @@ pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
      (~"no-opt", ~"do not optimize, even if -O is passed", no_opt),
      (~"no-monomorphic-collapse", ~"do not collapse template instantiations",
       no_monomorphic_collapse),
-     (~"gc", ~"Garbage collect shared data (experimental)", gc),
-     (~"jit", ~"Execute using JIT (experimental)", jit),
-     (~"extra-debug-info", ~"Extra debugging info (experimental)",
-      extra_debug_info),
-     (~"debug-info", ~"Produce debug info (experimental)", debug_info),
-     (~"static", ~"Use or produce static libraries or binaries " +
-      "(experimental)", static)
     ]
 }
 

trunk/src/librustc/lib/llvm.rs

@@ -382,7 +382,6 @@ pub extern mod llvm {
     pub unsafe fn LLVMGetUsedValue(U: UseRef) -> ValueRef;
 
     /* Operations on Users */
-    pub unsafe fn LLVMGetNumOperands(Val: ValueRef) -> c_int;
     pub unsafe fn LLVMGetOperand(Val: ValueRef, Index: c_uint) -> ValueRef;
     pub unsafe fn LLVMSetOperand(Val: ValueRef, Index: c_uint, Op: ValueRef);
 

trunk/src/librustc/middle/trans/consts.rs

@@ -73,15 +73,9 @@ pub fn const_vec(cx: @crate_ctxt, e: @ast::expr, es: &[@ast::expr])
         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 v = C_array(llunitty, es.map(|e| const_expr(cx, *e)));
         let unit_sz = machine::llsize_of(cx, llunitty);
         let sz = llvm::LLVMConstMul(C_uint(cx, es.len()), unit_sz);
-        let vs = es.map(|e| const_expr(cx, *e));
-        // If the vector contains enums, an LLVM array won't work.
-        let v = if vs.any(|vi| val_ty(*vi) != llunitty) {
-            C_struct(vs)
-        } else {
-            C_array(llunitty, vs)
-        };
         return (v, sz, llunitty);
     }
 }
@@ -285,17 +279,15 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
               // call. Despite that being "a const", it's not the kind of
               // const you can ask for the integer-value of, evidently. This
               // might be an LLVM bug, not sure. In any case, to work around
-              // this we obtain the initializer and count how many elements it
-              // has, ignoring the length we pulled out of the slice. (Note
-              // that the initializer might be a struct rather than an array,
-              // if enums are involved.) This only works because we picked out
-              // the original globalvar via const_deref and so can recover the
-              // array-size of the underlying array (or the element count of
-              // the underlying struct), and all this will hold together
-              // exactly as long as we _don't_ support const sub-slices (that
-              // is, slices that represent something other than a whole
-              // array).  At that point we'll have more and uglier work to do
-              // here, but for now this should work.
+              // this we drop down to the array-type level here and just ask
+              // how long the array-type itself is, ignoring the length we
+              // pulled out of the slice. This in turn only works because we
+              // picked out the original globalvar via const_deref and so can
+              // recover the array-size of the underlying array, and all this
+              // will hold together exactly as long as we _don't_ support
+              // const sub-slices (that is, slices that represent something
+              // other than a whole array).  At that point we'll have more and
+              // uglier work to do here, but for now this should work.
               //
               // In the future, what we should be doing here is the
               // moral equivalent of:
@@ -307,7 +299,7 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
               // not want to consider sizeof() a constant expression
               // we can get the value (as a number) out of.
 
-              let len = llvm::LLVMGetNumOperands(arr) as u64;
+              let len = llvm::LLVMGetArrayLength(val_ty(arr)) as u64;
               let len = match ty::get(bt).sty {
                   ty::ty_estr(*) => {assert len > 0; len - 1},
                   _ => len
@@ -354,8 +346,10 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
           }
           ast::expr_addr_of(ast::m_imm, sub) => {
             let cv = const_expr(cx, sub);
+            let subty = ty::expr_ty(cx.tcx, sub),
+            llty = type_of::type_of(cx, subty);
             let gv = do str::as_c_str("const") |name| {
-                llvm::LLVMAddGlobal(cx.llmod, val_ty(cv), name)
+                llvm::LLVMAddGlobal(cx.llmod, llty, name)
             };
             llvm::LLVMSetInitializer(gv, cv);
             llvm::LLVMSetGlobalConstant(gv, True);
@@ -383,7 +377,8 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
                       }
                   })
               };
-              C_struct([C_struct(cs)])
+              let llty = type_of::type_of(cx, ety);
+              C_named_struct(llty, [C_struct(cs)])
           }
           ast::expr_vec(es, ast::m_imm) => {
             let (v, _, _) = const_vec(cx, e, es);
@@ -439,13 +434,7 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
                     let lldiscrim = base::get_discrim_val(cx, e.span,
                                                           enum_did,
                                                           variant_did);
-                    // However, we still have to pad it out to the
-                    // size of the full enum; see the expr_call case,
-                    // below.
-                    let ety = ty::expr_ty(cx.tcx, e);
-                    let size = machine::static_size_of_enum(cx, ety);
-                    let padding = C_null(T_array(T_i8(), size));
-                    C_struct(~[lldiscrim, padding])
+                    C_struct(~[lldiscrim])
                 }
                 Some(ast::def_struct(_)) => {
                     let ety = ty::expr_ty(cx.tcx, e);
@@ -461,12 +450,14 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
           ast::expr_call(callee, args, _) => {
             match cx.tcx.def_map.find(&callee.id) {
                 Some(ast::def_struct(def_id)) => {
+                    let ety = ty::expr_ty(cx.tcx, e);
+                    let llty = type_of::type_of(cx, ety);
                     let llstructbody =
                         C_struct(args.map(|a| const_expr(cx, *a)));
                     if ty::ty_dtor(cx.tcx, def_id).is_present() {
-                        C_struct(~[ llstructbody, C_u8(0) ])
+                        C_named_struct(llty, ~[ llstructbody, C_u8(0) ])
                     } else {
-                        C_struct(~[ llstructbody ])
+                        C_named_struct(llty, ~[ llstructbody ])
                     }
                 }
             Some(ast::def_variant(tid, vid)) => {
@@ -479,20 +470,7 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
 
                 // FIXME (#1645): enum body alignment is generaly wrong.
                 if !degen {
-                    // Pad out the data to the size of its type_of;
-                    // this is necessary if the enum is contained
-                    // within an aggregate (tuple, struct, vector) so
-                    // that the next element is at the right offset.
-                    let actual_size =
-                        machine::llsize_of_real(cx, llvm::LLVMTypeOf(c_args));
-                    let padding =
-                        C_null(T_array(T_i8(), size - actual_size));
-                    // A packed_struct has an alignment of 1; thus,
-                    // wrapping one around c_args will misalign it the
-                    // same way we normally misalign enum bodies
-                    // without affecting its internal alignment or
-                    // changing the alignment of the enum.
-                    C_struct(~[discrim, C_packed_struct(~[c_args]), padding])
+                    C_packed_struct(~[discrim, c_args])
                 } else if size == 0 {
                     C_struct(~[discrim])
                 } else {