2 import trans_common::*;
4 import option::{some, none};
5 import syntax::{ast, ast_util};
6 import metadata::csearch;
8 import lib::llvm::llvm;
9 import llvm::{ValueRef, TypeRef, LLVMGetParam};
11 // Translation functionality related to impls and ifaces
14 // vtable: a table of function pointers pointing to method wrappers
15 // of an impl that implements an iface
16 // dict: a record containing a vtable pointer along with pointers to
17 // all tydescs and other dicts needed to run methods in this vtable
18 // (i.e. corresponding to the type parameters of the impl)
19 // wrapper: a function that takes a dict as first argument, along
20 // with the method-specific tydescs for a method (and all
21 // other args the method expects), which fetches the extra
22 // tydescs and dicts from the dict, splices them into the
23 // arglist, and calls through to the actual method
25 // Generic functions take, along with their normal arguments, a number
26 // of extra tydesc and dict arguments -- one tydesc for each type
27 // parameter, one dict (following the tydesc in the arg order) for
28 // each interface bound on a type parameter.
30 // Most dicts are completely static, and are allocated and filled at
31 // compile time. Dicts that depend on run-time values (tydescs or
32 // dicts for type parameter types) are built at run-time, and interned
33 // through upcall_intern_dict in the runtime. This means that dict
34 // pointers are self-contained things that do not need to be cleaned
37 // The trans_constants pass in trans.rs outputs the vtables. Typeck
38 // annotates notes with information about the methods and dicts that
39 // are referenced (ccx.method_map and ccx.dict_map).
41 fn trans_impl(cx: @local_ctxt, name: ast::ident, methods: [@ast::method],
42 id: ast::node_id, tps: [ast::ty_param]) {
43 let sub_cx = extend_path(cx, name);
45 alt cx.ccx.item_ids.find(m.id) {
47 trans_fn(extend_path(sub_cx, m.ident), m.span, m.decl, m.body,
48 llfn, impl_self(ty::node_id_to_monotype(cx.ccx.tcx, id)),
55 fn trans_self_arg(bcx: @block_ctxt, base: @ast::expr) -> result {
57 let basety = ty::expr_ty(bcx_tcx(bcx), base);
58 let {bcx, val} = trans_arg_expr(bcx, {mode: ast::by_ref, ty: basety},
59 T_ptr(type_of_or_i8(bcx, basety)), tz,
61 rslt(bcx, PointerCast(bcx, val, T_opaque_cbox_ptr(bcx_ccx(bcx))))
64 fn trans_static_callee(bcx: @block_ctxt, e: @ast::expr, base: @ast::expr,
65 did: ast::def_id) -> lval_maybe_callee {
66 let {bcx, val} = trans_self_arg(bcx, base);
67 {env: obj_env(val) with lval_static_fn(bcx, did, e.id)}
70 fn trans_dict_callee(bcx: @block_ctxt, e: @ast::expr, base: @ast::expr,
71 iface_id: ast::def_id, n_method: uint,
72 n_param: uint, n_bound: uint) -> lval_maybe_callee {
73 let tcx = bcx_tcx(bcx);
74 let {bcx, val} = trans_self_arg(bcx, base);
75 let dict = option::get(bcx.fcx.lltyparams[n_param].dicts)[n_bound];
76 let method = ty::iface_methods(tcx, iface_id)[n_method];
77 let fty = ty::expr_ty(tcx, e);
78 let bare_fn_ty = type_of_fn_from_ty(bcx_ccx(bcx), ast_util::dummy_sp(),
80 let {inputs: bare_inputs, output} = llfn_arg_tys(bare_fn_ty);
81 let fn_ty = T_fn([val_ty(dict)] + bare_inputs, output);
82 let vtable = PointerCast(bcx, Load(bcx, GEPi(bcx, dict, [0, 0])),
83 T_ptr(T_array(T_ptr(fn_ty), n_method + 1u)));
84 let mptr = Load(bcx, GEPi(bcx, vtable, [0, n_method as int]));
86 if vec::len(*method.tps) > 0u {
87 let tydescs = [], tis = [];
88 let tptys = ty::node_id_to_type_params(tcx, e.id);
89 for t in vec::tail_n(tptys, vec::len(tptys) - vec::len(*method.tps)) {
90 // TODO: Doesn't always escape.
92 let td = get_tydesc(bcx, t, true, tps_normal, ti).result;
97 generic = some({item_type: fty,
100 param_bounds: method.tps,
101 origins: bcx_ccx(bcx).dict_map.find(e.id)});
103 {bcx: bcx, val: mptr, kind: owned,
104 env: dict_env(dict, val),
108 fn llfn_arg_tys(ft: TypeRef) -> {inputs: [TypeRef], output: TypeRef} {
109 let out_ty = llvm::LLVMGetReturnType(ft);
110 let n_args = llvm::LLVMCountParamTypes(ft);
111 let args = vec::init_elt(0 as TypeRef, n_args);
112 unsafe { llvm::LLVMGetParamTypes(ft, vec::to_ptr(args)); }
113 {inputs: args, output: out_ty}
116 fn trans_wrapper(ccx: @crate_ctxt, pt: [ast::ident],
117 extra_tps: [ty::param_bounds], m: @ast::method) -> ValueRef {
118 let real_fn = ccx.item_ids.get(m.id);
119 let {inputs: real_args, output: real_ret} =
120 llfn_arg_tys(llvm::LLVMGetElementType(val_ty(real_fn)));
122 for tp in extra_tps {
123 extra_ptrs += [T_ptr(ccx.tydesc_type)];
126 ty::bound_iface(_) { extra_ptrs += [T_ptr(T_dict())]; }
131 let env_ty = T_ptr(T_struct([T_ptr(T_i8())] + extra_ptrs));
132 let n_extra_ptrs = vec::len(extra_ptrs);
134 let wrap_args = [T_ptr(T_dict())] + vec::slice(real_args, 0u, 2u) +
135 vec::slice(real_args, 2u + vec::len(extra_ptrs), vec::len(real_args));
136 let llfn_ty = T_fn(wrap_args, real_ret);
138 let lcx = @{path: pt + ["wrapper", m.ident], module_path: [],
139 obj_typarams: [], obj_fields: [], ccx: ccx};
140 let name = link::mangle_internal_name_by_path_and_seq(ccx, pt, m.ident);
141 let llfn = decl_internal_cdecl_fn(ccx.llmod, name, llfn_ty);
142 let fcx = new_fn_ctxt(lcx, ast_util::dummy_sp(), llfn);
143 let bcx = new_top_block_ctxt(fcx), lltop = bcx.llbb;
145 let dict = PointerCast(bcx, LLVMGetParam(llfn, 0u), env_ty);
147 let args = [LLVMGetParam(llfn, 1u), LLVMGetParam(llfn, 2u)], i = 0u;
148 // saved tydescs/dicts
149 while i < n_extra_ptrs {
151 args += [load_inbounds(bcx, dict, [0, i as int])];
153 // the rest of the parameters
154 let i = 3u, params_total = llvm::LLVMCountParamTypes(llfn_ty);
155 while i < params_total {
156 args += [LLVMGetParam(llfn, i)];
159 Call(bcx, ccx.item_ids.get(m.id), args);
161 finish_fn(fcx, lltop);
165 fn dict_is_static(tcx: ty::ctxt, origin: typeck::dict_origin) -> bool {
167 typeck::dict_static(_, ts, origs) {
168 vec::all(ts, {|t| !ty::type_contains_params(tcx, t)}) &&
169 vec::all(*origs, {|o| dict_is_static(tcx, o)})
171 typeck::dict_param(_, _) { false }
175 fn get_dict(bcx: @block_ctxt, origin: typeck::dict_origin) -> result {
176 let ccx = bcx_ccx(bcx);
178 typeck::dict_static(impl_did, tys, sub_origins) {
179 if dict_is_static(ccx.tcx, origin) {
180 ret rslt(bcx, get_static_dict(bcx, origin));
182 let {bcx, ptrs} = get_dict_ptrs(bcx, origin);
183 let pty = T_ptr(T_i8()), dict_ty = T_array(pty, vec::len(ptrs));
184 let dict = alloca(bcx, dict_ty), i = 0;
186 Store(bcx, PointerCast(bcx, ptr, pty), GEPi(bcx, dict, [0, i]));
189 dict = Call(bcx, ccx.upcalls.intern_dict,
190 [C_uint(ccx, vec::len(ptrs)),
191 PointerCast(bcx, dict, T_ptr(T_dict()))]);
194 typeck::dict_param(n_param, n_bound) {
195 rslt(bcx, option::get(bcx.fcx.lltyparams[n_param].dicts)[n_bound])
200 fn dict_id(tcx: ty::ctxt, origin: typeck::dict_origin) -> dict_id {
202 typeck::dict_static(did, ts, origs) {
203 let d_params = [], orig = 0u;
204 if vec::len(ts) == 0u { ret @{impl_def: did, params: d_params}; }
205 let impl_params = ty::lookup_item_type(tcx, did).bounds;
206 vec::iter2(ts, *impl_params) {|t, bounds|
207 d_params += [dict_param_ty(t)];
208 for bound in *bounds {
211 d_params += [dict_param_dict(dict_id(tcx, origs[orig]))];
217 @{impl_def: did, params: d_params}
222 fn get_static_dict(bcx: @block_ctxt, origin: typeck::dict_origin)
224 let ccx = bcx_ccx(bcx);
225 let id = dict_id(ccx.tcx, origin);
226 alt ccx.dicts.find(id) {
230 let ptrs = C_struct(get_dict_ptrs(bcx, origin).ptrs);
231 let name = ccx.names.next("dict");
232 let gvar = str::as_buf(name, {|buf|
233 llvm::LLVMAddGlobal(ccx.llmod, val_ty(ptrs), buf)
235 llvm::LLVMSetGlobalConstant(gvar, lib::llvm::True);
236 llvm::LLVMSetInitializer(gvar, ptrs);
237 llvm::LLVMSetLinkage(gvar,
238 lib::llvm::LLVMInternalLinkage as llvm::Linkage);
239 let cast = llvm::LLVMConstPointerCast(gvar, T_ptr(T_dict()));
240 ccx.dicts.insert(id, cast);
244 fn get_dict_ptrs(bcx: @block_ctxt, origin: typeck::dict_origin)
245 -> {bcx: @block_ctxt, ptrs: [ValueRef]} {
246 let ccx = bcx_ccx(bcx);
248 typeck::dict_static(impl_did, tys, sub_origins) {
249 let vtable = if impl_did.crate == ast::local_crate {
250 ccx.item_ids.get(impl_did.node)
252 let name = csearch::get_symbol(ccx.sess.get_cstore(), impl_did);
253 get_extern_const(ccx.externs, ccx.llmod, name, T_ptr(T_i8()))
255 let impl_params = ty::lookup_item_type(ccx.tcx, impl_did).bounds;
256 let ptrs = [vtable], origin = 0u, ti = none, bcx = bcx;
257 vec::iter2(*impl_params, tys) {|param, ty|
258 let rslt = get_tydesc(bcx, ty, true, tps_normal, ti).result;
261 for bound in *param {
264 let res = get_dict(bcx, sub_origins[origin]);
273 {bcx: bcx, ptrs: ptrs}