---

yaml
---
r: 15791
b: refs/heads/try
c: d899c3a
h: refs/heads/master
i:
  15789: 7fa439d
  15787: d8d305c
  15783: f09eaf2
  15775: 1f4ace9
v: v3

Author: graydon

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 5428a22b95ccd8c84a402e2f5cb4aa53ddc6f4d4
+refs/heads/try: d899c3a5792da29ac2bf71caf76b56017b5f42d0
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/rustc/middle/trans/impl.rs

@@ -64,24 +64,13 @@ fn trans_method_callee(bcx: block, callee_id: ast::node_id,
         }
       }
       typeck::method_iface(_, off) {
-        trans_iface_callee(bcx, self, callee_id, off)
+        let {bcx, val} = trans_temp_expr(bcx, self);
+        let fty = node_id_type(bcx, callee_id);
+        trans_iface_callee(bcx, val, fty, off)
       }
     }
 }
 
-fn trans_vtable_callee(bcx: block, env: callee_env, vtable: ValueRef,
-                       callee_id: ast::node_id, n_method: uint)
-    -> lval_maybe_callee {
-    let _icx = bcx.insn_ctxt("impl::trans_vtable_callee");
-    let bcx = bcx, ccx = bcx.ccx();
-    let fty = node_id_type(bcx, callee_id);
-    let llfty = type_of::type_of_fn_from_ty(ccx, fty);
-    let vtable = PointerCast(bcx, vtable,
-                             T_ptr(T_array(T_ptr(llfty), n_method + 1u)));
-    let mptr = Load(bcx, GEPi(bcx, vtable, [0u, n_method]));
-    {bcx: bcx, val: mptr, kind: owned, env: env}
-}
-
 fn method_from_methods(ms: [@ast::method], name: ast::ident) -> ast::def_id {
   local_def(option::get(vec::find(ms, {|m| m.ident == name})).id)
 }
@@ -139,7 +128,9 @@ fn trans_monomorphized_callee(bcx: block, callee_id: ast::node_id,
          with lval}
       }
       typeck::vtable_iface(iid, tps) {
-        trans_iface_callee(bcx, base, callee_id, n_method)
+        let {bcx, val} = trans_temp_expr(bcx, base);
+        let fty = node_id_type(bcx, callee_id);
+        trans_iface_callee(bcx, val, fty, n_method)
       }
       typeck::vtable_param(n_param, n_bound) {
         fail "vtable_param left in monomorphized function's vtable substs";
@@ -148,18 +139,22 @@ fn trans_monomorphized_callee(bcx: block, callee_id: ast::node_id,
 }
 
 // Method callee where the vtable comes from a boxed iface
-fn trans_iface_callee(bcx: block, base: @ast::expr,
-                      callee_id: ast::node_id, n_method: uint)
+fn trans_iface_callee(bcx: block, val: ValueRef,
+                      callee_ty: ty::t, n_method: uint)
     -> lval_maybe_callee {
     let _icx = bcx.insn_ctxt("impl::trans_iface_callee");
-    let {bcx, val} = trans_temp_expr(bcx, base);
+    let ccx = bcx.ccx();
     let vtable = Load(bcx, PointerCast(bcx, GEPi(bcx, val, [0u, 0u]),
-                                     T_ptr(T_ptr(T_vtable()))));
+                                       T_ptr(T_ptr(T_vtable()))));
     let box = Load(bcx, GEPi(bcx, val, [0u, 1u]));
     // FIXME[impl] I doubt this is alignment-safe
     let self = GEPi(bcx, box, [0u, abi::box_field_body]);
     let env = self_env(self, ty::mk_opaque_box(bcx.tcx()), some(box));
-    trans_vtable_callee(bcx, env, vtable, callee_id, n_method)
+    let llfty = type_of::type_of_fn_from_ty(ccx, callee_ty);
+    let vtable = PointerCast(bcx, vtable,
+                             T_ptr(T_array(T_ptr(llfty), n_method + 1u)));
+    let mptr = Load(bcx, GEPi(bcx, vtable, [0u, n_method]));
+    {bcx: bcx, val: mptr, kind: owned, env: env}
 }
 
 fn find_vtable_in_fn_ctxt(ps: param_substs, n_param: uint, n_bound: uint)

branches/try/src/rustc/middle/trans/native.rs

@@ -10,7 +10,7 @@ import lib::llvm::{ llvm, TypeRef, ValueRef,
                     StructRetAttribute, ByValAttribute
                   };
 import syntax::{ast, ast_util};
-import back::link;
+import back::{link, abi};
 import common::*;
 import build::*;
 import base::*;
@@ -842,63 +842,65 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::native_item,
         let vp_ty = substs.tys[1];
         let visitor = get_param(decl, first_real_arg);
 
