---

yaml
---
r: 7080
b: refs/heads/master
c: 4f3171e
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 6cfc196d424d50e39c3f697b213a62ff8df9979b
+refs/heads/master: 4f3171ea8150953b30b79aed9a3f35f14b40c0ba

trunk/mk/clean.mk

@@ -48,8 +48,7 @@ clean-misc:
                                    test/*/*.$(ext) \
                                    test/bench/*/*.$(ext)))
 	$(Q)rm -Rf $(foreach ext, \
-                 css html js \
-                 aux cp fn ky log pdf pg toc tp vr cps, \
+                 html aux cp fn ky log pdf pg toc tp vr cps, \
                  $(wildcard doc/*.$(ext) \
                             doc/*/*.$(ext) \
                             doc/*/*/*.$(ext)))

trunk/src/comp/back/upcall.rs

@@ -2,7 +2,7 @@
 import driver::session;
 import middle::trans;
 import middle::trans_common::{T_fn, T_i1, T_i8, T_i32,
-                              T_int, T_nil,
+                              T_int, T_nil, T_dict,
                               T_opaque_vec, T_ptr,
                               T_size_t, T_void};
 import lib::llvm::type_names;
@@ -20,6 +20,7 @@ type upcalls =
      create_shared_type_desc: ValueRef,
      free_shared_type_desc: ValueRef,
      get_type_desc: ValueRef,
+     intern_dict: ValueRef,
      vec_grow: ValueRef,
      vec_push: ValueRef,
      cmp_type: ValueRef,
@@ -76,6 +77,8 @@ fn declare_upcalls(targ_cfg: @session::config,
                  size_t, size_t,
                  T_ptr(T_ptr(tydesc_type)), int_t],
                 T_ptr(tydesc_type)),
+          intern_dict:
+              d("intern_dict", [size_t, T_ptr(T_dict())], T_ptr(T_dict())),
           vec_grow:
               dv("vec_grow", [T_ptr(T_ptr(opaque_vec_t)), int_t]),
           vec_push:

trunk/src/comp/middle/resolve.rs

