use trans::closure;
use trans::common::{Block, C_bool, C_bytes_in_context, C_i32, C_int, C_integral};
use trans::common::{C_null, C_struct_in_context, C_u64, C_u8, C_undef};
-use trans::common::{CrateContext, ExternMap, FunctionContext};
+use trans::common::{CrateContext, FunctionContext};
use trans::common::{Result, NodeIdAndSpan};
use trans::common::{node_id_type, return_type_is_void};
use trans::common::{type_is_immediate, type_is_zero_size, val_ty};
use trans::expr;
use trans::foreign;
use trans::glue;
-use trans::inline;
use trans::intrinsic;
use trans::machine;
use trans::machine::{llsize_of, llsize_of_real};
use util::nodemap::NodeMap;
use arena::TypedArena;
-use libc::{c_uint, uint64_t};
+use libc::c_uint;
use std::ffi::{CStr, CString};
use std::cell::{Cell, RefCell};
use std::collections::HashSet;
decl_fn(ccx, name, llvm::CCallConv, ty, ty::FnConverging(output))
}
-// only use this for foreign function ABIs and glue, use `get_extern_rust_fn` for Rust functions
-pub fn get_extern_fn(ccx: &CrateContext,
- externs: &mut ExternMap,
- name: &str,
- cc: llvm::CallConv,
- ty: Type,
- output: Ty)
- -> ValueRef {
- match externs.get(name) {
- Some(n) => return *n,
- None => {}
- }
- let f = decl_fn(ccx, name, cc, ty, ty::FnConverging(output));
- externs.insert(name.to_string(), f);
- f
-}
-
fn get_extern_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<'tcx>,
name: &str, did: ast::DefId) -> ValueRef {
match ccx.externs().borrow().get(name) {
ccx.all_llvm_symbols().borrow_mut().insert(sym);
}
-
-pub fn get_res_dtor<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
- did: ast::DefId,
- t: Ty<'tcx>,
- parent_id: ast::DefId,
- substs: &Substs<'tcx>)
- -> ValueRef {
- let _icx = push_ctxt("trans_res_dtor");
- let did = inline::maybe_instantiate_inline(ccx, did);
-
- if !substs.types.is_empty() {
- assert_eq!(did.krate, ast::LOCAL_CRATE);
-
- // Since we're in trans we don't care for any region parameters
- let substs = ccx.tcx().mk_substs(Substs::erased(substs.types.clone()));
-
- let (val, _, _) = monomorphize::monomorphic_fn(ccx, did, substs, None);
-
- val
- } else if did.krate == ast::LOCAL_CRATE {
- get_item_val(ccx, did.node)
- } else {
- let tcx = ccx.tcx();
- let name = csearch::get_symbol(&ccx.sess().cstore, did);
- let class_ty = ty::lookup_item_type(tcx, parent_id).ty.subst(tcx, substs);
- let llty = type_of_dtor(ccx, class_ty);
- let dtor_ty = ty::mk_ctor_fn(ccx.tcx(),
- did,
- &[glue::get_drop_glue_type(ccx, t)],
- ty::mk_nil(ccx.tcx()));
- get_extern_fn(ccx,
- &mut *ccx.externs().borrow_mut(),
- &name[..],
- llvm::CCallConv,
- llty,
- dtor_ty)
- }
-}
-
pub fn bin_op_to_icmp_predicate(ccx: &CrateContext, op: ast::BinOp_, signed: bool)
-> llvm::IntPredicate {
match op {
}
}
+// only use this for foreign function ABIs and glue, use `get_extern_rust_fn` for Rust functions
+pub fn get_extern_fn(ccx: &CrateContext,
+ externs: &mut ExternMap,
+ name: &str,
+ cc: llvm::CallConv,
+ ty: Type,
+ output: Ty)
+ -> ValueRef {
+ match externs.get(name) {
+ Some(n) => return *n,
+ None => {}
+ }
+ let f = base::decl_fn(ccx, name, cc, ty, ty::FnConverging(output));
+ externs.insert(name.to_string(), f);
+ f
+}
+
/// Registers a foreign function found in a library. Just adds a LLVM global.
pub fn register_foreign_item_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
abi: Abi, fty: Ty<'tcx>,
// Create the LLVM value for the C extern fn
let llfn_ty = lltype_for_fn_from_foreign_types(ccx, &tys);
- let llfn = base::get_extern_fn(ccx,
- &mut *ccx.externs().borrow_mut(),
- name,
- cc,
- llfn_ty,
- fty);
+ let llfn = get_extern_fn(ccx, &mut *ccx.externs().borrow_mut(), name, cc, llfn_ty, fty);
add_argument_attributes(&tys, llfn);
llfn
use back::abi;
use back::link::*;
-use llvm::{ValueRef, get_param};
use llvm;
+use llvm::{ValueRef, get_param};
+use metadata::csearch;
use middle::lang_items::ExchangeFreeFnLangItem;
use middle::subst;
use middle::subst::{Subst, Substs};
+use middle::ty::{self, Ty};
use trans::adt;
use trans::adt::GetDtorType; // for tcx.dtor_type()
use trans::base::*;
use trans::cleanup;
use trans::cleanup::CleanupMethods;
use trans::common::*;
+use trans::consts;
use trans::datum;
use trans::debuginfo::DebugLoc;
use trans::expr;
+use trans::foreign;
+use trans::inline;
use trans::machine::*;
-use trans::type_::Type;
+use trans::monomorphize;
+use trans::tvec;
use trans::type_of::{type_of, sizing_type_of, align_of};
-use middle::ty::{self, Ty};
-use util::ppaux::{ty_to_short_str, Repr};
+use trans::type_::Type;
use util::ppaux;
+use util::ppaux::{ty_to_short_str, Repr};
use arena::TypedArena;
use libc::c_uint;
}
+pub fn get_res_dtor<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
+ did: ast::DefId,
+ t: Ty<'tcx>,
+ parent_id: ast::DefId,
+ substs: &Substs<'tcx>)
+ -> ValueRef {
+ let _icx = push_ctxt("trans_res_dtor");
+ let did = inline::maybe_instantiate_inline(ccx, did);
+
+ if !substs.types.is_empty() {
+ assert_eq!(did.krate, ast::LOCAL_CRATE);
+
+ // Since we're in trans we don't care for any region parameters
+ let substs = ccx.tcx().mk_substs(Substs::erased(substs.types.clone()));
+
+ let (val, _, _) = monomorphize::monomorphic_fn(ccx, did, substs, None);
+
+ val
+ } else if did.krate == ast::LOCAL_CRATE {
+ get_item_val(ccx, did.node)
+ } else {
+ let tcx = ccx.tcx();
+ let name = csearch::get_symbol(&ccx.sess().cstore, did);
+ let class_ty = ty::lookup_item_type(tcx, parent_id).ty.subst(tcx, substs);
+ let llty = type_of_dtor(ccx, class_ty);
+ let dtor_ty = ty::mk_ctor_fn(ccx.tcx(),
+ did,
+ &[get_drop_glue_type(ccx, t)],
+ ty::mk_nil(ccx.tcx()));
+ foreign::get_extern_fn(ccx,
+ &mut *ccx.externs().borrow_mut(),
+ &name[..],
+ llvm::CCallConv,
+ llty,
+ dtor_ty)
+ }
+}
+
fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
t: Ty<'tcx>,
v0: ValueRef,