Reuse monomorphized functions more aggressively

Adds a trans::type_use pass that, given a function body, detects how
dependant that function is on properties of its type parameters.

Author: marijnh

src/rustc/middle/regionck.rs

@@ -24,7 +24,7 @@ type ctxt = {
 fn check_expr(expr: @ast::expr, cx: ctxt, visitor: visit::vt<ctxt>) {
     let t = ty::expr_ty(cx.tcx, expr);
     if ty::type_has_rptrs(t) {
-        ty::walk_ty(cx.tcx, t) { |t|
+        ty::walk_ty(t) { |t|
             alt ty::get(t).struct {
                 ty::ty_rptr(region, _) {
                     alt region {

src/rustc/middle/trans/base.rs

@@ -1784,22 +1784,98 @@ fn trans_external_path(ccx: @crate_ctxt, did: ast::def_id, t: ty::t)
     ret get_extern_const(ccx.externs, ccx.llmod, name, llty);
 }
 
-fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, substs: [ty::t],
+fn normalize_for_monomorphization(tcx: ty::ctxt, ty: ty::t) -> option<ty::t> {
+    // FIXME[mono] could do this recursively. is that worthwhile?
+    alt ty::get(ty).struct {
+      ty::ty_box(mt) { some(ty::mk_opaque_box(tcx)) }
+      ty::ty_fn(fty) { some(ty::mk_fn(tcx, {proto: fty.proto,
+                                            inputs: [],
+                                            output: ty::mk_nil(tcx),
+                                            ret_style: ast::return_val,
+                                            constraints: []})) }
+      ty::ty_iface(_, _) { some(ty::mk_fn(tcx, {proto: ast::proto_box,
+                                                inputs: [],
+                                                output: ty::mk_nil(tcx),
+                                                ret_style: ast::return_val,
+                                                constraints: []})) }
+      ty::ty_ptr(_) { some(ty::mk_uint(tcx)) }
+      _ { none }
+    }
+}
+
+fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: [ty::t],
+                vtables: option<typeck::vtable_res>,
+                param_uses: option<[type_use::type_uses]>) -> mono_id {
+    let precise_param_ids = alt vtables {
+      some(vts) {
+        let bounds = ty::lookup_item_type(ccx.tcx, item).bounds;
+        let i = 0u;
+        vec::map2(*bounds, substs, {|bounds, subst|
+            let v = [];
+            for bound in *bounds {
+                alt bound {
+                  ty::bound_iface(_) {
+                    v += [impl::vtable_id(ccx, vts[i])];
+                    i += 1u;
+                  }
+                  _ {}
+                }
+            }
+            mono_precise(subst, if v.len() > 0u { some(v) } else { none })
+        })
+      }
+      none {
+        vec::map(substs, {|subst| mono_precise(subst, none)})
+      }
+    };
+    let param_ids = alt param_uses {
+      some(uses) {
+        vec::map2(precise_param_ids, uses, {|id, uses|
+            alt check id {
+              mono_precise(_, some(_)) { id }
+              mono_precise(subst, none) {
+                if uses == 0u { mono_any }
+                else if uses == type_use::use_repr &&
+                        !ty::type_needs_drop(ccx.tcx, subst) {
+                    let llty = type_of(ccx, subst);
+                    let size = shape::llsize_of_real(ccx, llty);
+                    let align = shape::llalign_of_real(ccx, llty);
+                    // Special value for nil to prevent problems with undef
+                    // return pointers.
+                    if size == 1u && ty::type_is_nil(subst) {
+                        mono_repr(0u, 0u)
+                    } else { mono_repr(size, align) }
+                } else { id }
+              }
+            }
+        })
+      }
+      none { precise_param_ids }
+    };
+    @{def: item, params: param_ids}
+}
+
+fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, real_substs: [ty::t],
                   vtables: option<typeck::vtable_res>)
     -> {val: ValueRef, must_cast: bool, intrinsic: bool} {
     let mut must_cast = false;
-    let substs = vec::map(substs, {|t|
-        alt ty::get(t).struct {
-          ty::ty_box(mt) { must_cast = true; ty::mk_opaque_box(ccx.tcx) }
-          _ { t }
+    let substs = vec::map(real_substs, {|t|
+        alt normalize_for_monomorphization(ccx.tcx, t) {
+          some(t) { must_cast = true; t }
+          none { t }
         }
     });
-    let hash_id = @{def: fn_id, substs: substs, vtables: alt vtables {
-      some(os) { some_vts(vec::map(*os, impl::vtable_id)) }
-      none { no_vts }
-    }};
+
+    let param_uses = type_use::type_uses_for(ccx, fn_id, substs.len());
+    let hash_id = make_mono_id(ccx, fn_id, substs, vtables, some(param_uses));
+    if vec::any(hash_id.params,
+                {|p| alt p { mono_precise(_, _) { false } _ { true } } }) {
+        must_cast = true;
+    }
     alt ccx.monomorphized.find(hash_id) {
-      some(val) { ret {val: val, must_cast: must_cast, intrinsic: false}; }
+      some(val) {
+        ret {val: val, must_cast: must_cast, intrinsic: false};
+      }
       none {}
     }
 
@@ -1867,12 +1943,12 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, substs: [ty::t],
                  impl_self(selfty), psubsts, fn_id.node, none);
       }
       ast_map::node_ctor(i) {
-        alt check ccx.tcx.items.get(i.id) {
-          ast_map::node_item(@{node: ast::item_res(decl, _, _, _, _), _}, _) {
+        alt check i.node {
+          ast::item_res(decl, _, _, _, _) {
             set_inline_hint(lldecl);
             trans_res_ctor(ccx, pt, decl, fn_id.node, psubsts, lldecl);
           }
-          ast_map::node_item(@{node: ast::item_class(_, _, ctor), _}, _) {
+          ast::item_class(_, _, ctor) {
             ccx.sess.unimpl("monomorphic class constructor");
           }
         }
@@ -4606,6 +4682,7 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
           tydescs: ty::new_ty_hash(),
           external: util::common::new_def_hash(),
           monomorphized: map::hashmap(hash_mono_id, {|a, b| a == b}),
+          type_use_cache: util::common::new_def_hash(),
           vtables: map::hashmap(hash_mono_id, {|a, b| a == b}),
           module_data: str_hash::<ValueRef>(),
           lltypes: ty::new_ty_hash(),

src/rustc/middle/trans/common.rs

@@ -90,6 +90,8 @@ type crate_ctxt = {
      external: hashmap<ast::def_id, option<ast::node_id>>,
      // Cache instances of monomorphized functions
      monomorphized: hashmap<mono_id, ValueRef>,
+     // Cache computed type parameter uses (see type_use.rs)
+     type_use_cache: hashmap<ast::def_id, [type_use::type_uses]>,
      // Cache generated vtables
      vtables: hashmap<mono_id, ValueRef>,
      module_data: hashmap<str, ValueRef>,
@@ -797,15 +799,27 @@ fn C_shape(ccx: @crate_ctxt, bytes: [u8]) -> ValueRef {
     ret llvm::LLVMConstPointerCast(llglobal, T_ptr(T_i8()));
 }
 
-// Used to identify cached monomorphized functions
-enum mono_vtables { some_vts([mono_id]), no_vts }
-type mono_id = @{def: ast::def_id, substs: [ty::t], vtables: mono_vtables};
+// Used to identify cached monomorphized functions and vtables
+enum mono_param_id {
+    mono_precise(ty::t, option<[mono_id]>),
+    mono_any,
+    mono_repr(uint /* size */, uint /* align */),
+}
+type mono_id = @{def: ast::def_id, params: [mono_param_id]};
 fn hash_mono_id(&&mi: mono_id) -> uint {
     let h = syntax::ast_util::hash_def_id(mi.def);
-    for ty in mi.substs { h = (h << 2u) + ty::type_id(ty); }
-    alt mi.vtables {
-      some_vts(ds) { for d in ds { h = (h << 2u) + hash_mono_id(d); } }
-      no_vts {}
+    for param in mi.params {
+        h = h * alt param {
+          mono_precise(ty, vts) {
+            let h = ty::type_id(ty);
+            option::may(vts) {|vts|
+                for vt in vts { h += hash_mono_id(vt); }
+            }
+            h
+          }
+          mono_any { 1u }
+          mono_repr(sz, align) { sz * (align + 2u) }
+        }
     }
     h
 }

src/rustc/middle/trans/impl.rs

@@ -187,22 +187,23 @@ fn resolve_vtable_in_fn_ctxt(fcx: fn_ctxt, vt: typeck::vtable_origin)
     }
 }
 
-fn vtable_id(origin: typeck::vtable_origin) -> mono_id {
+fn vtable_id(ccx: @crate_ctxt, origin: typeck::vtable_origin) -> mono_id {
     alt check origin {
       typeck::vtable_static(impl_id, substs, sub_vtables) {
-        @{def: impl_id, substs: substs,
-          vtables: if (*sub_vtables).len() == 0u { no_vts }
-                 else { some_vts(vec::map(*sub_vtables, vtable_id)) } }
+        make_mono_id(ccx, impl_id, substs,
+                     if (*sub_vtables).len() == 0u { none }
+                     else { some(sub_vtables) }, none)
       }
       typeck::vtable_iface(iface_id, substs) {
-        @{def: iface_id, substs: substs, vtables: no_vts}
+        @{def: iface_id,
+          params: vec::map(substs, {|t| mono_precise(t, none)})}
       }
     }
 }
 
 fn get_vtable(ccx: @crate_ctxt, origin: typeck::vtable_origin)
     -> ValueRef {
-    let hash_id = vtable_id(origin);
+    let hash_id = vtable_id(ccx, origin);
     alt ccx.vtables.find(hash_id) {
       some(val) { val }
       none {