Revert "Issue rust-lang#3678: Remove wrappers and call foreign functions directly"

This reverts commit 303f650.

Author: toddaaro

src/librustc/back/upcall.rs

@@ -16,6 +16,8 @@ use lib::llvm::{ModuleRef, ValueRef};
 
 pub struct Upcalls {
     trace: ValueRef,
+    call_shim_on_c_stack: ValueRef,
+    call_shim_on_rust_stack: ValueRef,
     rust_personality: ValueRef,
     reset_stack_limit: ValueRef
 }
@@ -45,6 +47,9 @@ pub fn declare_upcalls(targ_cfg: @session::config, llmod: ModuleRef) -> @Upcalls
 
     @Upcalls {
         trace: upcall!(fn trace(opaque_ptr, opaque_ptr, int_ty) -> Type::void()),
+        call_shim_on_c_stack: upcall!(fn call_shim_on_c_stack(opaque_ptr, opaque_ptr) -> int_ty),
+        call_shim_on_rust_stack:
+            upcall!(fn call_shim_on_rust_stack(opaque_ptr, opaque_ptr) -> int_ty),
         rust_personality: upcall!(nothrow fn rust_personality -> Type::i32()),
         reset_stack_limit: upcall!(nothrow fn reset_stack_limit -> Type::void())
     }

src/librustc/driver/driver.rs