-        // We're going to synthesize a monomorphized vtbl call here much
-        // like what impl::trans_monomorphized_callee does, but without
-        // having quite as much source machinery to go on.
+        let (tyname, args) = alt ty::get(tp_ty).struct {
+          ty::ty_bot { ("bot", []) }
+          ty::ty_nil { ("nil", []) }
+          ty::ty_bool { ("bool", []) }
+          ty::ty_int(ast::ty_i) { ("int", []) }
+          ty::ty_int(ast::ty_char) { ("char", []) }
+          ty::ty_int(ast::ty_i8) { ("i8", []) }
+          ty::ty_int(ast::ty_i16) { ("i16", []) }
+          ty::ty_int(ast::ty_i32) { ("i32", []) }
+          ty::ty_int(ast::ty_i64) { ("i64", []) }
+          ty::ty_uint(ast::ty_u) { ("uint", []) }
+          ty::ty_uint(ast::ty_u8) { ("u8", []) }
+          ty::ty_uint(ast::ty_u16) { ("u16", []) }
+          ty::ty_uint(ast::ty_u32) { ("u32", []) }
+          ty::ty_uint(ast::ty_u64) { ("u64", []) }
+          ty::ty_float(ast::ty_f) { ("float", []) }
+          ty::ty_float(ast::ty_f32) { ("f32", []) }
+          ty::ty_float(ast::ty_f64) { ("f64", []) }
+          ty::ty_str { ("str", []) }
+          _ {
+            bcx.sess().unimpl("trans::native::visit_ty on "
+                              + ty_to_str(ccx.tcx, tp_ty));
+          }
+        };
+
+        let mth_name = "visit_" + tyname;
+        let dest = ignore;
 
         alt impl::find_vtable_in_fn_ctxt(substs,
                                          1u, /* n_param */
                                          0u  /* n_bound */ ) {
 
           typeck::vtable_static(impl_did, impl_substs, sub_origins) {
-
-            let (tyname, args) = alt ty::get(tp_ty).struct {
-              ty::ty_bot { ("bot", []) }
-              ty::ty_nil { ("nil", []) }
-              ty::ty_bool { ("bool", []) }
-              ty::ty_int(ast::ty_i) { ("int", []) }
-              ty::ty_int(ast::ty_char) { ("char", []) }
-              ty::ty_int(ast::ty_i8) { ("i8", []) }
-              ty::ty_int(ast::ty_i16) { ("i16", []) }
-              ty::ty_int(ast::ty_i32) { ("i32", []) }
-              ty::ty_int(ast::ty_i64) { ("i64", []) }
-              ty::ty_uint(ast::ty_u) { ("uint", []) }
-              ty::ty_uint(ast::ty_u8) { ("u8", []) }
-              ty::ty_uint(ast::ty_u16) { ("u16", []) }
-              ty::ty_uint(ast::ty_u32) { ("u32", []) }
-              ty::ty_uint(ast::ty_u64) { ("u64", []) }
-              ty::ty_float(ast::ty_f) { ("float", []) }
-              ty::ty_float(ast::ty_f32) { ("f32", []) }
-              ty::ty_float(ast::ty_f64) { ("f64", []) }
-              ty::ty_str { ("str", []) }
-              _ {
-                bcx.sess().unimpl("trans::native::visit_ty on "
-                                  + ty_to_str(ccx.tcx, tp_ty));
-              }
-            };
-
-            let mth_id = impl::method_with_name(ccx, impl_did,
-                                                "visit_" + tyname);
+            let mth_id = impl::method_with_name(ccx, impl_did, mth_name);
             let mth_ty = ty::lookup_item_type(ccx.tcx, mth_id).ty;
-
             // FIXME: is this safe? There is no callee AST node,
             // we're synthesizing it.
             let callee_id = (-1) as ast::node_id;
+            let get_lval = {|bcx|
+                let lval = lval_static_fn_inner(bcx, mth_id, callee_id,
+                                                impl_substs,
+                                                some(sub_origins));
+                {env: self_env(visitor, vp_ty, none) with lval}
+            };
+            bcx = trans_call_inner(bcx, mth_ty, ty::mk_bool(ccx.tcx),
+                                   get_lval, arg_vals(args), dest);
+          }
 
-            let dest = ignore;
-
-            bcx = trans_call_inner(bcx,
-                                   mth_ty,
-                                   ty::mk_nil(ccx.tcx),
-                                   {|bcx|
-                                       let lval =
-                                           lval_static_fn_inner
-                                           (bcx, mth_id, callee_id,
-                                            impl_substs,  some(sub_origins));
-                                       {env: self_env(visitor, vp_ty, none)
-                                        with lval}
-                                   }, arg_vals(args), dest);
+          typeck::vtable_iface(iid, _tps) {
+            let methods = ty::iface_methods(ccx.tcx, iid);
+            let mth_idx = option::get(ty::method_idx(mth_name, *methods));
+            let mth_ty = ty::mk_fn(ccx.tcx, methods[mth_idx].fty);
+            let get_lval = {|bcx|
+                impl::trans_iface_callee(bcx, visitor, mth_ty, mth_idx)
+            };
+            bcx = trans_call_inner(bcx, mth_ty, ty::mk_bool(ccx.tcx),
+                                   get_lval, arg_vals(args), dest);
           }
+
           _ {
             ccx.sess.span_bug(item.span,
                               "non-static callee in 'visit_ty' intrinsinc");