rustc: Purge of HashMap, fixing segfaulting cases

alexcrichton · alexcrichton · commit 17459d0bd355 · 2013-03-26T19:21:04.000-04:00
Various FIXME comments added around to denote copies which when removed cause
the compiler to segfault at some point before stage2. None of these copies
should even be necessary.
diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs
@@ -61,7 +61,7 @@ pub fn enc_ty(w: @io::Writer, cx: @ctxt, t: ty::t) {
     match cx.abbrevs {
       ac_no_abbrevs => {
         let result_str = match cx.tcx.short_names_cache.find(&t) {
-            Some(s) => /*bad*/copy *s,
+            Some(&s) => /*bad*/copy *s,
             None => {
                 let s = do io::with_str_writer |wr| {
                     enc_sty(wr, cx, /*bad*/copy ty::get(t).sty);
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
@@ -856,7 +856,9 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext,
         do ebml_w.tag(c::tag_table_node_type_subst) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                ebml_w.emit_tys(ecx, /*bad*/copy *tys)
+                // FIXME(#5562): removing this copy causes a segfault
+                //               before stage2
+                ebml_w.emit_tys(ecx, /*bad*/copy **tys)
             }
         }
     }
@@ -922,7 +924,7 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext,
         }
     }
 
-    for maps.method_map.find(&id).each |mme| {
+    for maps.method_map.find(&id).each |&mme| {
         do ebml_w.tag(c::tag_table_method_map) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
@@ -17,7 +17,6 @@ use middle;
 
 use core::float;
 use core::vec;
-use std::oldmap::HashMap;
 use syntax::{ast, ast_map, ast_util, visit};
 use syntax::ast::*;
 
@@ -194,7 +193,7 @@ pub fn lookup_const_by_id(tcx: ty::ctxt,
             mutbl_map: @mut LinearSet::new(),
             root_map: @mut LinearMap::new(),
             last_use_map: @mut LinearMap::new(),
-            method_map: HashMap(),
+            method_map: @mut LinearMap::new(),
             vtable_map: @mut LinearMap::new(),
             write_guard_map: @mut LinearSet::new(),
             moves_map: @mut LinearSet::new(),
diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs
@@ -274,6 +274,8 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt<Context>) {
         _ => e.id
     };
     for cx.tcx.node_type_substs.find(&type_parameter_id).each |ts| {
+        // FIXME(#5562): removing this copy causes a segfault before stage2
+        let ts = /*bad*/ copy **ts;
         let bounds = match e.node {
           expr_path(_) => {
             let did = ast_util::def_id_of_def(*cx.tcx.def_map.get(&e.id));
@@ -289,15 +291,15 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt<Context>) {
                 ~"non path/method call expr has type substs??")
           }
         };
-        if vec::len(*ts) != vec::len(*bounds) {
+        if ts.len() != bounds.len() {
             // Fail earlier to make debugging easier
             fail!(fmt!("internal error: in kind::check_expr, length \
                        mismatch between actual and declared bounds: actual = \
                         %s (%u tys), declared = %? (%u tys)",
-                      tys_to_str(cx.tcx, *ts), ts.len(),
-                      *bounds, (*bounds).len()));
+                      tys_to_str(cx.tcx, ts), ts.len(),
+                      *bounds, bounds.len()));
         }
-        for vec::each2(*ts, *bounds) |ty, bound| {
+        for vec::each2(ts, *bounds) |ty, bound| {
             check_bounds(cx, type_parameter_id, e.span, *ty, *bound)
         }
     }
@@ -335,9 +337,11 @@ fn check_ty(aty: @Ty, cx: Context, v: visit::vt<Context>) {
     match aty.node {
       ty_path(_, id) => {
         for cx.tcx.node_type_substs.find(&id).each |ts| {
+            // FIXME(#5562): removing this copy causes a segfault before stage2
+            let ts = /*bad*/ copy **ts;
             let did = ast_util::def_id_of_def(*cx.tcx.def_map.get(&id));
             let bounds = ty::lookup_item_type(cx.tcx, did).bounds;
-            for vec::each2(*ts, *bounds) |ty, bound| {
+            for vec::each2(ts, *bounds) |ty, bound| {
                 check_bounds(cx, aty.id, aty.span, *ty, *bound)
             }
         }
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
@@ -72,8 +72,7 @@ use core::int;
 use core::io;
 use core::libc::{c_uint, c_ulonglong};
 use core::uint;
-use std::oldmap::HashMap;
-use std::{oldmap, time, list};
+use std::{time, list};
 use syntax::ast::ident;
 use syntax::ast_map::{path, path_elt_to_str, path_mod, path_name};
 use syntax::ast_util::{def_id_of_def, local_def, path_to_ident};
@@ -170,16 +169,22 @@ pub fn get_extern_fn(externs: ExternMap,
                      name: @str,
                      cc: lib::llvm::CallConv,
                      ty: TypeRef) -> ValueRef {
-    if externs.contains_key(&name) { return externs.get(&name); }
+    match externs.find(&name) {
+        Some(n) => return copy *n,
+        None => ()
+    }
     let f = decl_fn(llmod, name, cc, ty);
     externs.insert(name, f);
     return f;
 }
 
 pub fn get_extern_const(externs: ExternMap, llmod: ModuleRef,
                         name: @str, ty: TypeRef) -> ValueRef {
+    match externs.find(&name) {
+        Some(n) => return copy *n,
+        None => ()
+    }
     unsafe {
-        if externs.contains_key(&name) { return externs.get(&name); }
         let c = str::as_c_str(name, |buf| {
             llvm::LLVMAddGlobal(llmod, ty, buf)
         });
@@ -3061,7 +3066,7 @@ pub fn trans_crate(sess: session::Session,
               llmod: llmod,
               td: td,
               tn: tn,
-              externs: HashMap(),
+              externs: @mut LinearMap::new(),
               intrinsics: intrinsics,
               item_vals: @mut LinearMap::new(),
               exp_map2: emap2,
@@ -3082,8 +3087,8 @@ pub fn trans_crate(sess: session::Session,
               const_globals: @mut LinearMap::new(),
               const_values: @mut LinearMap::new(),
               module_data: @mut LinearMap::new(),
-              lltypes: ty::new_ty_hash(),
-              llsizingtypes: ty::new_ty_hash(),
+              lltypes: @mut LinearMap::new(),
+              llsizingtypes: @mut LinearMap::new(),
               adt_reprs: @mut LinearMap::new(),
               names: new_namegen(sess.parse_sess.interner),
               next_addrspace: new_addrspace_gen(),
diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs
@@ -82,9 +82,12 @@ pub fn trans(bcx: block, expr: @ast::expr) -> Callee {
         }
         ast::expr_field(base, _, _) => {
             match bcx.ccx().maps.method_map.find(&expr.id) {
-                Some(ref origin) => { // An impl method
+                Some(origin) => { // An impl method
+                    // FIXME(#5562): removing this copy causes a segfault
+                    //               before stage2
+                    let origin = /*bad*/ copy *origin;
                     return meth::trans_method_callee(bcx, expr.id,
-                                                     base, (*origin));
+                                                     base, origin);
                 }
                 None => {} // not a method, just a field
             }
@@ -343,11 +346,14 @@ pub fn trans_method_call(in_cx: block,
         expr_ty(in_cx, call_ex),
         |cx| {
             match cx.ccx().maps.method_map.find(&call_ex.id) {
-                Some(ref origin) => {
+                Some(origin) => {
+                    // FIXME(#5562): removing this copy causes a segfault
+                    //               before stage2
+                    let origin = /*bad*/ copy *origin;
                     meth::trans_method_callee(cx,
                                               call_ex.callee_id,
                                               rcvr,
-                                              (*origin))
+                                              origin)
                 }
                 None => {
                     cx.tcx().sess.span_bug(call_ex.span,
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
@@ -52,7 +52,6 @@ use core::str;
 use core::to_bytes;
 use core::vec::raw::to_ptr;
 use core::vec;
-use std::oldmap::{HashMap, Set};
 use syntax::ast::ident;
 use syntax::ast_map::{path, path_elt};
 use syntax::codemap::span;
@@ -156,7 +155,7 @@ pub fn BuilderRef_res(B: BuilderRef) -> BuilderRef_res {
     }
 }
 
-pub type ExternMap = HashMap<@str, ValueRef>;
+pub type ExternMap = @mut LinearMap<@str, ValueRef>;
 
 // Crate context.  Every crate we compile has one of these.
 pub struct CrateContext {
@@ -203,8 +202,8 @@ pub struct CrateContext {
      // Cache of emitted const values
      const_values: @mut LinearMap<ast::node_id, ValueRef>,
      module_data: @mut LinearMap<~str, ValueRef>,
-     lltypes: HashMap<ty::t, TypeRef>,
-     llsizingtypes: HashMap<ty::t, TypeRef>,
+     lltypes: @mut LinearMap<ty::t, TypeRef>,
+     llsizingtypes: @mut LinearMap<ty::t, TypeRef>,
      adt_reprs: @mut LinearMap<ty::t, @adt::Repr>,
      names: namegen,
      next_addrspace: addrspace_gen,
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
@@ -1647,7 +1647,7 @@ fn trans_overloaded_op(bcx: block,
                        dest: Dest,
                        +autoref_arg: AutorefArg) -> block
 {
-    let origin = bcx.ccx().maps.method_map.get(&expr.id);
+    let origin = *bcx.ccx().maps.method_map.get(&expr.id);
     let fty = node_id_type(bcx, expr.callee_id);
     return callee::trans_call_inner(
         bcx, expr.info(), fty,
diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs
@@ -402,7 +402,7 @@ pub fn make_visit_glue(bcx: block, v: ValueRef, t: ty::t) {
     let mut bcx = bcx;
     let ty_visitor_name = special_idents::ty_visitor;
     fail_unless!(bcx.ccx().tcx.intrinsic_defs.contains_key(&ty_visitor_name));
-    let (trait_id, ty) = bcx.ccx().tcx.intrinsic_defs.get(&ty_visitor_name);
+    let (trait_id, ty) = *bcx.ccx().tcx.intrinsic_defs.get(&ty_visitor_name);
     let v = PointerCast(bcx, v, T_ptr(type_of::type_of(bcx.ccx(), ty)));
     bcx = reflect::emit_calls_to_trait_visit_ty(bcx, t, v, trait_id);
     build_return(bcx);
diff --git a/src/librustc/middle/trans/reachable.rs b/src/librustc/middle/trans/reachable.rs
@@ -193,7 +193,7 @@ fn traverse_inline_body(cx: ctx, body: &blk) {
           }
           expr_field(_, _, _) => {
             match cx.method_map.find(&e.id) {
-              Some(typeck::method_map_entry {
+              Some(&typeck::method_map_entry {
                   origin: typeck::method_static(did),
                   _
                 }) => {
@@ -204,7 +204,7 @@ fn traverse_inline_body(cx: ctx, body: &blk) {
           }
           expr_method_call(*) => {
             match cx.method_map.find(&e.id) {
-              Some(typeck::method_map_entry {
+              Some(&typeck::method_map_entry {
                   origin: typeck::method_static(did),
                   _
                 }) => {
diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
@@ -337,7 +337,7 @@ pub fn emit_calls_to_trait_visit_ty(bcx: block,
     use syntax::parse::token::special_idents::tydesc;
     let final = sub_block(bcx, ~"final");
     fail_unless!(bcx.ccx().tcx.intrinsic_defs.contains_key(&tydesc));
-    let (_, tydesc_ty) = bcx.ccx().tcx.intrinsic_defs.get(&tydesc);
+    let (_, tydesc_ty) = *bcx.ccx().tcx.intrinsic_defs.get(&tydesc);
     let tydesc_ty = type_of(bcx.ccx(), tydesc_ty);
     let mut r = Reflector {
         visitor_val: visitor_val,
diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs
@@ -101,8 +101,10 @@ pub fn type_of_non_gc_box(cx: @CrateContext, t: ty::t) -> TypeRef {
 //     behavior.
 
 pub fn sizing_type_of(cx: @CrateContext, t: ty::t) -> TypeRef {
-    if cx.llsizingtypes.contains_key(&t) {
-        return cx.llsizingtypes.get(&t);
+    match cx.llsizingtypes.find(&t) {
+        // FIXME(#5562): removing this copy causes a segfault in stage1 core
+        Some(t) => return /*bad*/ copy *t,
+        None => ()
     }
 
     let llsizingty = match ty::get(t).sty {
@@ -161,7 +163,11 @@ pub fn type_of(cx: @CrateContext, t: ty::t) -> TypeRef {
     debug!("type_of %?: %?", t, ty::get(t));
 
     // Check the cache.
-    if cx.lltypes.contains_key(&t) { return cx.lltypes.get(&t); }
+    match cx.lltypes.find(&t) {
+        // FIXME(#5562): removing this copy causes a segfault in stage1 core
+        Some(t) => return /*bad*/ copy *t,
+        None => ()
+    }
 
     // Replace any typedef'd types with their equivalent non-typedef
     // type. This ensures that all LLVM nominal types that contain
diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs
@@ -250,8 +250,11 @@ pub fn mark_for_method_call(cx: Context, e_id: node_id, callee_id: node_id) {
         match mth.origin {
           typeck::method_static(did) => {
             for cx.ccx.tcx.node_type_substs.find(&callee_id).each |ts| {
+                // FIXME(#5562): removing this copy causes a segfault
+                //               before stage2
+                let ts = /*bad*/ copy **ts;
                 let type_uses = type_uses_for(cx.ccx, did, ts.len());
-                for vec::each2(type_uses, *ts) |uses, subst| {
+                for vec::each2(type_uses, ts) |uses, subst| {
                     type_needs(cx, *uses, *subst)
                 }
             }
@@ -296,9 +299,11 @@ pub fn mark_for_expr(cx: Context, e: @expr) {
       }
       expr_path(_) => {
         for cx.ccx.tcx.node_type_substs.find(&e.id).each |ts| {
+            // FIXME(#5562): removing this copy causes a segfault before stage2
+            let ts = copy **ts;
             let id = ast_util::def_id_of_def(*cx.ccx.tcx.def_map.get(&e.id));
             let uses_for_ts = type_uses_for(cx.ccx, id, ts.len());
-            for vec::each2(uses_for_ts, *ts) |uses, subst| {
+            for vec::each2(uses_for_ts, ts) |uses, subst| {
                 type_needs(cx, *uses, *subst)
             }
         }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs
diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -856,7 +856,9 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext,`
`856`	`856`	`do ebml_w.tag(c::tag_table_node_type_subst) {`
`857`	`857`	`ebml_w.id(id);`
`858`	`858`	`do ebml_w.tag(c::tag_table_val) {`
`859`		`- ebml_w.emit_tys(ecx, /bad/copy *tys)`
	`859`	`+ // FIXME(#5562): removing this copy causes a segfault`
	`860`	`+ // before stage2`
	`861`	`+ ebml_w.emit_tys(ecx, /bad/copy **tys)`
`860`	`862`	`}`
`861`	`863`	`}`
`862`	`864`	`}`
`@@ -922,7 +924,7 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext,`
`922`	`924`	`}`
`923`	`925`	`}`
`924`	`926`
`925`		`- for maps.method_map.find(&id).each \|mme\| {`
	`927`	`+ for maps.method_map.find(&id).each \|&mme\| {`
`926`	`928`	`do ebml_w.tag(c::tag_table_method_map) {`
`927`	`929`	`ebml_w.id(id);`
`928`	`930`	`do ebml_w.tag(c::tag_table_val) {`
Original file line number	Diff line number	Diff line change
`@@ -1647,7 +1647,7 @@ fn trans_overloaded_op(bcx: block,`
`1647`	`1647`	`dest: Dest,`
`1648`	`1648`	`+autoref_arg: AutorefArg) -> block`
`1649`	`1649`	`{`
`1650`		`- let origin = bcx.ccx().maps.method_map.get(&expr.id);`
	`1650`	`+ let origin = *bcx.ccx().maps.method_map.get(&expr.id);`
`1651`	`1651`	`let fty = node_id_type(bcx, expr.callee_id);`
`1652`	`1652`	`return callee::trans_call_inner(`
`1653`	`1653`	`bcx, expr.info(), fty,`
Original file line number	Diff line number	Diff line change
`@@ -193,7 +193,7 @@ fn traverse_inline_body(cx: ctx, body: &blk) {`
`193`	`193`	`}`
`194`	`194`	`expr_field(_, _, _) => {`
`195`	`195`	`match cx.method_map.find(&e.id) {`
`196`		`- Some(typeck::method_map_entry {`
	`196`	`+ Some(&typeck::method_map_entry {`
`197`	`197`	`origin: typeck::method_static(did),`
`198`	`198`	`_`
`199`	`199`	`}) => {`
`@@ -204,7 +204,7 @@ fn traverse_inline_body(cx: ctx, body: &blk) {`
`204`	`204`	`}`
`205`	`205`	`expr_method_call(*) => {`
`206`	`206`	`match cx.method_map.find(&e.id) {`
`207`		`- Some(typeck::method_map_entry {`
	`207`	`+ Some(&typeck::method_map_entry {`
`208`	`208`	`origin: typeck::method_static(did),`
`209`	`209`	`_`
`210`	`210`	`}) => {`