@@ -265,9 +265,6 @@ pub fn phase_3_run_analysis_passes(sess: Session,
     time(time_passes, ~"loop checking", ||
          middle::check_loop::check_crate(ty_cx, crate));
 
-    time(time_passes, ~"stack checking", ||
-         middle::stack_check::stack_check_crate(ty_cx, crate));
-
     let middle::moves::MoveMaps {moves_map, moved_variables_set,
                                  capture_map} =
         time(time_passes, ~"compute moves", ||

src/librustc/lib/llvm.rs

@@ -2246,11 +2246,6 @@ impl TypeNames {
         self.type_to_str_depth(ty, 30)
     }
 
-    pub fn types_to_str(&self, tys: &[Type]) -> ~str {
-        let strs = tys.map(|t| self.type_to_str(*t));
-        fmt!("[%s]", strs.connect(","))
-    }
-
     pub fn val_to_str(&self, val: ValueRef) -> ~str {
         unsafe {
             let ty = Type::from_ref(llvm::LLVMTypeOf(val));

src/librustc/middle/lint.rs

@@ -73,7 +73,6 @@ use syntax::{ast, oldvisit, ast_util, visit};
 #[deriving(Clone, Eq)]
 pub enum lint {
     ctypes,
-    cstack,
     unused_imports,
     unnecessary_qualification,
     while_true,
@@ -147,13 +146,6 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         default: warn
      }),
 
-    ("cstack",
-     LintSpec {
-        lint: cstack,
-        desc: "only invoke foreign functions from fixedstacksegment fns",
-        default: deny
-     }),
-
     ("unused_imports",
      LintSpec {
         lint: unused_imports,

src/librustc/middle/stack_check.rs

@@ -203,28 +203,28 @@ pub fn decl_internal_cdecl_fn(llmod: ModuleRef, name: &str, ty: Type) -> ValueRe
     return llfn;
 }
 
-pub fn get_extern_fn(externs: &mut ExternMap, llmod: ModuleRef, name: &str,
+pub fn get_extern_fn(externs: &mut ExternMap, llmod: ModuleRef, name: @str,
                      cc: lib::llvm::CallConv, ty: Type) -> ValueRef {
-    match externs.find_equiv(&name) {
-        Some(n) => return *n,
+    match externs.find_copy(&name) {
+        Some(n) => return n,
         None => ()
     }
     let f = decl_fn(llmod, name, cc, ty);
-    externs.insert(name.to_owned(), f);
+    externs.insert(name, f);
     return f;
 }
 
 pub fn get_extern_const(externs: &mut ExternMap, llmod: ModuleRef,
-                        name: &str, ty: Type) -> ValueRef {
-    match externs.find_equiv(&name) {
-        Some(n) => return *n,
+                        name: @str, ty: Type) -> ValueRef {
+    match externs.find_copy(&name) {
+        Some(n) => return n,
         None => ()
     }
     unsafe {
         let c = do name.with_c_str |buf| {
             llvm::LLVMAddGlobal(llmod, ty.to_ref(), buf)
         };
-        externs.insert(name.to_owned(), c);
+        externs.insert(name, c);
         return c;
     }
 }
@@ -511,6 +511,7 @@ pub fn get_res_dtor(ccx: @mut CrateContext,
                                      None,
                                      ty::lookup_item_type(tcx, parent_id).ty);
         let llty = type_of_dtor(ccx, class_ty);
+        let name = name.to_managed(); // :-(
         get_extern_fn(&mut ccx.externs,
                       ccx.llmod,
                       name,
@@ -797,13 +798,13 @@ pub fn fail_if_zero(cx: @mut Block, span: span, divrem: ast::binop,
     }
 }
 
-pub fn null_env_ptr(ccx: &CrateContext) -> ValueRef {
-    C_null(Type::opaque_box(ccx).ptr_to())
+pub fn null_env_ptr(bcx: @mut Block) -> ValueRef {
+    C_null(Type::opaque_box(bcx.ccx()).ptr_to())
 }
 
 pub fn trans_external_path(ccx: &mut CrateContext, did: ast::def_id, t: ty::t)
     -> ValueRef {
-    let name = csearch::get_symbol(ccx.sess.cstore, did);
+    let name = csearch::get_symbol(ccx.sess.cstore, did).to_managed(); // Sad
     match ty::get(t).sty {
       ty::ty_bare_fn(_) | ty::ty_closure(_) => {
         let llty = type_of_fn_from_ty(ccx, t);
@@ -1571,7 +1572,7 @@ pub fn mk_return_basic_block(llfn: ValueRef) -> BasicBlockRef {
 // slot where the return value of the function must go.
 pub fn make_return_pointer(fcx: @mut FunctionContext, output_type: ty::t) -> ValueRef {
     unsafe {
-        if type_of::return_uses_outptr(fcx.ccx.tcx, output_type) {
+        if !ty::type_is_immediate(fcx.ccx.tcx, output_type) {
             llvm::LLVMGetParam(fcx.llfn, 0)
         } else {
             let lloutputtype = type_of::type_of(fcx.ccx, output_type);
@@ -1611,7 +1612,7 @@ pub fn new_fn_ctxt_w_id(ccx: @mut CrateContext,
             ty::subst_tps(ccx.tcx, substs.tys, substs.self_ty, output_type)
         }
     };
-    let uses_outptr = type_of::return_uses_outptr(ccx.tcx, substd_output_type);
+    let is_immediate = ty::type_is_immediate(ccx.tcx, substd_output_type);
     let fcx = @mut FunctionContext {
           llfn: llfndecl,
           llenv: unsafe {
@@ -1623,7 +1624,7 @@ pub fn new_fn_ctxt_w_id(ccx: @mut CrateContext,
           llreturn: None,
           llself: None,
           personality: None,
-          caller_expects_out_pointer: uses_outptr,
+          has_immediate_return_value: is_immediate,
           llargs: @mut HashMap::new(),
           lllocals: @mut HashMap::new(),
           llupvars: @mut HashMap::new(),
@@ -1646,15 +1647,8 @@ pub fn new_fn_ctxt_w_id(ccx: @mut CrateContext,
         fcx.alloca_insert_pt = Some(llvm::LLVMGetFirstInstruction(entry_bcx.llbb));
     }
 
-    if !ty::type_is_voidish(substd_output_type) {
-        // If the function returns nil/bot, there is no real return
-        // value, so do not set `llretptr`.
-        if !skip_retptr || uses_outptr {
-            // Otherwise, we normally allocate the llretptr, unless we
-            // have been instructed to skip it for immediate return
-            // values.
-            fcx.llretptr = Some(make_return_pointer(fcx, substd_output_type));
-        }
+    if !ty::type_is_nil(substd_output_type) && !(is_immediate && skip_retptr) {
+        fcx.llretptr = Some(make_return_pointer(fcx, substd_output_type));
     }
     fcx
 }
@@ -1802,7 +1796,7 @@ pub fn finish_fn(fcx: @mut FunctionContext, last_bcx: @mut Block) {
 // Builds the return block for a function.
 pub fn build_return_block(fcx: &FunctionContext, ret_cx: @mut Block) {
     // Return the value if this function immediate; otherwise, return void.
-    if fcx.llretptr.is_none() || fcx.caller_expects_out_pointer {
+    if fcx.llretptr.is_none() || !fcx.has_immediate_return_value {
         return RetVoid(ret_cx);
     }
 
@@ -1888,7 +1882,9 @@ pub fn trans_closure(ccx: @mut CrateContext,
     // translation calls that don't have a return value (trans_crate,
     // trans_mod, trans_item, et cetera) and those that do
     // (trans_block, trans_expr, et cetera).
-    if body.expr.is_none() || ty::type_is_voidish(block_ty) {
+    if body.expr.is_none() || ty::type_is_bot(block_ty) ||
+        ty::type_is_nil(block_ty)
+    {
         bcx = controlflow::trans_block(bcx, body, expr::Ignore);
     } else {
         let dest = expr::SaveIn(fcx.llretptr.unwrap());
@@ -2133,14 +2129,13 @@ pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
       ast::item_fn(ref decl, purity, _abis, ref generics, ref body) => {
         if purity == ast::extern_fn  {
             let llfndecl = get_item_val(ccx, item.id);
-            foreign::trans_rust_fn_with_foreign_abi(
-                ccx,
-                &vec::append((*path).clone(),
-                             [path_name(item.ident)]),
-                decl,
-                body,
-                llfndecl,
-                item.id);
+            foreign::trans_foreign_fn(ccx,
+                                      vec::append((*path).clone(),
+                                                  [path_name(item.ident)]),
+                                      decl,
+                                      body,
+                                      llfndecl,
+                                      item.id);
         } else if !generics.is_type_parameterized() {
             let llfndecl = get_item_val(ccx, item.id);
             trans_fn(ccx,
@@ -2201,7 +2196,7 @@ pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
           }
       },
       ast::item_foreign_mod(ref foreign_mod) => {
-        foreign::trans_foreign_mod(ccx, foreign_mod);
+        foreign::trans_foreign_mod(ccx, path, foreign_mod);
       }
       ast::item_struct(struct_def, ref generics) => {
         if !generics.is_type_parameterized() {
@@ -2296,15 +2291,16 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
 
     fn create_main(ccx: @mut CrateContext, main_llfn: ValueRef) -> ValueRef {
         let nt = ty::mk_nil();
-        let llfty = type_of_rust_fn(ccx, [], nt);
+
+        let llfty = type_of_fn(ccx, [], nt);
         let llfdecl = decl_fn(ccx.llmod, "_rust_main",
                               lib::llvm::CCallConv, llfty);
 
         let fcx = new_fn_ctxt(ccx, ~[], llfdecl, nt, None);
 
         // the args vector built in create_entry_fn will need
         // be updated if this assertion starts to fail.
-        assert!(!fcx.caller_expects_out_pointer);
+        assert!(fcx.has_immediate_return_value);
 
         let bcx = fcx.entry_bcx.unwrap();
         // Call main.
@@ -2467,10 +2463,7 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
                             let llfn = if purity != ast::extern_fn {
                                 register_fn(ccx, i.span, sym, i.id, ty)
                             } else {
-                                foreign::register_rust_fn_with_foreign_abi(ccx,
-                                                                           i.span,
-                                                                           sym,
-                                                                           i.id)
+                                foreign::register_foreign_fn(ccx, i.span, sym, i.id)
                             };
                             set_inline_hint_if_appr(i.attrs, llfn);
                             llfn
@@ -2516,7 +2509,9 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
                     match ni.node {
                         ast::foreign_item_fn(*) => {
                             let path = vec::append((*pth).clone(), [path_name(ni.ident)]);
-                            foreign::register_foreign_item_fn(ccx, abis, &path, ni);
+                            let sym = exported_name(ccx, path, ty, ni.attrs);
+
+                            register_fn(ccx, ni.span, sym, ni.id, ty)
                         }
                         ast::foreign_item_static(*) => {
                             let ident = token::ident_to_str(&ni.ident);