@@ -1892,7 +1892,7 @@ fn visit_mod_with_impl_scope(e: @env, m: ast::_mod, s: span, sc: iscopes,
 
 fn resolve_impl_in_expr(e: @env, x: @ast::expr, sc: iscopes, v: vt<iscopes>) {
     alt x.node {
-      ast::expr_field(_, _, _) | ast::expr_path(_) {
+      ast::expr_field(_, _, _) | ast::expr_path(_) | ast::expr_cast(_, _) {
         e.impl_map.insert(x.id, sc);
       }
       _ {}

trunk/src/comp/middle/trans.rs

@@ -5689,6 +5689,7 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
           discrim_symbols: new_int_hash::<str>(),
           consts: new_int_hash::<ValueRef>(),
           tydescs: ty::new_ty_hash(),
+          dicts: map::mk_hashmap(hash_dict_id, {|a, b| a == b}),
           module_data: new_str_hash::<ValueRef>(),
           lltypes: ty::new_ty_hash(),
           names: namegen(0),

trunk/src/comp/middle/trans_closure.rs

@@ -461,18 +461,24 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t,
     let (outgoing_fty_real, lltydescs, param_bounds) = alt f_res.generic {
       none. { (outgoing_fty, [], @[]) }
       some(ginfo) {
-        for bounds in *ginfo.param_bounds {
+        let tds = [], orig = 0u;
+        vec::iter2(ginfo.tydescs, *ginfo.param_bounds) {|td, bounds|
+            tds += [td];
             for bound in *bounds {
                 alt bound {
                   ty::bound_iface(_) {
-                    fail "FIXME[impl] binding bounded types not implemented";
+                    let dict = trans_impl::get_dict(
+                        bcx, option::get(ginfo.origins)[orig]);
+                    tds += [PointerCast(bcx, dict.val, val_ty(td))];
+                    orig += 1u;
+                    bcx = dict.bcx;
                   }
                   _ {}
                 }
             }
         }
         lazily_emit_all_generic_info_tydesc_glues(cx, ginfo);
-        (ginfo.item_type, ginfo.tydescs, ginfo.param_bounds)
+        (ginfo.item_type, tds, ginfo.param_bounds)
       }
     };
 

trunk/src/comp/middle/trans_common.rs

@@ -93,6 +93,7 @@ type crate_ctxt =
      discrim_symbols: hashmap<ast::node_id, str>,
      consts: hashmap<ast::node_id, ValueRef>,
      tydescs: hashmap<ty::t, @tydesc_info>,
+     dicts: hashmap<dict_id, ValueRef>,
      module_data: hashmap<str, ValueRef>,
      lltypes: hashmap<ty::t, TypeRef>,
      names: namegen,
@@ -925,6 +926,24 @@ pure fn type_is_tup_like(cx: @block_ctxt, t: ty::t) -> bool {
     ty::type_is_tup_like(tcx, t)
 }
 
+// Used to identify cached dictionaries
+tag dict_param {
+    dict_param_dict(dict_id);
+    dict_param_ty(ty::t);
+}
+type dict_id = @{impl_def: ast::def_id, params: [dict_param]};
+fn hash_dict_id(&&dp: dict_id) -> uint {
+    let h = syntax::ast_util::hash_def_id(dp.impl_def);
+    for param in dp.params {
+        h = h << 2u;
+        alt param {
+          dict_param_dict(d) { h += hash_dict_id(d); }
+          dict_param_ty(t) { h += t; }
+        }
+    }
+    h
+}
+
 //
 // Local Variables:
 // mode: rust

trunk/src/comp/middle/trans_impl.rs

@@ -5,8 +5,38 @@ import option::{some, none};
 import syntax::{ast, ast_util};
 import metadata::csearch;
 import back::link;
-import lib::llvm;
-import llvm::llvm::{ValueRef, TypeRef, LLVMGetParam};
+import lib::llvm::llvm;
+import llvm::{ValueRef, TypeRef, LLVMGetParam};
+
+// Translation functionality related to impls and ifaces
+//
+// Terminology:
+//  vtable:  a table of function pointers pointing to method wrappers
+//           of an impl that implements an iface
+//  dict:    a record containing a vtable pointer along with pointers to
+//           all tydescs and other dicts needed to run methods in this vtable
+//           (i.e. corresponding to the type parameters of the impl)
+//  wrapper: a function that takes a dict as first argument, along
+//           with the method-specific tydescs for a method (and all
+//           other args the method expects), which fetches the extra
+//           tydescs and dicts from the dict, splices them into the
+//           arglist, and calls through to the actual method
+//
+// Generic functions take, along with their normal arguments, a number
+// of extra tydesc and dict arguments -- one tydesc for each type
+// parameter, one dict (following the tydesc in the arg order) for
+// each interface bound on a type parameter.
+//
+// Most dicts are completely static, and are allocated and filled at
+// compile time. Dicts that depend on run-time values (tydescs or
+// dicts for type parameter types) are built at run-time, and interned
+// through upcall_intern_dict in the runtime. This means that dict
+// pointers are self-contained things that do not need to be cleaned
+// up.
+//
+// The trans_constants pass in trans.rs outputs the vtables. Typeck
+// annotates notes with information about the methods and dicts that
+// are referenced (ccx.method_map and ccx.dict_map).
 
 fn trans_impl(cx: @local_ctxt, name: ast::ident, methods: [@ast::method],
               id: ast::node_id, tps: [ast::ty_param]) {
@@ -55,7 +85,8 @@ fn trans_dict_callee(bcx: @block_ctxt, e: @ast::expr, base: @ast::expr,
     let generic = none;
     if vec::len(*method.tps) > 0u {
         let tydescs = [], tis = [];
-        for t in ty::node_id_to_type_params(tcx, e.id) {
+        let tptys = ty::node_id_to_type_params(tcx, e.id);
+        for t in vec::tail_n(tptys, vec::len(tptys) - vec::len(*method.tps)) {
             // TODO: Doesn't always escape.
             let ti = none;
             let td = get_tydesc(bcx, t, true, tps_normal, ti).result;
@@ -75,18 +106,18 @@ fn trans_dict_callee(bcx: @block_ctxt, e: @ast::expr, base: @ast::expr,
 }
 
 fn llfn_arg_tys(ft: TypeRef) -> {inputs: [TypeRef], output: TypeRef} {
-    let out_ty = llvm::llvm::LLVMGetReturnType(ft);
-    let n_args = llvm::llvm::LLVMCountParamTypes(ft);
+    let out_ty = llvm::LLVMGetReturnType(ft);
+    let n_args = llvm::LLVMCountParamTypes(ft);
     let args = vec::init_elt(0 as TypeRef, n_args);
-    unsafe { llvm::llvm::LLVMGetParamTypes(ft, vec::to_ptr(args)); }
+    unsafe { llvm::LLVMGetParamTypes(ft, vec::to_ptr(args)); }
     {inputs: args, output: out_ty}
 }
 
 fn trans_wrapper(ccx: @crate_ctxt, pt: [ast::ident],
                  extra_tps: [ty::param_bounds], m: @ast::method) -> ValueRef {
     let real_fn = ccx.item_ids.get(m.id);
     let {inputs: real_args, output: real_ret} =
-        llfn_arg_tys(llvm::llvm::LLVMGetElementType(val_ty(real_fn)));
+        llfn_arg_tys(llvm::LLVMGetElementType(val_ty(real_fn)));
     let extra_ptrs = [];
     for tp in extra_tps {
         extra_ptrs += [T_ptr(ccx.tydesc_type)];
@@ -120,7 +151,7 @@ fn trans_wrapper(ccx: @crate_ctxt, pt: [ast::ident],
         args += [load_inbounds(bcx, dict, [0, i as int])];
     }
     // the rest of the parameters
-    let i = 3u, params_total = llvm::llvm::LLVMCountParamTypes(llfn_ty);
+    let i = 3u, params_total = llvm::LLVMCountParamTypes(llfn_ty);
     while i < params_total {
         args += [LLVMGetParam(llfn, i)];
         i += 1u;
@@ -131,9 +162,88 @@ fn trans_wrapper(ccx: @crate_ctxt, pt: [ast::ident],
     ret llfn;
 }
 
-// FIXME[impl] cache these on the function level somehow
+fn dict_is_static(tcx: ty::ctxt, origin: typeck::dict_origin) -> bool {
+    alt origin {
+      typeck::dict_static(_, ts, origs) {
+        vec::all(ts, {|t| !ty::type_contains_params(tcx, t)}) &&
+        vec::all(*origs, {|o| dict_is_static(tcx, o)})
+      }
+      typeck::dict_param(_, _) { false }
+    }
+}
+
 fn get_dict(bcx: @block_ctxt, origin: typeck::dict_origin) -> result {
-    let bcx = bcx, ccx = bcx_ccx(bcx);
+    let ccx = bcx_ccx(bcx);
+    alt origin {
+      typeck::dict_static(impl_did, tys, sub_origins) {
+        if dict_is_static(ccx.tcx, origin) {
+            ret rslt(bcx, get_static_dict(bcx, origin));
+        }
+        let {bcx, ptrs} = get_dict_ptrs(bcx, origin);
+        let pty = T_ptr(T_i8()), dict_ty = T_array(pty, vec::len(ptrs));
+        let dict = alloca(bcx, dict_ty), i = 0;
+        for ptr in ptrs {
+            Store(bcx, PointerCast(bcx, ptr, pty), GEPi(bcx, dict, [0, i]));
+            i += 1;
+        }
+        dict = Call(bcx, ccx.upcalls.intern_dict,
+                    [C_uint(ccx, vec::len(ptrs)),
+                     PointerCast(bcx, dict, T_ptr(T_dict()))]);
+        rslt(bcx, dict)
+      }
+      typeck::dict_param(n_param, n_bound) {
+        rslt(bcx, option::get(bcx.fcx.lltyparams[n_param].dicts)[n_bound])
+      }
+    }
+}
+
+fn dict_id(tcx: ty::ctxt, origin: typeck::dict_origin) -> dict_id {
+    alt origin {
+      typeck::dict_static(did, ts, origs) {
+        let d_params = [], orig = 0u;
+        if vec::len(ts) == 0u { ret @{impl_def: did, params: d_params}; }
+        let impl_params = ty::lookup_item_type(tcx, did).bounds;
+        vec::iter2(ts, *impl_params) {|t, bounds|
+            d_params += [dict_param_ty(t)];
+            for bound in *bounds {
+                alt bound {
+                  ty::bound_iface(_) {
+                    d_params += [dict_param_dict(dict_id(tcx, origs[orig]))];
+                    orig += 1u;
+                  }
+                }
+            }
+        }
+        @{impl_def: did, params: d_params}
+      }
+    }
+}
+
+fn get_static_dict(bcx: @block_ctxt, origin: typeck::dict_origin)
+    -> ValueRef {
+    let ccx = bcx_ccx(bcx);
+    let id = dict_id(ccx.tcx, origin);
+    alt ccx.dicts.find(id) {
+      some(d) { ret d; }
+      none. {}
+    }
+    let ptrs = C_struct(get_dict_ptrs(bcx, origin).ptrs);
+    let name = ccx.names.next("dict");
+    let gvar = str::as_buf(name, {|buf|
+        llvm::LLVMAddGlobal(ccx.llmod, val_ty(ptrs), buf)
+    });
+    llvm::LLVMSetGlobalConstant(gvar, lib::llvm::True);
+    llvm::LLVMSetInitializer(gvar, ptrs);
+    llvm::LLVMSetLinkage(gvar,
+                         lib::llvm::LLVMInternalLinkage as llvm::Linkage);
+    let cast = llvm::LLVMConstPointerCast(gvar, T_ptr(T_dict()));
+    ccx.dicts.insert(id, cast);
+    cast
+}
+
+fn get_dict_ptrs(bcx: @block_ctxt, origin: typeck::dict_origin)
+    -> {bcx: @block_ctxt, ptrs: [ValueRef]} {
+    let ccx = bcx_ccx(bcx);
     alt origin {
       typeck::dict_static(impl_did, tys, sub_origins) {
         let vtable = if impl_did.crate == ast::local_crate {
@@ -143,9 +253,9 @@ fn get_dict(bcx: @block_ctxt, origin: typeck::dict_origin) -> result {
             get_extern_const(ccx.externs, ccx.llmod, name, T_ptr(T_i8()))
         };
         let impl_params = ty::lookup_item_type(ccx.tcx, impl_did).bounds;
-        let ptrs = [vtable], i = 0u, origin = 0u, ti = none;
-        for param in *impl_params {
-            let rslt = get_tydesc(bcx, tys[i], false, tps_normal, ti).result;
+        let ptrs = [vtable], origin = 0u, ti = none, bcx = bcx;
+        vec::iter2(*impl_params, tys) {|param, ty|
+            let rslt = get_tydesc(bcx, ty, true, tps_normal, ti).result;
             ptrs += [rslt.val];
             bcx = rslt.bcx;
             for bound in *param {
@@ -159,18 +269,8 @@ fn get_dict(bcx: @block_ctxt, origin: typeck::dict_origin) -> result {
                   _ {}
                 }
             }
-            i += 1u;
         }
-        let pty = T_ptr(T_i8()), dict_ty = T_array(pty, vec::len(ptrs));
-        let dict = alloca(bcx, dict_ty), i = 0;
-        for ptr in ptrs {
-            Store(bcx, PointerCast(bcx, ptr, pty), GEPi(bcx, dict, [0, i]));
-            i += 1;
-        }
-        rslt(bcx, PointerCast(bcx, dict, T_ptr(T_dict())))
-      }
-      typeck::dict_param(n_param, n_bound) {
-        rslt(bcx, option::get(bcx.fcx.lltyparams[n_param].dicts)[n_bound])
+        {bcx: bcx, ptrs: ptrs}
       }
     }
-}
+}