user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

make CrateContext fields private

Browse source
This commit is contained in:
Stuart Pernsteiner 2014-09-05 09:18:53 -07:00
parent 67b97ab6d2
commit cf35cb365a
27 changed files with 542 additions and 375 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/librustc/back/link.rs
View file

@ -715,14 +715,14 @@ fn symbol_hash(tcx: &ty::ctxt,
}
fn get_symbol_hash(ccx: &CrateContext, t: ty::t) -> String {
match ccx.type_hashcodes.borrow().find(&t) {
match ccx.type_hashcodes().borrow().find(&t) {
Some(h) => return h.to_string(),
None => {}
}
let mut symbol_hasher = ccx.symbol_hasher.borrow_mut();
let hash = symbol_hash(ccx.tcx(), &mut *symbol_hasher, t, &ccx.link_meta);
ccx.type_hashcodes.borrow_mut().insert(t, hash.clone());
let mut symbol_hasher = ccx.symbol_hasher().borrow_mut();
let hash = symbol_hash(ccx.tcx(), &mut *symbol_hasher, t, ccx.link_meta());
ccx.type_hashcodes().borrow_mut().insert(t, hash.clone());
hash
}

2
src/librustc/middle/trans/_match.rs
View file

@ -563,7 +563,7 @@ fn get_branches<'a>(bcx: &'a Block, m: &[Match], col: uint) -> Vec<Opt<'a>> {
}
ast::PatIdent(..) | ast::PatEnum(..) | ast::PatStruct(..) => {
// This is either an enum variant or a variable binding.
let opt_def = ccx.tcx.def_map.borrow().find_copy(&cur.id);
let opt_def = ccx.tcx().def_map.borrow().find_copy(&cur.id);
match opt_def {
Some(def::DefVariant(enum_id, var_id, _)) => {
let variant = ty::enum_variant_with_id(ccx.tcx(), enum_id, var_id);

6
src/librustc/middle/trans/adt.rs
View file

@ -150,14 +150,14 @@ pub fn represent_node(bcx: &Block, node: ast::NodeId) -> Rc<Repr> {
/// Decides how to represent a given type.
pub fn represent_type(cx: &CrateContext, t: ty::t) -> Rc<Repr> {
debug!("Representing: {}", ty_to_string(cx.tcx(), t));
match cx.adt_reprs.borrow().find(&t) {
match cx.adt_reprs().borrow().find(&t) {
Some(repr) => return repr.clone(),
None => {}
}
let repr = Rc::new(represent_type_uncached(cx, t));
debug!("Represented as: {:?}", repr)
cx.adt_reprs.borrow_mut().insert(t, repr.clone());
cx.adt_reprs().borrow_mut().insert(t, repr.clone());
repr
}
@ -423,7 +423,7 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp
attempts = choose_shortest;
},
attr::ReprPacked => {
cx.tcx.sess.bug("range_to_inttype: found ReprPacked on an enum");
cx.tcx().sess.bug("range_to_inttype: found ReprPacked on an enum");
}
}
for &ity in attempts.iter() {

170
src/librustc/middle/trans/base.rs
View file

@ -149,7 +149,7 @@ impl<'a> StatRecorder<'a> {
} else {
0
};
let istart = ccx.stats.n_llvm_insns.get();
let istart = ccx.stats().n_llvm_insns.get();
StatRecorder {
ccx: ccx,
name: Some(name),
@ -165,13 +165,13 @@ impl<'a> Drop for StatRecorder<'a> {
if self.ccx.sess().trans_stats() {
let end = time::precise_time_ns();
let elapsed = ((end - self.start) / 1_000_000) as uint;
let iend = self.ccx.stats.n_llvm_insns.get();
self.ccx.stats.fn_stats.borrow_mut().push((self.name.take().unwrap(),
let iend = self.ccx.stats().n_llvm_insns.get();
self.ccx.stats().fn_stats.borrow_mut().push((self.name.take().unwrap(),
elapsed,
iend - self.istart));
self.ccx.stats.n_fns.set(self.ccx.stats.n_fns.get() + 1);
self.ccx.stats().n_fns.set(self.ccx.stats().n_fns.get() + 1);
// Reset LLVM insn count to avoid compound costs.
self.ccx.stats.n_llvm_insns.set(self.istart);
self.ccx.stats().n_llvm_insns.set(self.istart);
}
}
}
@ -182,7 +182,7 @@ pub fn decl_fn(ccx: &CrateContext, name: &str, cc: llvm::CallConv,
let llfn: ValueRef = name.with_c_str(|buf| {
unsafe {
llvm::LLVMGetOrInsertFunction(ccx.llmod, buf, ty.to_ref())
llvm::LLVMGetOrInsertFunction(ccx.llmod(), buf, ty.to_ref())
}
});
@ -198,7 +198,7 @@ pub fn decl_fn(ccx: &CrateContext, name: &str, cc: llvm::CallConv,
_ => {}
}
if ccx.tcx.sess.opts.cg.no_redzone {
if ccx.tcx().sess.opts.cg.no_redzone {
unsafe {
llvm::LLVMAddFunctionAttribute(llfn,
llvm::FunctionIndex as c_uint,
@ -243,7 +243,7 @@ pub fn get_extern_fn(ccx: &CrateContext,
}
fn get_extern_rust_fn(ccx: &CrateContext, fn_ty: ty::t, name: &str, did: ast::DefId) -> ValueRef {
match ccx.externs.borrow().find_equiv(&name) {
match ccx.externs().borrow().find_equiv(&name) {
Some(n) => return *n,
None => ()
}
@ -254,7 +254,7 @@ fn get_extern_rust_fn(ccx: &CrateContext, fn_ty: ty::t, name: &str, did: ast::De
set_llvm_fn_attrs(attrs.as_slice(), f)
});
ccx.externs.borrow_mut().insert(name.to_string(), f);
ccx.externs().borrow_mut().insert(name.to_string(), f);
f
}
@ -264,14 +264,14 @@ pub fn self_type_for_unboxed_closure(ccx: &CrateContext,
let unboxed_closure_type = ty::mk_unboxed_closure(ccx.tcx(),
closure_id,
ty::ReStatic);
let unboxed_closures = ccx.tcx.unboxed_closures.borrow();
let unboxed_closures = ccx.tcx().unboxed_closures.borrow();
let unboxed_closure = unboxed_closures.get(&closure_id);
match unboxed_closure.kind {
ty::FnUnboxedClosureKind => {
ty::mk_imm_rptr(&ccx.tcx, ty::ReStatic, unboxed_closure_type)
ty::mk_imm_rptr(ccx.tcx(), ty::ReStatic, unboxed_closure_type)
}
ty::FnMutUnboxedClosureKind => {
ty::mk_mut_rptr(&ccx.tcx, ty::ReStatic, unboxed_closure_type)
ty::mk_mut_rptr(ccx.tcx(), ty::ReStatic, unboxed_closure_type)
}
ty::FnOnceUnboxedClosureKind => unboxed_closure_type,
}
@ -279,7 +279,7 @@ pub fn self_type_for_unboxed_closure(ccx: &CrateContext,
pub fn kind_for_unboxed_closure(ccx: &CrateContext, closure_id: ast::DefId)
-> ty::UnboxedClosureKind {
let unboxed_closures = ccx.tcx.unboxed_closures.borrow();
let unboxed_closures = ccx.tcx().unboxed_closures.borrow();
unboxed_closures.get(&closure_id).kind
}
@ -292,7 +292,7 @@ pub fn decl_rust_fn(ccx: &CrateContext, fn_ty: ty::t, name: &str) -> ValueRef {
(f.sig.inputs.clone(), f.sig.output, f.abi, Some(Type::i8p(ccx)))
}
ty::ty_unboxed_closure(closure_did, _) => {
let unboxed_closures = ccx.tcx.unboxed_closures.borrow();
let unboxed_closures = ccx.tcx().unboxed_closures.borrow();
let unboxed_closure = unboxed_closures.get(&closure_did);
let function_type = unboxed_closure.closure_type.clone();
let self_type = self_type_for_unboxed_closure(ccx, closure_did);
@ -308,7 +308,7 @@ pub fn decl_rust_fn(ccx: &CrateContext, fn_ty: ty::t, name: &str) -> ValueRef {
let llfty = type_of_rust_fn(ccx, env, inputs.as_slice(), output, abi);
debug!("decl_rust_fn(input count={},type={})",
inputs.len(),
ccx.tn.type_to_string(llfty));
ccx.tn().type_to_string(llfty));
let llfn = decl_fn(ccx, name, llvm::CCallConv, llfty, output);
let attrs = get_fn_llvm_attributes(ccx, fn_ty);
@ -413,15 +413,15 @@ pub fn malloc_raw_dyn_managed<'a>(
// Type descriptor and type glue stuff
pub fn get_tydesc(ccx: &CrateContext, t: ty::t) -> Rc<tydesc_info> {
match ccx.tydescs.borrow().find(&t) {
match ccx.tydescs().borrow().find(&t) {
Some(inf) => return inf.clone(),
_ => { }
}
ccx.stats.n_static_tydescs.set(ccx.stats.n_static_tydescs.get() + 1u);
ccx.stats().n_static_tydescs.set(ccx.stats().n_static_tydescs.get() + 1u);
let inf = Rc::new(glue::declare_tydesc(ccx, t));
ccx.tydescs.borrow_mut().insert(t, inf.clone());
ccx.tydescs().borrow_mut().insert(t, inf.clone());
inf
}
@ -492,10 +492,10 @@ pub fn unset_split_stack(f: ValueRef) {
// Double-check that we never ask LLVM to declare the same symbol twice. It
// silently mangles such symbols, breaking our linkage model.
pub fn note_unique_llvm_symbol(ccx: &CrateContext, sym: String) {
if ccx.all_llvm_symbols.borrow().contains(&sym) {
if ccx.all_llvm_symbols().borrow().contains(&sym) {
ccx.sess().bug(format!("duplicate LLVM symbol: {}", sym).as_slice());
}
ccx.all_llvm_symbols.borrow_mut().insert(sym);
ccx.all_llvm_symbols().borrow_mut().insert(sym);
}
@ -532,7 +532,7 @@ pub fn get_res_dtor(ccx: &CrateContext,
let dtor_ty = ty::mk_ctor_fn(ccx.tcx(), ast::DUMMY_NODE_ID,
[glue::get_drop_glue_type(ccx, t)], ty::mk_nil());
get_extern_fn(ccx,
&mut *ccx.externs.borrow_mut(),
&mut *ccx.externs().borrow_mut(),
name.as_slice(),
llvm::CCallConv,
llty,
@ -961,8 +961,8 @@ pub fn trans_external_path(ccx: &CrateContext, did: ast::DefId, t: ty::t) -> Val
}
_ => {
let llty = type_of(ccx, t);
get_extern_const(&mut *ccx.externs.borrow_mut(),
ccx.llmod,
get_extern_const(&mut *ccx.externs().borrow_mut(),
ccx.llmod(),
name.as_slice(),
llty)
}
@ -1165,7 +1165,7 @@ pub fn call_memcpy(cx: &Block, dst: ValueRef, src: ValueRef, n_bytes: ValueRef,
let memcpy = ccx.get_intrinsic(&key);
let src_ptr = PointerCast(cx, src, Type::i8p(ccx));
let dst_ptr = PointerCast(cx, dst, Type::i8p(ccx));
let size = IntCast(cx, n_bytes, ccx.int_type);
let size = IntCast(cx, n_bytes, ccx.int_type());
let align = C_i32(ccx, align as i32);
let volatile = C_bool(ccx, false);
Call(cx, memcpy, [dst_ptr, src_ptr, size, align, volatile], None);
@ -1426,7 +1426,7 @@ pub fn new_fn_ctxt<'a>(ccx: &'a CrateContext,
if id == -1 {
"".to_string()
} else {
ccx.tcx.map.path_to_string(id).to_string()
ccx.tcx().map.path_to_string(id).to_string()
},
id, param_substs.repr(ccx.tcx()));
@ -1786,7 +1786,7 @@ pub fn trans_closure(ccx: &CrateContext,
is_unboxed_closure: IsUnboxedClosureFlag,
maybe_load_env: <'a>|&'a Block<'a>, ScopeId|
-> &'a Block<'a>) {
ccx.stats.n_closures.set(ccx.stats.n_closures.get() + 1);
ccx.stats().n_closures.set(ccx.stats().n_closures.get() + 1);
let _icx = push_ctxt("trans_closure");
set_uwtable(llfndecl);
@ -1820,7 +1820,7 @@ pub fn trans_closure(ccx: &CrateContext,
ty_to_string(ccx.tcx(), *monomorphized_arg_type));
}
debug!("trans_closure: function lltype: {}",
bcx.fcx.ccx.tn.val_to_string(bcx.fcx.llfn));
bcx.fcx.ccx.tn().val_to_string(bcx.fcx.llfn));
let arg_datums = if abi != RustCall {
create_datums_for_fn_args(&fcx,
@ -1912,7 +1912,7 @@ pub fn trans_fn(ccx: &CrateContext,
param_substs: &param_substs,
id: ast::NodeId,
attrs: &[ast::Attribute]) {
let _s = StatRecorder::new(ccx, ccx.tcx.map.path_to_string(id).to_string());
let _s = StatRecorder::new(ccx, ccx.tcx().map.path_to_string(id).to_string());
debug!("trans_fn(param_substs={})", param_substs.repr(ccx.tcx()));
let _icx = push_ctxt("trans_fn");
let fn_ty = ty::node_id_to_type(ccx.tcx(), id);
@ -1958,7 +1958,7 @@ pub fn trans_named_tuple_constructor<'a>(mut bcx: &'a Block<'a>,
dest: expr::Dest) -> Result<'a> {
let ccx = bcx.fcx.ccx;
let tcx = &ccx.tcx;
let tcx = ccx.tcx();
let result_ty = match ty::get(ctor_ty).sty {
ty::ty_bare_fn(ref bft) => bft.sig.output,
@ -2064,7 +2064,7 @@ fn trans_enum_variant_or_tuple_like_struct(ccx: &CrateContext,
fn enum_variant_size_lint(ccx: &CrateContext, enum_def: &ast::EnumDef, sp: Span, id: ast::NodeId) {
let mut sizes = Vec::new(); // does no allocation if no pushes, thankfully
let levels = ccx.tcx.node_lint_levels.borrow();
let levels = ccx.tcx().node_lint_levels.borrow();
let lint_id = lint::LintId::of(lint::builtin::VARIANT_SIZE_DIFFERENCE);
let lvlsrc = match levels.find(&(id, lint_id)) {
None | Some(&(lint::Allow, _)) => return,
@ -2181,7 +2181,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
static");
}
let v = ccx.const_values.borrow().get_copy(&item.id);
let v = ccx.const_values().borrow().get_copy(&item.id);
unsafe {
if !(llvm::LLVMConstIntGetZExtValue(v) != 0) {
ccx.sess().span_fatal(expr.span, "static assertion failed");
@ -2218,9 +2218,9 @@ pub fn trans_mod(ccx: &CrateContext, m: &ast::Mod) {
fn finish_register_fn(ccx: &CrateContext, sp: Span, sym: String, node_id: ast::NodeId,
llfn: ValueRef) {
ccx.item_symbols.borrow_mut().insert(node_id, sym);
ccx.item_symbols().borrow_mut().insert(node_id, sym);
if !ccx.reachable.contains(&node_id) {
if !ccx.reachable().contains(&node_id) {
llvm::SetLinkage(llfn, llvm::InternalLinkage);
}
@ -2228,11 +2228,11 @@ fn finish_register_fn(ccx: &CrateContext, sp: Span, sym: String, node_id: ast::N
// otherwise it would continue to be exhausted (bad), and both it and the
// eh_personality functions need to be externally linkable.
let def = ast_util::local_def(node_id);
if ccx.tcx.lang_items.stack_exhausted() == Some(def) {
if ccx.tcx().lang_items.stack_exhausted() == Some(def) {
unset_split_stack(llfn);
llvm::SetLinkage(llfn, llvm::ExternalLinkage);
}
if ccx.tcx.lang_items.eh_personality() == Some(def) {
if ccx.tcx().lang_items.eh_personality() == Some(def) {
llvm::SetLinkage(llfn, llvm::ExternalLinkage);
}
@ -2268,7 +2268,7 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t)
ty::ty_closure(ref f) => (f.sig.clone(), f.abi, true),
ty::ty_bare_fn(ref f) => (f.sig.clone(), f.abi, false),
ty::ty_unboxed_closure(closure_did, _) => {
let unboxed_closures = ccx.tcx.unboxed_closures.borrow();
let unboxed_closures = ccx.tcx().unboxed_closures.borrow();
let ref function_type = unboxed_closures.get(&closure_did)
.closure_type;
@ -2485,8 +2485,8 @@ pub fn create_entry_wrapper(ccx: &CrateContext,
fn create_entry_fn(ccx: &CrateContext,
rust_main: ValueRef,
use_start_lang_item: bool) {
let llfty = Type::func([ccx.int_type, Type::i8p(ccx).ptr_to()],
&ccx.int_type);
let llfty = Type::func([ccx.int_type(), Type::i8p(ccx).ptr_to()],
&ccx.int_type());
let llfn = decl_cdecl_fn(ccx, "main", llfty, ty::mk_nil());
@ -2498,15 +2498,15 @@ pub fn create_entry_wrapper(ccx: &CrateContext,
let llbb = "top".with_c_str(|buf| {
unsafe {
llvm::LLVMAppendBasicBlockInContext(ccx.llcx, llfn, buf)
llvm::LLVMAppendBasicBlockInContext(ccx.llcx(), llfn, buf)
}
});
let bld = ccx.builder.b;
let bld = ccx.raw_builder();
unsafe {
llvm::LLVMPositionBuilderAtEnd(bld, llbb);
let (start_fn, args) = if use_start_lang_item {
let start_def_id = match ccx.tcx.lang_items.require(StartFnLangItem) {
let start_def_id = match ccx.tcx().lang_items.require(StartFnLangItem) {
Ok(id) => id,
Err(s) => { ccx.sess().fatal(s.as_slice()); }
};
@ -2557,7 +2557,7 @@ fn exported_name(ccx: &CrateContext, id: ast::NodeId,
// Use provided name
Some(name) => name.get().to_string(),
_ => ccx.tcx.map.with_path(id, |mut path| {
_ => ccx.tcx().map.with_path(id, |mut path| {
if attr::contains_name(attrs, "no_mangle") {
// Don't mangle
path.last().unwrap().to_string()
@ -2577,13 +2577,13 @@ fn exported_name(ccx: &CrateContext, id: ast::NodeId,
pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
debug!("get_item_val(id=`{:?}`)", id);
match ccx.item_vals.borrow().find_copy(&id) {
match ccx.item_vals().borrow().find_copy(&id) {
Some(v) => return v,
None => {}
}
let mut foreign = false;
let item = ccx.tcx.map.get(id);
let item = ccx.tcx().map.get(id);
let val = match item {
ast_map::NodeItem(i) => {
let ty = ty::node_id_to_type(ccx.tcx(), i.id);
@ -2597,7 +2597,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
// information in the hash of the symbol
debug!("making {}", sym);
let (sym, is_local) = {
match ccx.external_srcs.borrow().find(&i.id) {
match ccx.external_srcs().borrow().find(&i.id) {
Some(&did) => {
debug!("but found in other crate...");
(csearch::get_symbol(&ccx.sess().cstore,
@ -2610,16 +2610,16 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
// We need the translated value here, because for enums the
// LLVM type is not fully determined by the Rust type.
let (v, inlineable, _) = consts::const_expr(ccx, &**expr, is_local);
ccx.const_values.borrow_mut().insert(id, v);
ccx.const_values().borrow_mut().insert(id, v);
let mut inlineable = inlineable;
unsafe {
let llty = llvm::LLVMTypeOf(v);
let g = sym.as_slice().with_c_str(|buf| {
llvm::LLVMAddGlobal(ccx.llmod, llty, buf)
llvm::LLVMAddGlobal(ccx.llmod(), llty, buf)
});
if !ccx.reachable.contains(&id) {
if !ccx.reachable().contains(&id) {
llvm::SetLinkage(g, llvm::InternalLinkage);
}
@ -2655,11 +2655,11 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
if !inlineable {
debug!("{} not inlined", sym);
ccx.non_inlineable_statics.borrow_mut()
ccx.non_inlineable_statics().borrow_mut()
.insert(id);
}
ccx.item_symbols.borrow_mut().insert(i.id, sym);
ccx.item_symbols().borrow_mut().insert(i.id, sym);
g
}
}
@ -2717,7 +2717,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
match ni.node {
ast::ForeignItemFn(..) => {
let abi = ccx.tcx.map.get_foreign_abi(id);
let abi = ccx.tcx().map.get_foreign_abi(id);
let ty = ty::node_id_to_type(ccx.tcx(), ni.id);
let name = foreign::link_name(&*ni);
foreign::register_foreign_item_fn(ccx, abi, ty,
@ -2740,8 +2740,8 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
};
assert!(args.len() != 0u);
let ty = ty::node_id_to_type(ccx.tcx(), id);
let parent = ccx.tcx.map.get_parent(id);
let enm = ccx.tcx.map.expect_item(parent);
let parent = ccx.tcx().map.get_parent(id);
let enm = ccx.tcx().map.expect_item(parent);
let sym = exported_name(ccx,
id,
ty,
@ -2766,8 +2766,8 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
}
Some(ctor_id) => ctor_id,
};
let parent = ccx.tcx.map.get_parent(id);
let struct_item = ccx.tcx.map.expect_item(parent);
let parent = ccx.tcx().map.get_parent(id);
let struct_item = ccx.tcx().map.expect_item(parent);
let ty = ty::node_id_to_type(ccx.tcx(), ctor_id);
let sym = exported_name(ccx,
id,
@ -2789,11 +2789,11 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
// foreign items (extern fns and extern statics) don't have internal
// linkage b/c that doesn't quite make sense. Otherwise items can
// have internal linkage if they're not reachable.
if !foreign && !ccx.reachable.contains(&id) {
if !foreign && !ccx.reachable().contains(&id) {
llvm::SetLinkage(val, llvm::InternalLinkage);
}
ccx.item_vals.borrow_mut().insert(id, val);
ccx.item_vals().borrow_mut().insert(id, val);
val
}
@ -2810,7 +2810,7 @@ fn register_method(ccx: &CrateContext, id: ast::NodeId,
pub fn p2i(ccx: &CrateContext, v: ValueRef) -> ValueRef {
unsafe {
return llvm::LLVMConstPtrToInt(v, ccx.int_type.to_ref());
return llvm::LLVMConstPtrToInt(v, ccx.int_type().to_ref());
}
}
@ -2819,13 +2819,13 @@ pub fn crate_ctxt_to_encode_parms<'r>(cx: &'r CrateContext, ie: encoder::EncodeI
encoder::EncodeParams {
diag: cx.sess().diagnostic(),
tcx: cx.tcx(),
reexports2: &cx.exp_map2,
item_symbols: &cx.item_symbols,
non_inlineable_statics: &cx.non_inlineable_statics,
link_meta: &cx.link_meta,
reexports2: cx.exp_map2(),
item_symbols: cx.item_symbols(),
non_inlineable_statics: cx.non_inlineable_statics(),
link_meta: cx.link_meta(),
cstore: &cx.sess().cstore,
encode_inlined_item: ie,
reachable: &cx.reachable,
reachable: cx.reachable(),
}
}
@ -2854,11 +2854,11 @@ pub fn write_metadata(cx: &CrateContext, krate: &ast::Crate) -> Vec<u8> {
let llmeta = C_bytes(cx, compressed.as_slice());
let llconst = C_struct(cx, [llmeta], false);
let name = format!("rust_metadata_{}_{}",
cx.link_meta.crate_name,
cx.link_meta.crate_hash);
cx.link_meta().crate_name,
cx.link_meta().crate_hash);
let llglobal = name.with_c_str(|buf| {
unsafe {
llvm::LLVMAddGlobal(cx.metadata_llmod, val_ty(llconst).to_ref(), buf)
llvm::LLVMAddGlobal(cx.metadata_llmod(), val_ty(llconst).to_ref(), buf)
}
});
unsafe {
@ -2927,20 +2927,20 @@ pub fn trans_crate(krate: ast::Crate,
let metadata = write_metadata(&ccx, &krate);
if ccx.sess().trans_stats() {
println!("--- trans stats ---");
println!("n_static_tydescs: {}", ccx.stats.n_static_tydescs.get());
println!("n_glues_created: {}", ccx.stats.n_glues_created.get());
println!("n_null_glues: {}", ccx.stats.n_null_glues.get());
println!("n_real_glues: {}", ccx.stats.n_real_glues.get());
println!("n_static_tydescs: {}", ccx.stats().n_static_tydescs.get());
println!("n_glues_created: {}", ccx.stats().n_glues_created.get());
println!("n_null_glues: {}", ccx.stats().n_null_glues.get());
println!("n_real_glues: {}", ccx.stats().n_real_glues.get());
println!("n_fns: {}", ccx.stats.n_fns.get());
println!("n_monos: {}", ccx.stats.n_monos.get());
println!("n_inlines: {}", ccx.stats.n_inlines.get());
println!("n_closures: {}", ccx.stats.n_closures.get());
println!("n_fns: {}", ccx.stats().n_fns.get());
println!("n_monos: {}", ccx.stats().n_monos.get());
println!("n_inlines: {}", ccx.stats().n_inlines.get());
println!("n_closures: {}", ccx.stats().n_closures.get());
println!("fn stats:");
ccx.stats.fn_stats.borrow_mut().sort_by(|&(_, _, insns_a), &(_, _, insns_b)| {
ccx.stats().fn_stats.borrow_mut().sort_by(|&(_, _, insns_a), &(_, _, insns_b)| {
insns_b.cmp(&insns_a)
});
for tuple in ccx.stats.fn_stats.borrow().iter() {
for tuple in ccx.stats().fn_stats.borrow().iter() {
match *tuple {
(ref name, ms, insns) => {
println!("{} insns, {} ms, {}", insns, ms, *name);
@ -2949,17 +2949,17 @@ pub fn trans_crate(krate: ast::Crate,
}
}
if ccx.sess().count_llvm_insns() {
for (k, v) in ccx.stats.llvm_insns.borrow().iter() {
for (k, v) in ccx.stats().llvm_insns.borrow().iter() {
println!("{:7u} {}", *v, *k);
}
}
let llcx = ccx.llcx;
let link_meta = ccx.link_meta.clone();
let llmod = ccx.llmod;
let llcx = ccx.llcx();
let link_meta = ccx.link_meta().clone();
let llmod = ccx.llmod();
let mut reachable: Vec<String> = ccx.reachable.iter().filter_map(|id| {
ccx.item_symbols.borrow().find(id).map(|s| s.to_string())
let mut reachable: Vec<String> = ccx.reachable().iter().filter_map(|id| {
ccx.item_symbols().borrow().find(id).map(|s| s.to_string())
}).collect();
// For the purposes of LTO, we add to the reachable set all of the upstream
@ -2986,11 +2986,11 @@ pub fn trans_crate(krate: ast::Crate,
// referenced from rt/rust_try.ll
reachable.push("rust_eh_personality_catch".to_string());
let metadata_module = ccx.metadata_llmod;
let formats = ccx.tcx.dependency_formats.borrow().clone();
let metadata_module = ccx.metadata_llmod();
let formats = ccx.tcx().dependency_formats.borrow().clone();
let no_builtins = attr::contains_name(krate.attrs.as_slice(), "no_builtins");
(ccx.tcx, CrateTranslation {
(ccx.take_tcx(), CrateTranslation {
context: llcx,
module: llmod,
link: link_meta,

10
src/librustc/middle/trans/build.rs
View file

@ -352,7 +352,7 @@ pub fn Load(cx: &Block, pointer_val: ValueRef) -> ValueRef {
let eltty = if ty.kind() == llvm::Array {
ty.element_type()
} else {
ccx.int_type
ccx.int_type()
};
return llvm::LLVMGetUndef(eltty.to_ref());
}
@ -373,7 +373,7 @@ pub fn AtomicLoad(cx: &Block, pointer_val: ValueRef, order: AtomicOrdering) -> V
unsafe {
let ccx = cx.fcx.ccx;
if cx.unreachable.get() {
return llvm::LLVMGetUndef(ccx.int_type.to_ref());
return llvm::LLVMGetUndef(ccx.int_type().to_ref());
}
B(cx).atomic_load(pointer_val, order)
}
@ -388,7 +388,7 @@ pub fn LoadRangeAssert(cx: &Block, pointer_val: ValueRef, lo: c_ulonglong,
let eltty = if ty.kind() == llvm::Array {
ty.element_type()
} else {
ccx.int_type
ccx.int_type()
};
unsafe {
llvm::LLVMGetUndef(eltty.to_ref())
@ -658,7 +658,7 @@ pub fn _UndefReturn(cx: &Block, fn_: ValueRef) -> ValueRef {
let retty = if ty.kind() == llvm::Integer {
ty.return_type()
} else {
ccx.int_type
ccx.int_type()
};
B(cx).count_insn("ret_undef");
llvm::LLVMGetUndef(retty.to_ref())
@ -786,7 +786,7 @@ pub fn IsNotNull(cx: &Block, val: ValueRef) -> ValueRef {
pub fn PtrDiff(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
unsafe {
let ccx = cx.fcx.ccx;
if cx.unreachable.get() { return llvm::LLVMGetUndef(ccx.int_type.to_ref()); }
if cx.unreachable.get() { return llvm::LLVMGetUndef(ccx.int_type().to_ref()); }
B(cx).ptrdiff(lhs, rhs)
}
}

34
src/librustc/middle/trans/builder.rs
View file

@ -38,21 +38,21 @@ pub fn noname() -> *const c_char {
impl<'a> Builder<'a> {
pub fn new(ccx: &'a CrateContext) -> Builder<'a> {
Builder {
llbuilder: ccx.builder.b,
llbuilder: ccx.raw_builder(),
ccx: ccx,
}
}
pub fn count_insn(&self, category: &str) {
if self.ccx.sess().trans_stats() {
self.ccx.stats.n_llvm_insns.set(self.ccx
.stats
self.ccx.stats().n_llvm_insns.set(self.ccx
.stats()
.n_llvm_insns
.get() + 1);
}
if self.ccx.sess().count_llvm_insns() {
base::with_insn_ctxt(|v| {
let mut h = self.ccx.stats.llvm_insns.borrow_mut();
let mut h = self.ccx.stats().llvm_insns.borrow_mut();
// Build version of path with cycles removed.
@ -160,9 +160,9 @@ impl<'a> Builder<'a> {
self.count_insn("invoke");
debug!("Invoke {} with args ({})",
self.ccx.tn.val_to_string(llfn),
self.ccx.tn().val_to_string(llfn),
args.iter()
.map(|&v| self.ccx.tn.val_to_string(v))
.map(|&v| self.ccx.tn().val_to_string(v))
.collect::<Vec<String>>()
.connect(", "));
@ -488,7 +488,7 @@ impl<'a> Builder<'a> {
let v = [min, max];
llvm::LLVMSetMetadata(value, llvm::MD_range as c_uint,
llvm::LLVMMDNodeInContext(self.ccx.llcx,
llvm::LLVMMDNodeInContext(self.ccx.llcx(),
v.as_ptr(), v.len() as c_uint));
}
@ -497,8 +497,8 @@ impl<'a> Builder<'a> {
pub fn store(&self, val: ValueRef, ptr: ValueRef) {
debug!("Store {} -> {}",
self.ccx.tn.val_to_string(val),
self.ccx.tn.val_to_string(ptr));
self.ccx.tn().val_to_string(val),
self.ccx.tn().val_to_string(ptr));
assert!(self.llbuilder.is_not_null());
self.count_insn("store");
unsafe {
@ -508,8 +508,8 @@ impl<'a> Builder<'a> {
pub fn volatile_store(&self, val: ValueRef, ptr: ValueRef) {
debug!("Store {} -> {}",
self.ccx.tn.val_to_string(val),
self.ccx.tn.val_to_string(ptr));
self.ccx.tn().val_to_string(val),
self.ccx.tn().val_to_string(ptr));
assert!(self.llbuilder.is_not_null());
self.count_insn("store.volatile");
unsafe {
@ -520,8 +520,8 @@ impl<'a> Builder<'a> {
pub fn atomic_store(&self, val: ValueRef, ptr: ValueRef, order: AtomicOrdering) {
debug!("Store {} -> {}",
self.ccx.tn.val_to_string(val),
self.ccx.tn.val_to_string(ptr));
self.ccx.tn().val_to_string(val),
self.ccx.tn().val_to_string(ptr));
self.count_insn("store.atomic");
unsafe {
let ty = Type::from_ref(llvm::LLVMTypeOf(ptr));
@ -794,11 +794,11 @@ impl<'a> Builder<'a> {
else { llvm::False };
let argtys = inputs.iter().map(|v| {
debug!("Asm Input Type: {:?}", self.ccx.tn.val_to_string(*v));
debug!("Asm Input Type: {:?}", self.ccx.tn().val_to_string(*v));
val_ty(*v)
}).collect::<Vec<_>>();
debug!("Asm Output Type: {:?}", self.ccx.tn.type_to_string(output));
debug!("Asm Output Type: {:?}", self.ccx.tn().type_to_string(output));
let fty = Type::func(argtys.as_slice(), &output);
unsafe {
let v = llvm::LLVMInlineAsm(
@ -812,9 +812,9 @@ impl<'a> Builder<'a> {
self.count_insn("call");
debug!("Call {} with args ({})",
self.ccx.tn.val_to_string(llfn),
self.ccx.tn().val_to_string(llfn),
args.iter()
.map(|&v| self.ccx.tn.val_to_string(v))
.map(|&v| self.ccx.tn().val_to_string(v))
.collect::<Vec<String>>()
.connect(", "));

2
src/librustc/middle/trans/cabi_mips.rs
View file

@ -146,7 +146,7 @@ fn coerce_to_int(ccx: &CrateContext, size: uint) -> Vec<Type> {
let r = size % 32;
if r > 0 {
unsafe {
args.push(Type::from_ref(llvm::LLVMIntTypeInContext(ccx.llcx, r as c_uint)));
args.push(Type::from_ref(llvm::LLVMIntTypeInContext(ccx.llcx(), r as c_uint)));
}
}

24
src/librustc/middle/trans/cleanup.rs
View file

@ -87,7 +87,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
*/
debug!("push_ast_cleanup_scope({})",
self.ccx.tcx.map.node_to_string(id));
self.ccx.tcx().map.node_to_string(id));
// FIXME(#2202) -- currently closure bodies have a parent
// region, which messes up the assertion below, since there
@ -101,7 +101,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
// this new AST scope had better be its immediate child.
let top_scope = self.top_ast_scope();
if top_scope.is_some() {
assert_eq!(self.ccx.tcx.region_maps.opt_encl_scope(id), top_scope);
assert_eq!(self.ccx.tcx().region_maps.opt_encl_scope(id), top_scope);
}
self.push_scope(CleanupScope::new(AstScopeKind(id)));
@ -111,7 +111,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
id: ast::NodeId,
exits: [&'a Block<'a>, ..EXIT_MAX]) {
debug!("push_loop_cleanup_scope({})",
self.ccx.tcx.map.node_to_string(id));
self.ccx.tcx().map.node_to_string(id));
assert_eq!(Some(id), self.top_ast_scope());
self.push_scope(CleanupScope::new(LoopScopeKind(id, exits)));
@ -135,7 +135,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
*/
debug!("pop_and_trans_ast_cleanup_scope({})",
self.ccx.tcx.map.node_to_string(cleanup_scope));
self.ccx.tcx().map.node_to_string(cleanup_scope));
assert!(self.top_scope(|s| s.kind.is_ast_with_id(cleanup_scope)));
@ -154,7 +154,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
*/
debug!("pop_loop_cleanup_scope({})",
self.ccx.tcx.map.node_to_string(cleanup_scope));
self.ccx.tcx().map.node_to_string(cleanup_scope));
assert!(self.top_scope(|s| s.kind.is_loop_with_id(cleanup_scope)));
@ -237,7 +237,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
debug!("schedule_lifetime_end({:?}, val={})",
cleanup_scope,
self.ccx.tn.val_to_string(val));
self.ccx.tn().val_to_string(val));
self.schedule_clean(cleanup_scope, drop as CleanupObj);
}
@ -262,7 +262,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
debug!("schedule_drop_mem({:?}, val={}, ty={})",
cleanup_scope,
self.ccx.tn.val_to_string(val),
self.ccx.tn().val_to_string(val),
ty.repr(self.ccx.tcx()));
self.schedule_clean(cleanup_scope, drop as CleanupObj);
@ -288,7 +288,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
debug!("schedule_drop_and_zero_mem({:?}, val={}, ty={}, zero={})",
cleanup_scope,
self.ccx.tn.val_to_string(val),
self.ccx.tn().val_to_string(val),
ty.repr(self.ccx.tcx()),
true);
@ -314,7 +314,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
debug!("schedule_drop_immediate({:?}, val={}, ty={})",
cleanup_scope,
self.ccx.tn.val_to_string(val),
self.ccx.tn().val_to_string(val),
ty.repr(self.ccx.tcx()));
self.schedule_clean(cleanup_scope, drop as CleanupObj);
@ -334,7 +334,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
debug!("schedule_free_value({:?}, val={}, heap={:?})",
cleanup_scope,
self.ccx.tn.val_to_string(val),
self.ccx.tn().val_to_string(val),
heap);
self.schedule_clean(cleanup_scope, drop as CleanupObj);
@ -374,7 +374,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> {
self.ccx.sess().bug(
format!("no cleanup scope {} found",
self.ccx.tcx.map.node_to_string(cleanup_scope)).as_slice());
self.ccx.tcx().map.node_to_string(cleanup_scope)).as_slice());
}
fn schedule_clean_in_custom_scope(&self,
@ -720,7 +720,7 @@ impl<'a> CleanupHelperMethods<'a> for FunctionContext<'a> {
let llpersonality = match pad_bcx.tcx().lang_items.eh_personality() {
Some(def_id) => callee::trans_fn_ref(pad_bcx, def_id, ExprId(0)),
None => {
let mut personality = self.ccx.eh_personality.borrow_mut();
let mut personality = self.ccx.eh_personality().borrow_mut();
match *personality {
Some(llpersonality) => llpersonality,
None => {

16
src/librustc/middle/trans/closure.rs
View file

@ -427,12 +427,12 @@ pub fn trans_expr_fn<'a>(
pub fn get_or_create_declaration_if_unboxed_closure(ccx: &CrateContext,
closure_id: ast::DefId)
-> Option<ValueRef> {
if !ccx.tcx.unboxed_closures.borrow().contains_key(&closure_id) {
if !ccx.tcx().unboxed_closures.borrow().contains_key(&closure_id) {
// Not an unboxed closure.
return None
}
match ccx.unboxed_closure_vals.borrow().find(&closure_id) {
match ccx.unboxed_closure_vals().borrow().find(&closure_id) {
Some(llfn) => {
debug!("get_or_create_declaration_if_unboxed_closure(): found \
closure");
@ -441,10 +441,10 @@ pub fn get_or_create_declaration_if_unboxed_closure(ccx: &CrateContext,
None => {}
}
let function_type = ty::mk_unboxed_closure(&ccx.tcx,
let function_type = ty::mk_unboxed_closure(ccx.tcx(),
closure_id,
ty::ReStatic);
let symbol = ccx.tcx.map.with_path(closure_id.node, |path| {
let symbol = ccx.tcx().map.with_path(closure_id.node, |path| {
mangle_internal_name_by_path_and_seq(path, "unboxed_closure")
});
@ -456,8 +456,8 @@ pub fn get_or_create_declaration_if_unboxed_closure(ccx: &CrateContext,
debug!("get_or_create_declaration_if_unboxed_closure(): inserting new \
closure {} (type {})",
closure_id,
ccx.tn.type_to_string(val_ty(llfn)));
ccx.unboxed_closure_vals.borrow_mut().insert(closure_id, llfn);
ccx.tn().type_to_string(val_ty(llfn)));
ccx.unboxed_closure_vals().borrow_mut().insert(closure_id, llfn);
Some(llfn)
}
@ -554,7 +554,7 @@ pub fn get_wrapper_for_bare_fn(ccx: &CrateContext,
}
};
match ccx.closure_bare_wrapper_cache.borrow().find(&fn_ptr) {
match ccx.closure_bare_wrapper_cache().borrow().find(&fn_ptr) {
Some(&llval) => return llval,
None => {}
}
@ -581,7 +581,7 @@ pub fn get_wrapper_for_bare_fn(ccx: &CrateContext,
decl_rust_fn(ccx, closure_ty, name.as_slice())
};
ccx.closure_bare_wrapper_cache.borrow_mut().insert(fn_ptr, llfn);
ccx.closure_bare_wrapper_cache().borrow_mut().insert(fn_ptr, llfn);
// This is only used by statics inlined from a different crate.
if !is_local {

34
src/librustc/middle/trans/common.rs
View file

@ -82,7 +82,7 @@ pub fn type_is_immediate(ccx: &CrateContext, ty: ty::t) -> bool {
ty::ty_struct(..) | ty::ty_enum(..) | ty::ty_tup(..) |
ty::ty_unboxed_closure(..) => {
let llty = sizing_type_of(ccx, ty);
llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type)
llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type())
}
_ => type_is_zero_size(ccx, ty)
}
@ -342,7 +342,7 @@ impl<'a> FunctionContext<'a> {
self.llreturn.set(Some(unsafe {
"return".with_c_str(|buf| {
llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx, self.llfn, buf)
llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(), self.llfn, buf)
})
}))
}
@ -365,7 +365,7 @@ impl<'a> FunctionContext<'a> {
-> &'a Block<'a> {
unsafe {
let llbb = name.with_c_str(|buf| {
llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx,
llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(),
self.llfn,
buf)
});
@ -451,7 +451,7 @@ impl<'a> Block<'a> {
pub fn ccx(&self) -> &'a CrateContext { self.fcx.ccx }
pub fn tcx(&self) -> &'a ty::ctxt {
&self.fcx.ccx.tcx
self.fcx.ccx.tcx()
}
pub fn sess(&self) -> &'a Session { self.fcx.ccx.sess() }
@ -478,11 +478,11 @@ impl<'a> Block<'a> {
}
pub fn val_to_string(&self, val: ValueRef) -> String {
self.ccx().tn.val_to_string(val)
self.ccx().tn().val_to_string(val)
}
pub fn llty_str(&self, ty: Type) -> String {
self.ccx().tn.type_to_string(ty)
self.ccx().tn().type_to_string(ty)
}
pub fn ty_to_string(&self, t: ty::t) -> String {
@ -601,11 +601,11 @@ pub fn C_u64(ccx: &CrateContext, i: u64) -> ValueRef {
}
pub fn C_int(ccx: &CrateContext, i: int) -> ValueRef {
C_integral(ccx.int_type, i as u64, true)
C_integral(ccx.int_type(), i as u64, true)
}
pub fn C_uint(ccx: &CrateContext, i: uint) -> ValueRef {
C_integral(ccx.int_type, i as u64, false)
C_integral(ccx.int_type(), i as u64, false)
}
pub fn C_u8(ccx: &CrateContext, i: uint) -> ValueRef {
@ -617,25 +617,25 @@ pub fn C_u8(ccx: &CrateContext, i: uint) -> ValueRef {
// our boxed-and-length-annotated strings.
pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> ValueRef {
unsafe {
match cx.const_cstr_cache.borrow().find(&s) {
match cx.const_cstr_cache().borrow().find(&s) {
Some(&llval) => return llval,
None => ()
}
let sc = llvm::LLVMConstStringInContext(cx.llcx,
let sc = llvm::LLVMConstStringInContext(cx.llcx(),
s.get().as_ptr() as *const c_char,
s.get().len() as c_uint,
!null_terminated as Bool);
let gsym = token::gensym("str");
let g = format!("str{}", gsym.uint()).with_c_str(|buf| {
llvm::LLVMAddGlobal(cx.llmod, val_ty(sc).to_ref(), buf)
llvm::LLVMAddGlobal(cx.llmod(), val_ty(sc).to_ref(), buf)
});
llvm::LLVMSetInitializer(g, sc);
llvm::LLVMSetGlobalConstant(g, True);
llvm::SetLinkage(g, llvm::InternalLinkage);
cx.const_cstr_cache.borrow_mut().insert(s, g);
cx.const_cstr_cache().borrow_mut().insert(s, g);
g
}
}
@ -647,7 +647,7 @@ pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef {
let len = s.get().len();
let cs = llvm::LLVMConstPointerCast(C_cstr(cx, s, false),
Type::i8p(cx).to_ref());
C_named_struct(cx.tn.find_type("str_slice").unwrap(), [cs, C_uint(cx, len)])
C_named_struct(cx.tn().find_type("str_slice").unwrap(), [cs, C_uint(cx, len)])
}
}
@ -658,7 +658,7 @@ pub fn C_binary_slice(cx: &CrateContext, data: &[u8]) -> ValueRef {
let gsym = token::gensym("binary");
let g = format!("binary{}", gsym.uint()).with_c_str(|buf| {
llvm::LLVMAddGlobal(cx.llmod, val_ty(lldata).to_ref(), buf)
llvm::LLVMAddGlobal(cx.llmod(), val_ty(lldata).to_ref(), buf)
});
llvm::LLVMSetInitializer(g, lldata);
llvm::LLVMSetGlobalConstant(g, True);
@ -671,7 +671,7 @@ pub fn C_binary_slice(cx: &CrateContext, data: &[u8]) -> ValueRef {
pub fn C_struct(ccx: &CrateContext, elts: &[ValueRef], packed: bool) -> ValueRef {
unsafe {
llvm::LLVMConstStructInContext(ccx.llcx,
llvm::LLVMConstStructInContext(ccx.llcx(),
elts.as_ptr(), elts.len() as c_uint,
packed as Bool)
}
@ -692,7 +692,7 @@ pub fn C_array(ty: Type, elts: &[ValueRef]) -> ValueRef {
pub fn C_bytes(ccx: &CrateContext, bytes: &[u8]) -> ValueRef {
unsafe {
let ptr = bytes.as_ptr() as *const c_char;
return llvm::LLVMConstStringInContext(ccx.llcx, ptr, bytes.len() as c_uint, True);
return llvm::LLVMConstStringInContext(ccx.llcx(), ptr, bytes.len() as c_uint, True);
}
}
@ -702,7 +702,7 @@ pub fn const_get_elt(cx: &CrateContext, v: ValueRef, us: &[c_uint])
let r = llvm::LLVMConstExtractValue(v, us.as_ptr(), us.len() as c_uint);
debug!("const_get_elt(v={}, us={:?}, r={})",
cx.tn.val_to_string(v), us, cx.tn.val_to_string(r));
cx.tn().val_to_string(v), us, cx.tn().val_to_string(r));
return r;
}

20
src/librustc/middle/trans/consts.rs
View file

@ -91,7 +91,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: ast::Lit)
pub fn const_ptrcast(cx: &CrateContext, a: ValueRef, t: Type) -> ValueRef {
unsafe {
let b = llvm::LLVMConstPointerCast(a, t.ptr_to().to_ref());
assert!(cx.const_globals.borrow_mut().insert(b as int, a));
assert!(cx.const_globals().borrow_mut().insert(b as int, a));
b
}
}
@ -119,7 +119,7 @@ fn const_vec(cx: &CrateContext, e: &ast::Expr,
pub fn const_addr_of(cx: &CrateContext, cv: ValueRef, mutbl: ast::Mutability) -> ValueRef {
unsafe {
let gv = "const".with_c_str(|name| {
llvm::LLVMAddGlobal(cx.llmod, val_ty(cv).to_ref(), name)
llvm::LLVMAddGlobal(cx.llmod(), val_ty(cv).to_ref(), name)
});
llvm::LLVMSetInitializer(gv, cv);
llvm::LLVMSetGlobalConstant(gv,
@ -130,7 +130,7 @@ pub fn const_addr_of(cx: &CrateContext, cv: ValueRef, mutbl: ast::Mutability) ->
}
fn const_deref_ptr(cx: &CrateContext, v: ValueRef) -> ValueRef {
let v = match cx.const_globals.borrow().find(&(v as int)) {
let v = match cx.const_globals().borrow().find(&(v as int)) {
Some(&v) => v,
None => v
};
@ -178,13 +178,13 @@ fn const_deref(cx: &CrateContext, v: ValueRef, t: ty::t, explicit: bool)
pub fn get_const_val(cx: &CrateContext,
mut def_id: ast::DefId) -> (ValueRef, bool) {
let contains_key = cx.const_values.borrow().contains_key(&def_id.node);
let contains_key = cx.const_values().borrow().contains_key(&def_id.node);
if !ast_util::is_local(def_id) || !contains_key {
if !ast_util::is_local(def_id) {
def_id = inline::maybe_instantiate_inline(cx, def_id);
}
match cx.tcx.map.expect_item(def_id.node).node {
match cx.tcx().map.expect_item(def_id.node).node {
ast::ItemStatic(_, ast::MutImmutable, _) => {
trans_const(cx, ast::MutImmutable, def_id.node);
}
@ -192,8 +192,8 @@ pub fn get_const_val(cx: &CrateContext,
}
}
(cx.const_values.borrow().get_copy(&def_id.node),
!cx.non_inlineable_statics.borrow().contains(&def_id.node))
(cx.const_values().borrow().get_copy(&def_id.node),
!cx.non_inlineable_statics().borrow().contains(&def_id.node))
}
pub fn const_expr(cx: &CrateContext, e: &ast::Expr, is_local: bool) -> (ValueRef, bool, ty::t) {
@ -202,7 +202,7 @@ pub fn const_expr(cx: &CrateContext, e: &ast::Expr, is_local: bool) -> (ValueRef
let mut inlineable = inlineable;
let ety = ty::expr_ty(cx.tcx(), e);
let mut ety_adjusted = ty::expr_ty_adjusted(cx.tcx(), e);
let opt_adj = cx.tcx.adjustments.borrow().find_copy(&e.id);
let opt_adj = cx.tcx().adjustments.borrow().find_copy(&e.id);
match opt_adj {
None => { }
Some(adj) => {
@ -523,7 +523,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
(expr::cast_enum, expr::cast_integral) => {
let repr = adt::represent_type(cx, basety);
let discr = adt::const_get_discrim(cx, &*repr, v);
let iv = C_integral(cx.int_type, discr, false);
let iv = C_integral(cx.int_type(), discr, false);
let ety_cast = expr::cast_type_kind(cx.tcx(), ety);
match ety_cast {
expr::cast_integral => {
@ -690,7 +690,7 @@ pub fn trans_const(ccx: &CrateContext, m: ast::Mutability, id: ast::NodeId) {
let g = base::get_item_val(ccx, id);
// At this point, get_item_val has already translated the
// constant's initializer to determine its LLVM type.
let v = ccx.const_values.borrow().get_copy(&id);
let v = ccx.const_values().borrow().get_copy(&id);
llvm::LLVMSetInitializer(g, v);
if m != ast::MutMutable {
llvm::LLVMSetGlobalConstant(g, True);

260
src/librustc/middle/trans/context.rs
View file

@ -11,7 +11,7 @@
use driver::config::NoDebugInfo;
use driver::session::Session;
use llvm;
use llvm::{ContextRef, ModuleRef, ValueRef};
use llvm::{ContextRef, ModuleRef, ValueRef, BuilderRef};
use llvm::{TargetData};
use llvm::mk_target_data;
use metadata::common::LinkMeta;
@ -52,38 +52,38 @@ pub struct Stats {
}
pub struct CrateContext {
pub llmod: ModuleRef,
pub llcx: ContextRef,
pub metadata_llmod: ModuleRef,
pub td: TargetData,
pub tn: TypeNames,
pub externs: RefCell<ExternMap>,
pub item_vals: RefCell<NodeMap<ValueRef>>,
pub exp_map2: resolve::ExportMap2,
pub reachable: NodeSet,
pub item_symbols: RefCell<NodeMap<String>>,
pub link_meta: LinkMeta,
pub drop_glues: RefCell<HashMap<ty::t, ValueRef>>,
pub tydescs: RefCell<HashMap<ty::t, Rc<tydesc_info>>>,
llmod: ModuleRef,
llcx: ContextRef,
metadata_llmod: ModuleRef,
td: TargetData,
tn: TypeNames,
externs: RefCell<ExternMap>,
item_vals: RefCell<NodeMap<ValueRef>>,
exp_map2: resolve::ExportMap2,
reachable: NodeSet,
item_symbols: RefCell<NodeMap<String>>,
link_meta: LinkMeta,
drop_glues: RefCell<HashMap<ty::t, ValueRef>>,
tydescs: RefCell<HashMap<ty::t, Rc<tydesc_info>>>,
/// Set when running emit_tydescs to enforce that no more tydescs are
/// created.
pub finished_tydescs: Cell<bool>,
finished_tydescs: Cell<bool>,
/// Track mapping of external ids to local items imported for inlining
pub external: RefCell<DefIdMap<Option<ast::NodeId>>>,
external: RefCell<DefIdMap<Option<ast::NodeId>>>,
/// Backwards version of the `external` map (inlined items to where they
/// came from)
pub external_srcs: RefCell<NodeMap<ast::DefId>>,
external_srcs: RefCell<NodeMap<ast::DefId>>,
/// A set of static items which cannot be inlined into other crates. This
/// will prevent in IIItem() structures from being encoded into the metadata
/// that is generated
pub non_inlineable_statics: RefCell<NodeSet>,
non_inlineable_statics: RefCell<NodeSet>,
/// Cache instances of monomorphized functions
pub monomorphized: RefCell<HashMap<MonoId, ValueRef>>,
pub monomorphizing: RefCell<DefIdMap<uint>>,
monomorphized: RefCell<HashMap<MonoId, ValueRef>>,
monomorphizing: RefCell<DefIdMap<uint>>,
/// Cache generated vtables
pub vtables: RefCell<HashMap<(ty::t, MonoId), ValueRef>>,
vtables: RefCell<HashMap<(ty::t, MonoId), ValueRef>>,
/// Cache of constant strings,
pub const_cstr_cache: RefCell<HashMap<InternedString, ValueRef>>,
const_cstr_cache: RefCell<HashMap<InternedString, ValueRef>>,
/// Reverse-direction for const ptrs cast from globals.
/// Key is an int, cast from a ValueRef holding a *T,
@ -93,37 +93,37 @@ pub struct CrateContext {
/// when we ptrcast, and we have to ptrcast during translation
/// of a [T] const because we form a slice, a [*T,int] pair, not
/// a pointer to an LLVM array type.
pub const_globals: RefCell<HashMap<int, ValueRef>>,
const_globals: RefCell<HashMap<int, ValueRef>>,
/// Cache of emitted const values
pub const_values: RefCell<NodeMap<ValueRef>>,
const_values: RefCell<NodeMap<ValueRef>>,
/// Cache of external const values
pub extern_const_values: RefCell<DefIdMap<ValueRef>>,
extern_const_values: RefCell<DefIdMap<ValueRef>>,
pub impl_method_cache: RefCell<HashMap<(ast::DefId, ast::Name), ast::DefId>>,
impl_method_cache: RefCell<HashMap<(ast::DefId, ast::Name), ast::DefId>>,
/// Cache of closure wrappers for bare fn's.
pub closure_bare_wrapper_cache: RefCell<HashMap<ValueRef, ValueRef>>,
closure_bare_wrapper_cache: RefCell<HashMap<ValueRef, ValueRef>>,
pub lltypes: RefCell<HashMap<ty::t, Type>>,
pub llsizingtypes: RefCell<HashMap<ty::t, Type>>,
pub adt_reprs: RefCell<HashMap<ty::t, Rc<adt::Repr>>>,
pub symbol_hasher: RefCell<Sha256>,
pub type_hashcodes: RefCell<HashMap<ty::t, String>>,
pub all_llvm_symbols: RefCell<HashSet<String>>,
pub tcx: ty::ctxt,
pub stats: Stats,
pub int_type: Type,
pub opaque_vec_type: Type,
pub builder: BuilderRef_res,
lltypes: RefCell<HashMap<ty::t, Type>>,
llsizingtypes: RefCell<HashMap<ty::t, Type>>,
adt_reprs: RefCell<HashMap<ty::t, Rc<adt::Repr>>>,
symbol_hasher: RefCell<Sha256>,
type_hashcodes: RefCell<HashMap<ty::t, String>>,
all_llvm_symbols: RefCell<HashSet<String>>,
tcx: ty::ctxt,
stats: Stats,
int_type: Type,
opaque_vec_type: Type,
builder: BuilderRef_res,
/// Holds the LLVM values for closure IDs.
pub unboxed_closure_vals: RefCell<DefIdMap<ValueRef>>,
unboxed_closure_vals: RefCell<DefIdMap<ValueRef>>,
pub dbg_cx: Option<debuginfo::CrateDebugContext>,
dbg_cx: Option<debuginfo::CrateDebugContext>,
pub eh_personality: RefCell<Option<ValueRef>>,
eh_personality: RefCell<Option<ValueRef>>,
intrinsics: RefCell<HashMap<&'static str, ValueRef>>,
}
@ -235,10 +235,10 @@ impl CrateContext {
ccx.opaque_vec_type = Type::opaque_vec(&ccx);
let mut str_slice_ty = Type::named_struct(&ccx, "str_slice");
str_slice_ty.set_struct_body([Type::i8p(&ccx), ccx.int_type], false);
ccx.tn.associate_type("str_slice", &str_slice_ty);
str_slice_ty.set_struct_body([Type::i8p(&ccx), ccx.int_type()], false);
ccx.tn().associate_type("str_slice", &str_slice_ty);
ccx.tn.associate_type("tydesc", &Type::tydesc(&ccx, str_slice_ty));
ccx.tn().associate_type("tydesc", &Type::tydesc(&ccx, str_slice_ty));
if ccx.sess().count_llvm_insns() {
base::init_insn_ctxt()
@ -252,6 +252,10 @@ impl CrateContext {
&self.tcx
}
pub fn take_tcx(self) -> ty::ctxt {
self.tcx
}
pub fn sess<'a>(&'a self) -> &'a Session {
&self.tcx.sess
}
@ -260,6 +264,10 @@ impl CrateContext {
Builder::new(self)
}
pub fn raw_builder<'a>(&'a self) -> BuilderRef {
self.builder.b
}
pub fn tydesc_type(&self) -> Type {
self.tn.find_type("tydesc").unwrap()
}
@ -286,6 +294,164 @@ impl CrateContext {
let ref cfg = self.sess().targ_cfg;
cfg.os != abi::OsiOS || cfg.arch != abi::Arm
}
pub fn llmod(&self) -> ModuleRef {
self.llmod
}
pub fn llcx(&self) -> ContextRef {
self.llcx
}
pub fn metadata_llmod(&self) -> ModuleRef {
self.metadata_llmod
}
pub fn td<'a>(&'a self) -> &'a TargetData {
&self.td
}
pub fn tn<'a>(&'a self) -> &'a TypeNames {
&self.tn
}
pub fn externs<'a>(&'a self) -> &'a RefCell<ExternMap> {
&self.externs
}
pub fn item_vals<'a>(&'a self) -> &'a RefCell<NodeMap<ValueRef>> {
&self.item_vals
}
pub fn exp_map2<'a>(&'a self) -> &'a resolve::ExportMap2 {
&self.exp_map2
}
pub fn reachable<'a>(&'a self) -> &'a NodeSet {
&self.reachable
}
pub fn item_symbols<'a>(&'a self) -> &'a RefCell<NodeMap<String>> {
&self.item_symbols
}
pub fn link_meta<'a>(&'a self) -> &'a LinkMeta {
&self.link_meta
}
pub fn drop_glues<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, ValueRef>> {
&self.drop_glues
}
pub fn tydescs<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, Rc<tydesc_info>>> {
&self.tydescs
}
pub fn finished_tydescs<'a>(&'a self) -> &'a Cell<bool> {
&self.finished_tydescs
}
pub fn external<'a>(&'a self) -> &'a RefCell<DefIdMap<Option<ast::NodeId>>> {
&self.external
}
pub fn external_srcs<'a>(&'a self) -> &'a RefCell<NodeMap<ast::DefId>> {
&self.external_srcs
}
pub fn non_inlineable_statics<'a>(&'a self) -> &'a RefCell<NodeSet> {
&self.non_inlineable_statics
}
pub fn monomorphized<'a>(&'a self) -> &'a RefCell<HashMap<MonoId, ValueRef>> {
&self.monomorphized
}
pub fn monomorphizing<'a>(&'a self) -> &'a RefCell<DefIdMap<uint>> {
&self.monomorphizing
}
pub fn vtables<'a>(&'a self) -> &'a RefCell<HashMap<(ty::t, MonoId), ValueRef>> {
&self.vtables
}
pub fn const_cstr_cache<'a>(&'a self) -> &'a RefCell<HashMap<InternedString, ValueRef>> {
&self.const_cstr_cache
}
pub fn const_globals<'a>(&'a self) -> &'a RefCell<HashMap<int, ValueRef>> {
&self.const_globals
}
pub fn const_values<'a>(&'a self) -> &'a RefCell<NodeMap<ValueRef>> {
&self.const_values
}
pub fn extern_const_values<'a>(&'a self) -> &'a RefCell<DefIdMap<ValueRef>> {
&self.extern_const_values
}
pub fn impl_method_cache<'a>(&'a self)
-> &'a RefCell<HashMap<(ast::DefId, ast::Name), ast::DefId>> {
&self.impl_method_cache
}
pub fn closure_bare_wrapper_cache<'a>(&'a self) -> &'a RefCell<HashMap<ValueRef, ValueRef>> {
&self.closure_bare_wrapper_cache
}
pub fn lltypes<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, Type>> {
&self.lltypes
}
pub fn llsizingtypes<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, Type>> {
&self.llsizingtypes
}
pub fn adt_reprs<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, Rc<adt::Repr>>> {
&self.adt_reprs
}
pub fn symbol_hasher<'a>(&'a self) -> &'a RefCell<Sha256> {
&self.symbol_hasher
}
pub fn type_hashcodes<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, String>> {
&self.type_hashcodes
}
pub fn all_llvm_symbols<'a>(&'a self) -> &'a RefCell<HashSet<String>> {
&self.all_llvm_symbols
}
pub fn stats<'a>(&'a self) -> &'a Stats {
&self.stats
}
pub fn int_type(&self) -> Type {
self.int_type
}
pub fn opaque_vec_type(&self) -> Type {
self.opaque_vec_type
}
pub fn unboxed_closure_vals<'a>(&'a self) -> &'a RefCell<DefIdMap<ValueRef>> {
&self.unboxed_closure_vals
}
pub fn dbg_cx<'a>(&'a self) -> &'a Option<debuginfo::CrateDebugContext> {
&self.dbg_cx
}
pub fn eh_personality<'a>(&'a self) -> &'a RefCell<Option<ValueRef>> {
&self.eh_personality
}
fn intrinsics<'a>(&'a self) -> &'a RefCell<HashMap<&'static str, ValueRef>> {
&self.intrinsics
}
}
fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef> {
@ -293,7 +459,7 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef
($name:expr fn() -> $ret:expr) => (
if *key == $name {
let f = base::decl_cdecl_fn(ccx, $name, Type::func([], &$ret), ty::mk_nil());
ccx.intrinsics.borrow_mut().insert($name, f.clone());
ccx.intrinsics().borrow_mut().insert($name, f.clone());
return Some(f);
}
);
@ -301,7 +467,7 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef
if *key == $name {
let f = base::decl_cdecl_fn(ccx, $name,
Type::func([$($arg),*], &$ret), ty::mk_nil());
ccx.intrinsics.borrow_mut().insert($name, f.clone());
ccx.intrinsics().borrow_mut().insert($name, f.clone());
return Some(f);
}
)
@ -437,7 +603,7 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef
let f = base::decl_cdecl_fn(ccx, stringify!($cname),
Type::func([$($arg),*], &$ret),
ty::mk_nil());
ccx.intrinsics.borrow_mut().insert($name, f.clone());
ccx.intrinsics().borrow_mut().insert($name, f.clone());
return Some(f);
}
)

2
src/librustc/middle/trans/datum.rs
View file

@ -627,7 +627,7 @@ impl<K:KindOps> Datum<K> {
#[allow(dead_code)] // useful for debugging
pub fn to_string(&self, ccx: &CrateContext) -> String {
format!("Datum({}, {}, {:?})",
ccx.tn.val_to_string(self.val),
ccx.tn().val_to_string(self.val),
ty_to_string(ccx.tcx(), self.ty),
self.kind)
}

58
src/librustc/middle/trans/debuginfo.rs
View file

@ -538,7 +538,7 @@ impl TypeMap {
// First, find out the 'real' def_id of the type. Items inlined from
// other crates have to be mapped back to their source.
let source_def_id = if def_id.krate == ast::LOCAL_CRATE {
match cx.external_srcs.borrow().find_copy(&def_id.node) {
match cx.external_srcs().borrow().find_copy(&def_id.node) {
Some(source_def_id) => {
// The given def_id identifies the inlined copy of a
// type definition, let's take the source of the copy.
@ -552,7 +552,7 @@ impl TypeMap {
// Get the crate hash as first part of the identifier.
let crate_hash = if source_def_id.krate == ast::LOCAL_CRATE {
cx.link_meta.crate_hash.clone()
cx.link_meta().crate_hash.clone()
} else {
cx.sess().cstore.get_crate_hash(source_def_id.krate)
};
@ -721,7 +721,7 @@ enum VariableKind {
/// Create any deferred debug metadata nodes
pub fn finalize(cx: &CrateContext) {
if cx.dbg_cx.is_none() {
if cx.dbg_cx().is_none() {
return;
}
@ -738,18 +738,18 @@ pub fn finalize(cx: &CrateContext) {
if cx.sess().targ_cfg.os == abi::OsMacos ||
cx.sess().targ_cfg.os == abi::OsiOS {
"Dwarf Version".with_c_str(
|s| llvm::LLVMRustAddModuleFlag(cx.llmod, s, 2));
|s| llvm::LLVMRustAddModuleFlag(cx.llmod(), s, 2));
} else {
// FIXME(#13611) this is a kludge fix because the Linux bots have
// gdb 7.4 which doesn't understand dwarf4, we should
// do something more graceful here.
"Dwarf Version".with_c_str(
|s| llvm::LLVMRustAddModuleFlag(cx.llmod, s, 3));
|s| llvm::LLVMRustAddModuleFlag(cx.llmod(), s, 3));
}
// Prevent bitcode readers from deleting the debug info.
"Debug Info Version".with_c_str(
|s| llvm::LLVMRustAddModuleFlag(cx.llmod, s,
|s| llvm::LLVMRustAddModuleFlag(cx.llmod(), s,
llvm::LLVMRustDebugMetadataVersion));
};
}
@ -760,7 +760,7 @@ pub fn finalize(cx: &CrateContext) {
pub fn create_global_var_metadata(cx: &CrateContext,
node_id: ast::NodeId,
global: ValueRef) {
if cx.dbg_cx.is_none() {
if cx.dbg_cx().is_none() {
return;
}
@ -768,11 +768,11 @@ pub fn create_global_var_metadata(cx: &CrateContext,
// crate should already contain debuginfo for it. More importantly, the
// global might not even exist in un-inlined form anywhere which would lead
// to a linker errors.
if cx.external_srcs.borrow().contains_key(&node_id) {
if cx.external_srcs().borrow().contains_key(&node_id) {
return;
}
let var_item = cx.tcx.map.get(node_id);
let var_item = cx.tcx().map.get(node_id);
let (ident, span) = match var_item {
ast_map::NodeItem(item) => {
@ -838,7 +838,7 @@ pub fn create_local_var_metadata(bcx: &Block, local: &ast::Local) {
}
let cx = bcx.ccx();
let def_map = &cx.tcx.def_map;
let def_map = &cx.tcx().def_map;
pat_util::pat_bindings(def_map, &*local.pat, |_, node_id, span, path1| {
let var_ident = path1.node;
@ -880,7 +880,7 @@ pub fn create_captured_var_metadata(bcx: &Block,
let cx = bcx.ccx();
let ast_item = cx.tcx.map.find(node_id);
let ast_item = cx.tcx().map.find(node_id);
let variable_ident = match ast_item {
None => {
@ -963,7 +963,7 @@ pub fn create_match_binding_metadata(bcx: &Block,
let scope_metadata = scope_metadata(bcx.fcx, binding.id, binding.span);
let aops = unsafe {
[llvm::LLVMDIBuilderCreateOpDeref(bcx.ccx().int_type.to_ref())]
[llvm::LLVMDIBuilderCreateOpDeref(bcx.ccx().int_type().to_ref())]
};
// Regardless of the actual type (`T`) we're always passed the stack slot (alloca)
// for the binding. For ByRef bindings that's a `T*` but for ByMove bindings we
@ -1002,7 +1002,7 @@ pub fn create_argument_metadata(bcx: &Block, arg: &ast::Arg) {
let fcx = bcx.fcx;
let cx = fcx.ccx;
let def_map = &cx.tcx.def_map;
let def_map = &cx.tcx().def_map;
let scope_metadata = bcx.fcx.debug_context.get_ref(cx, arg.pat.span).fn_metadata;
pat_util::pat_bindings(def_map, &*arg.pat, |_, node_id, span, path1| {
@ -1120,7 +1120,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
let empty_generics = ast_util::empty_generics();
let fnitem = cx.tcx.map.get(fn_ast_id);
let fnitem = cx.tcx().map.get(fn_ast_id);
let (ident, fn_decl, generics, top_level_block, span, has_path) = match fnitem {
ast_map::NodeItem(ref item) => {
@ -1447,7 +1447,7 @@ fn is_node_local_to_unit(cx: &CrateContext, node_id: ast::NodeId) -> bool
// externally visible or by being inlined into something externally visible).
// It might better to use the `exported_items` set from `driver::CrateAnalysis`
// in the future, but (atm) this set is not available in the translation pass.
!cx.reachable.contains(&node_id)
!cx.reachable().contains(&node_id)
}
#[allow(non_snake_case)]
@ -1514,7 +1514,7 @@ fn compile_unit_metadata(cx: &CrateContext) {
});
fn fallback_path(cx: &CrateContext) -> CString {
cx.link_meta.crate_name.as_slice().to_c_str()
cx.link_meta().crate_name.as_slice().to_c_str()
}
}
@ -1643,7 +1643,7 @@ fn scope_metadata(fcx: &FunctionContext,
match scope_map.borrow().find_copy(&node_id) {
Some(scope_metadata) => scope_metadata,
None => {
let node = fcx.ccx.tcx.map.get(node_id);
let node = fcx.ccx.tcx().map.get(node_id);
fcx.ccx.sess().span_bug(span,
format!("debuginfo: Could not find scope info for node {:?}",
@ -2440,9 +2440,9 @@ fn prepare_enum_metadata(cx: &CrateContext,
def_id: ast::DefId)
-> token::InternedString {
let name = if def_id.krate == ast::LOCAL_CRATE {
cx.tcx.map.get_path_elem(def_id.node).name()
cx.tcx().map.get_path_elem(def_id.node).name()
} else {
csearch::get_item_path(&cx.tcx, def_id).last().unwrap().name()
csearch::get_item_path(cx.tcx(), def_id).last().unwrap().name()
};
token::get_name(name)
@ -2685,7 +2685,7 @@ fn at_box_metadata(cx: &CrateContext,
content_llvm_type: Type)
-> bool {
member_llvm_types.len() == 5 &&
member_llvm_types[0] == cx.int_type &&
member_llvm_types[0] == cx.int_type() &&
member_llvm_types[1] == Type::generic_glue_fn(cx).ptr_to() &&
member_llvm_types[2] == Type::i8(cx).ptr_to() &&
member_llvm_types[3] == Type::i8(cx).ptr_to() &&
@ -2787,7 +2787,7 @@ fn vec_slice_metadata(cx: &CrateContext,
-> bool {
member_llvm_types.len() == 2 &&
member_llvm_types[0] == type_of::type_of(cx, element_type).ptr_to() &&
member_llvm_types[1] == cx.int_type
member_llvm_types[1] == cx.int_type()
}
}
@ -3090,7 +3090,7 @@ fn set_debug_location(cx: &CrateContext, debug_location: DebugLocation) {
};
unsafe {
llvm::LLVMSetCurrentDebugLocation(cx.builder.b, metadata_node);
llvm::LLVMSetCurrentDebugLocation(cx.raw_builder(), metadata_node);
}
debug_context(cx).current_debug_location.set(debug_location);
@ -3125,14 +3125,14 @@ fn bytes_to_bits(bytes: u64) -> c_ulonglong {
#[inline]
fn debug_context<'a>(cx: &'a CrateContext) -> &'a CrateDebugContext {
let debug_context: &'a CrateDebugContext = cx.dbg_cx.get_ref();
let debug_context: &'a CrateDebugContext = cx.dbg_cx().get_ref();
debug_context
}
#[inline]
#[allow(non_snake_case)]
fn DIB(cx: &CrateContext) -> DIBuilderRef {
cx.dbg_cx.get_ref().builder
cx.dbg_cx().get_ref().builder
}
fn fn_should_be_ignored(fcx: &FunctionContext) -> bool {
@ -3143,7 +3143,7 @@ fn fn_should_be_ignored(fcx: &FunctionContext) -> bool {
}
fn assert_type_for_node_id(cx: &CrateContext, node_id: ast::NodeId, error_span: Span) {
if !cx.tcx.node_types.borrow().contains_key(&(node_id as uint)) {
if !cx.tcx().node_types.borrow().contains_key(&(node_id as uint)) {
cx.sess().span_bug(error_span, "debuginfo: Could not find type for node id!");
}
}
@ -3152,7 +3152,7 @@ fn get_namespace_and_span_for_item(cx: &CrateContext, def_id: ast::DefId)
-> (DIScope, Span) {
let containing_scope = namespace_for_item(cx, def_id).scope;
let definition_span = if def_id.krate == ast::LOCAL_CRATE {
cx.tcx.map.span(def_id.node)
cx.tcx().map.span(def_id.node)
} else {
// For external items there is no span information
codemap::DUMMY_SP
@ -3173,7 +3173,7 @@ fn populate_scope_map(cx: &CrateContext,
fn_entry_block: &ast::Block,
fn_metadata: DISubprogram,
scope_map: &mut HashMap<ast::NodeId, DIScope>) {
let def_map = &cx.tcx.def_map;
let def_map = &cx.tcx().def_map;
struct ScopeStackEntry {
scope_metadata: DIScope,
@ -3290,7 +3290,7 @@ fn populate_scope_map(cx: &CrateContext,
scope_stack: &mut Vec<ScopeStackEntry> ,
scope_map: &mut HashMap<ast::NodeId, DIScope>) {
let def_map = &cx.tcx.def_map;
let def_map = &cx.tcx().def_map;
// Unfortunately, we cannot just use pat_util::pat_bindings() or
// ast_util::walk_pat() here because we have to visit *all* nodes in
@ -3942,7 +3942,7 @@ impl NamespaceTreeNode {
}
fn crate_root_namespace<'a>(cx: &'a CrateContext) -> &'a str {
cx.link_meta.crate_name.as_slice()
cx.link_meta().crate_name.as_slice()
}
fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc<NamespaceTreeNode> {

24
src/librustc/middle/trans/expr.rs
View file

@ -94,7 +94,7 @@ pub enum Dest {
impl Dest {
pub fn to_string(&self, ccx: &CrateContext) -> String {
match *self {
SaveIn(v) => format!("SaveIn({})", ccx.tn.val_to_string(v)),
SaveIn(v) => format!("SaveIn({})", ccx.tn().val_to_string(v)),
Ignore => "Ignore".to_string()
}
}
@ -711,7 +711,7 @@ fn trans_index<'a>(bcx: &'a Block<'a>,
let mut bcx = bcx;
// Check for overloaded index.
let method_ty = ccx.tcx
let method_ty = ccx.tcx()
.method_map
.borrow()
.find(&method_call)
@ -758,14 +758,14 @@ fn trans_index<'a>(bcx: &'a Block<'a>,
let ix_size = machine::llbitsize_of_real(bcx.ccx(),
val_ty(ix_val));
let int_size = machine::llbitsize_of_real(bcx.ccx(),
ccx.int_type);
ccx.int_type());
let ix_val = {
if ix_size < int_size {
if ty::type_is_signed(expr_ty(bcx, idx)) {
SExt(bcx, ix_val, ccx.int_type)
} else { ZExt(bcx, ix_val, ccx.int_type) }
SExt(bcx, ix_val, ccx.int_type())
} else { ZExt(bcx, ix_val, ccx.int_type()) }
} else if ix_size > int_size {
Trunc(bcx, ix_val, ccx.int_type)
Trunc(bcx, ix_val, ccx.int_type())
} else {
ix_val
}
@ -839,7 +839,7 @@ fn trans_def<'a>(bcx: &'a Block<'a>,
let pty = type_of::type_of(bcx.ccx(), const_ty).ptr_to();
PointerCast(bcx, val, pty)
} else {
match bcx.ccx().extern_const_values.borrow().find(&did) {
match bcx.ccx().extern_const_values().borrow().find(&did) {
None => {} // Continue.
Some(llval) => {
return *llval;
@ -852,11 +852,11 @@ fn trans_def<'a>(bcx: &'a Block<'a>,
&bcx.ccx().sess().cstore,
did);
let llval = symbol.as_slice().with_c_str(|buf| {
llvm::LLVMAddGlobal(bcx.ccx().llmod,
llvm::LLVMAddGlobal(bcx.ccx().llmod(),
llty.to_ref(),
buf)
});
bcx.ccx().extern_const_values.borrow_mut()
bcx.ccx().extern_const_values().borrow_mut()
.insert(did, llval);
llval
}
@ -1439,7 +1439,7 @@ fn trans_unary<'a>(bcx: &'a Block<'a>,
// Otherwise, we should be in the RvalueDpsExpr path.
assert!(
op == ast::UnDeref ||
!ccx.tcx.method_map.borrow().contains_key(&method_call));
!ccx.tcx().method_map.borrow().contains_key(&method_call));
let un_ty = expr_ty(bcx, expr);
@ -1706,7 +1706,7 @@ fn trans_binary<'a>(bcx: &'a Block<'a>,
let ccx = bcx.ccx();
// if overloaded, would be RvalueDpsExpr
assert!(!ccx.tcx.method_map.borrow().contains_key(&MethodCall::expr(expr.id)));
assert!(!ccx.tcx().method_map.borrow().contains_key(&MethodCall::expr(expr.id)));
match op {
ast::BiAnd => {
@ -2050,7 +2050,7 @@ fn deref_once<'a>(bcx: &'a Block<'a>,
let mut bcx = bcx;
// Check for overloaded deref.
let method_ty = ccx.tcx.method_map.borrow()
let method_ty = ccx.tcx().method_map.borrow()
.find(&method_call).map(|method| method.ty);
let datum = match method_ty {
Some(method_ty) => {

71
src/librustc/middle/trans/foreign.rs
View file

@ -160,14 +160,14 @@ pub fn register_static(ccx: &CrateContext,
};
unsafe {
let g1 = ident.get().with_c_str(|buf| {
llvm::LLVMAddGlobal(ccx.llmod, llty2.to_ref(), buf)
llvm::LLVMAddGlobal(ccx.llmod(), llty2.to_ref(), buf)
});
llvm::SetLinkage(g1, linkage);
let mut real_name = "_rust_extern_with_linkage_".to_string();
real_name.push_str(ident.get());
let g2 = real_name.with_c_str(|buf| {
llvm::LLVMAddGlobal(ccx.llmod, llty.to_ref(), buf)
llvm::LLVMAddGlobal(ccx.llmod(), llty.to_ref(), buf)
});
llvm::SetLinkage(g2, llvm::InternalLinkage);
llvm::LLVMSetInitializer(g2, g1);
@ -176,7 +176,7 @@ pub fn register_static(ccx: &CrateContext,
}
None => unsafe {
ident.get().with_c_str(|buf| {
llvm::LLVMAddGlobal(ccx.llmod, llty.to_ref(), buf)
llvm::LLVMAddGlobal(ccx.llmod(), llty.to_ref(), buf)
})
}
}
@ -229,7 +229,7 @@ pub fn register_foreign_item_fn(ccx: &CrateContext, abi: Abi, fty: ty::t,
let llfn_ty = lltype_for_fn_from_foreign_types(ccx, &tys);
let llfn = base::get_extern_fn(ccx,
&mut *ccx.externs.borrow_mut(),
&mut *ccx.externs().borrow_mut(),
name,
cc,
llfn_ty,
@ -271,8 +271,8 @@ pub fn trans_native_call<'a>(
llfn={}, \
llretptr={})",
callee_ty.repr(tcx),
ccx.tn.val_to_string(llfn),
ccx.tn.val_to_string(llretptr));
ccx.tn().val_to_string(llfn),
ccx.tn().val_to_string(llretptr));
let (fn_abi, fn_sig) = match ty::get(callee_ty).sty {
ty::ty_bare_fn(ref fn_ty) => (fn_ty.abi, fn_ty.sig.clone()),
@ -319,9 +319,9 @@ pub fn trans_native_call<'a>(
debug!("argument {}, llarg_rust={}, rust_indirect={}, arg_ty={}",
i,
ccx.tn.val_to_string(llarg_rust),
ccx.tn().val_to_string(llarg_rust),
rust_indirect,
ccx.tn.type_to_string(arg_tys[i].ty));
ccx.tn().type_to_string(arg_tys[i].ty));
// Ensure that we always have the Rust value indirectly,
// because it makes bitcasting easier.
@ -335,7 +335,7 @@ pub fn trans_native_call<'a>(
}
debug!("llarg_rust={} (after indirection)",
ccx.tn.val_to_string(llarg_rust));
ccx.tn().val_to_string(llarg_rust));
// Check whether we need to do any casting
match arg_tys[i].cast {
@ -344,7 +344,7 @@ pub fn trans_native_call<'a>(
}
debug!("llarg_rust={} (after casting)",
ccx.tn.val_to_string(llarg_rust));
ccx.tn().val_to_string(llarg_rust));
// Finally, load the value if needed for the foreign ABI
let foreign_indirect = arg_tys[i].is_indirect();
@ -360,7 +360,7 @@ pub fn trans_native_call<'a>(
};
debug!("argument {}, llarg_foreign={}",
i, ccx.tn.val_to_string(llarg_foreign));
i, ccx.tn().val_to_string(llarg_foreign));
// fill padding with undef value
match arg_tys[i].pad {
@ -438,10 +438,10 @@ pub fn trans_native_call<'a>(
None => fn_type.ret_ty.ty
};
debug!("llretptr={}", ccx.tn.val_to_string(llretptr));
debug!("llforeign_retval={}", ccx.tn.val_to_string(llforeign_retval));
debug!("llrust_ret_ty={}", ccx.tn.type_to_string(llrust_ret_ty));
debug!("llforeign_ret_ty={}", ccx.tn.type_to_string(llforeign_ret_ty));
debug!("llretptr={}", ccx.tn().val_to_string(llretptr));
debug!("llforeign_retval={}", ccx.tn().val_to_string(llforeign_retval));
debug!("llrust_ret_ty={}", ccx.tn().type_to_string(llrust_ret_ty));
debug!("llforeign_ret_ty={}", ccx.tn().type_to_string(llforeign_ret_ty));
if llrust_ret_ty == llforeign_ret_ty {
base::store_ty(bcx, llforeign_retval, llretptr, fn_sig.output)
@ -496,7 +496,7 @@ pub fn trans_foreign_mod(ccx: &CrateContext, foreign_mod: &ast::ForeignMod) {
_ => {}
}
ccx.item_symbols.borrow_mut().insert(foreign_item.id,
ccx.item_symbols().borrow_mut().insert(foreign_item.id,
lname.get().to_string());
}
}
@ -542,7 +542,7 @@ pub fn decl_rust_fn_with_foreign_abi(ccx: &CrateContext,
let llfn = base::decl_fn(ccx, name, cconv, llfn_ty, ty::mk_nil());
add_argument_attributes(&tys, llfn);
debug!("decl_rust_fn_with_foreign_abi(llfn_ty={}, llfn={})",
ccx.tn.type_to_string(llfn_ty), ccx.tn.val_to_string(llfn));
ccx.tn().type_to_string(llfn_ty), ccx.tn().val_to_string(llfn));
llfn
}
@ -566,7 +566,7 @@ pub fn register_rust_fn_with_foreign_abi(ccx: &CrateContext,
let llfn = base::register_fn_llvmty(ccx, sp, sym, node_id, cconv, llfn_ty);
add_argument_attributes(&tys, llfn);
debug!("register_rust_fn_with_foreign_abi(node_id={:?}, llfn_ty={}, llfn={})",
node_id, ccx.tn.type_to_string(llfn_ty), ccx.tn.val_to_string(llfn));
node_id, ccx.tn().type_to_string(llfn_ty), ccx.tn().val_to_string(llfn));
llfn
}
@ -605,7 +605,7 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
let t = ty::node_id_to_type(tcx, id).subst(
ccx.tcx(), &param_substs.substs);
let ps = ccx.tcx.map.with_path(id, |path| {
let ps = ccx.tcx().map.with_path(id, |path| {
let abi = Some(ast_map::PathName(special_idents::clownshoe_abi.name));
link::mangle(path.chain(abi.move_iter()), hash)
});
@ -619,13 +619,13 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
_ => {
ccx.sess().bug(format!("build_rust_fn: extern fn {} has ty {}, \
expected a bare fn ty",
ccx.tcx.map.path_to_string(id),
ccx.tcx().map.path_to_string(id),
t.repr(tcx)).as_slice());
}
};
debug!("build_rust_fn: path={} id={} t={}",
ccx.tcx.map.path_to_string(id),
ccx.tcx().map.path_to_string(id),
id, t.repr(tcx));
let llfn = base::decl_internal_rust_fn(ccx, t, ps.as_slice());
@ -644,8 +644,8 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
let tcx = ccx.tcx();
debug!("build_wrap_fn(llrustfn={}, llwrapfn={}, t={})",
ccx.tn.val_to_string(llrustfn),
ccx.tn.val_to_string(llwrapfn),
ccx.tn().val_to_string(llrustfn),
ccx.tn().val_to_string(llwrapfn),
t.repr(ccx.tcx()));
// Avoid all the Rust generation stuff and just generate raw
@ -661,7 +661,7 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
let the_block =
"the block".with_c_str(
|s| llvm::LLVMAppendBasicBlockInContext(ccx.llcx, llwrapfn, s));
|s| llvm::LLVMAppendBasicBlockInContext(ccx.llcx(), llwrapfn, s));
let builder = ccx.builder();
builder.position_at_end(the_block);
@ -702,11 +702,11 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
match foreign_outptr {
Some(llforeign_outptr) => {
debug!("out pointer, foreign={}",
ccx.tn.val_to_string(llforeign_outptr));
ccx.tn().val_to_string(llforeign_outptr));
let llrust_retptr =
builder.bitcast(llforeign_outptr, llrust_ret_ty.ptr_to());
debug!("out pointer, foreign={} (casted)",
ccx.tn.val_to_string(llrust_retptr));
ccx.tn().val_to_string(llrust_retptr));
llrust_args.push(llrust_retptr);
return_alloca = None;
}
@ -717,8 +717,8 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
allocad={}, \
llrust_ret_ty={}, \
return_ty={}",
ccx.tn.val_to_string(slot),
ccx.tn.type_to_string(llrust_ret_ty),
ccx.tn().val_to_string(slot),
ccx.tn().type_to_string(llrust_ret_ty),
tys.fn_sig.output.repr(tcx));
llrust_args.push(slot);
return_alloca = Some(slot);
@ -752,7 +752,7 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
let mut llforeign_arg = get_param(llwrapfn, foreign_index);
debug!("llforeign_arg {}{}: {}", "#",
i, ccx.tn.val_to_string(llforeign_arg));
i, ccx.tn().val_to_string(llforeign_arg));
debug!("rust_indirect = {}, foreign_indirect = {}",
rust_indirect, foreign_indirect);
@ -791,12 +791,13 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
};
debug!("llrust_arg {}{}: {}", "#",
i, ccx.tn.val_to_string(llrust_arg));
i, ccx.tn().val_to_string(llrust_arg));
llrust_args.push(llrust_arg);
}
// Perform the call itself
debug!("calling llrustfn = {}, t = {}", ccx.tn.val_to_string(llrustfn), t.repr(ccx.tcx()));
debug!("calling llrustfn = {}, t = {}",
ccx.tn().val_to_string(llrustfn), t.repr(ccx.tcx()));
let attributes = base::get_fn_llvm_attributes(ccx, t);
let llrust_ret_val = builder.call(llrustfn, llrust_args.as_slice(), Some(attributes));
@ -915,10 +916,10 @@ fn foreign_types_for_fn_ty(ccx: &CrateContext,
fn_ty={} -> {}, \
ret_def={}",
ty.repr(ccx.tcx()),
ccx.tn.types_to_str(llsig.llarg_tys.as_slice()),
ccx.tn.type_to_string(llsig.llret_ty),
ccx.tn.types_to_str(fn_ty.arg_tys.iter().map(|t| t.ty).collect::<Vec<_>>().as_slice()),
ccx.tn.type_to_string(fn_ty.ret_ty.ty),
ccx.tn().types_to_str(llsig.llarg_tys.as_slice()),
ccx.tn().type_to_string(llsig.llret_ty),
ccx.tn().types_to_str(fn_ty.arg_tys.iter().map(|t| t.ty).collect::<Vec<_>>().as_slice()),
ccx.tn().type_to_string(fn_ty.ret_ty.ty),
ret_def);
ForeignTypes {

20
src/librustc/middle/trans/glue.rs
View file

@ -159,7 +159,7 @@ pub fn get_drop_glue(ccx: &CrateContext, t: ty::t) -> ValueRef {
debug!("make drop glue for {}", ppaux::ty_to_string(ccx.tcx(), t));
let t = get_drop_glue_type(ccx, t);
debug!("drop glue type {}", ppaux::ty_to_string(ccx.tcx(), t));
match ccx.drop_glues.borrow().find(&t) {
match ccx.drop_glues().borrow().find(&t) {
Some(&glue) => return glue,
_ => { }
}
@ -173,7 +173,7 @@ pub fn get_drop_glue(ccx: &CrateContext, t: ty::t) -> ValueRef {
let llfnty = Type::glue_fn(ccx, llty);
let glue = declare_generic_glue(ccx, t, llfnty, "drop");
ccx.drop_glues.borrow_mut().insert(t, glue);
ccx.drop_glues().borrow_mut().insert(t, glue);
make_generic_glue(ccx, t, glue, make_drop_glue, "drop");
@ -566,7 +566,7 @@ fn incr_refcnt_of_boxed<'a>(bcx: &'a Block<'a>,
pub fn declare_tydesc(ccx: &CrateContext, t: ty::t) -> tydesc_info {
// If emit_tydescs already ran, then we shouldn't be creating any new
// tydescs.
assert!(!ccx.finished_tydescs.get());
assert!(!ccx.finished_tydescs().get());
let llty = type_of(ccx, t);
@ -581,7 +581,7 @@ pub fn declare_tydesc(ccx: &CrateContext, t: ty::t) -> tydesc_info {
debug!("+++ declare_tydesc {} {}", ppaux::ty_to_string(ccx.tcx(), t), name);
let gvar = name.as_slice().with_c_str(|buf| {
unsafe {
llvm::LLVMAddGlobal(ccx.llmod, ccx.tydesc_type().to_ref(), buf)
llvm::LLVMAddGlobal(ccx.llmod(), ccx.tydesc_type().to_ref(), buf)
}
});
note_unique_llvm_symbol(ccx, name);
@ -632,7 +632,7 @@ fn make_generic_glue(ccx: &CrateContext,
let bcx = init_function(&fcx, false, ty::mk_nil());
llvm::SetLinkage(llfn, llvm::InternalLinkage);
ccx.stats.n_glues_created.set(ccx.stats.n_glues_created.get() + 1u);
ccx.stats().n_glues_created.set(ccx.stats().n_glues_created.get() + 1u);
// All glue functions take values passed *by alias*; this is a
// requirement since in many contexts glue is invoked indirectly and
// the caller has no idea if it's dealing with something that can be
@ -651,9 +651,9 @@ fn make_generic_glue(ccx: &CrateContext,
pub fn emit_tydescs(ccx: &CrateContext) {
let _icx = push_ctxt("emit_tydescs");
// As of this point, allow no more tydescs to be created.
ccx.finished_tydescs.set(true);
ccx.finished_tydescs().set(true);
let glue_fn_ty = Type::generic_glue_fn(ccx).ptr_to();
for (_, ti) in ccx.tydescs.borrow().iter() {
for (_, ti) in ccx.tydescs().borrow().iter() {
// Each of the glue functions needs to be cast to a generic type
// before being put into the tydesc because we only have a singleton
// tydesc type. Then we'll recast each function to its real type when
@ -661,17 +661,17 @@ pub fn emit_tydescs(ccx: &CrateContext) {
let drop_glue = unsafe {
llvm::LLVMConstPointerCast(get_drop_glue(ccx, ti.ty), glue_fn_ty.to_ref())
};
ccx.stats.n_real_glues.set(ccx.stats.n_real_glues.get() + 1);
ccx.stats().n_real_glues.set(ccx.stats().n_real_glues.get() + 1);
let visit_glue =
match ti.visit_glue.get() {
None => {
ccx.stats.n_null_glues.set(ccx.stats.n_null_glues.get() +
ccx.stats().n_null_glues.set(ccx.stats().n_null_glues.get() +
1u);
C_null(glue_fn_ty)
}
Some(v) => {
unsafe {
ccx.stats.n_real_glues.set(ccx.stats.n_real_glues.get() +
ccx.stats().n_real_glues.set(ccx.stats().n_real_glues.get() +
1);
llvm::LLVMConstPointerCast(v, glue_fn_ty.to_ref())
}

28
src/librustc/middle/trans/inline.rs
View file

@ -22,7 +22,7 @@ use syntax::ast_util;
pub fn maybe_instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
-> ast::DefId {
let _icx = push_ctxt("maybe_instantiate_inline");
match ccx.external.borrow().find(&fn_id) {
match ccx.external().borrow().find(&fn_id) {
Some(&Some(node_id)) => {
// Already inline
debug!("maybe_instantiate_inline({}): already inline as node id {}",
@ -43,14 +43,14 @@ pub fn maybe_instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
|a,b,c,d| astencode::decode_inlined_item(a, b, c, d));
return match csearch_result {
csearch::not_found => {
ccx.external.borrow_mut().insert(fn_id, None);
ccx.external().borrow_mut().insert(fn_id, None);
fn_id
}
csearch::found(ast::IIItem(item)) => {
ccx.external.borrow_mut().insert(fn_id, Some(item.id));
ccx.external_srcs.borrow_mut().insert(item.id, fn_id);
ccx.external().borrow_mut().insert(fn_id, Some(item.id));
ccx.external_srcs().borrow_mut().insert(item.id, fn_id);
ccx.stats.n_inlines.set(ccx.stats.n_inlines.get() + 1);
ccx.stats().n_inlines.set(ccx.stats().n_inlines.get() + 1);
trans_item(ccx, &*item);
// We're bringing an external global into this crate, but we don't
@ -78,13 +78,13 @@ pub fn maybe_instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
local_def(item.id)
}
csearch::found(ast::IIForeign(item)) => {
ccx.external.borrow_mut().insert(fn_id, Some(item.id));
ccx.external_srcs.borrow_mut().insert(item.id, fn_id);
ccx.external().borrow_mut().insert(fn_id, Some(item.id));
ccx.external_srcs().borrow_mut().insert(item.id, fn_id);
local_def(item.id)
}
csearch::found_parent(parent_id, ast::IIItem(item)) => {
ccx.external.borrow_mut().insert(parent_id, Some(item.id));
ccx.external_srcs.borrow_mut().insert(item.id, parent_id);
ccx.external().borrow_mut().insert(parent_id, Some(item.id));
ccx.external_srcs().borrow_mut().insert(item.id, parent_id);
let mut my_id = 0;
match item.node {
@ -93,14 +93,14 @@ pub fn maybe_instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
let vs_there = ty::enum_variants(ccx.tcx(), parent_id);
for (here, there) in vs_here.iter().zip(vs_there.iter()) {
if there.id == fn_id { my_id = here.id.node; }
ccx.external.borrow_mut().insert(there.id, Some(here.id.node));
ccx.external().borrow_mut().insert(there.id, Some(here.id.node));
}
}
ast::ItemStruct(ref struct_def, _) => {
match struct_def.ctor_id {
None => {}
Some(ctor_id) => {
ccx.external.borrow_mut().insert(fn_id, Some(ctor_id));
ccx.external().borrow_mut().insert(fn_id, Some(ctor_id));
my_id = ctor_id;
}
}
@ -119,10 +119,10 @@ pub fn maybe_instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
match impl_item {
ast::ProvidedInlinedTraitItem(mth) |
ast::RequiredInlinedTraitItem(mth) => {
ccx.external.borrow_mut().insert(fn_id, Some(mth.id));
ccx.external_srcs.borrow_mut().insert(mth.id, fn_id);
ccx.external().borrow_mut().insert(fn_id, Some(mth.id));
ccx.external_srcs().borrow_mut().insert(mth.id, fn_id);
ccx.stats.n_inlines.set(ccx.stats.n_inlines.get() + 1);
ccx.stats().n_inlines.set(ccx.stats().n_inlines.get() + 1);
}
}

8
src/librustc/middle/trans/intrinsic.rs
View file

@ -89,7 +89,7 @@ pub fn get_simple_intrinsic(ccx: &CrateContext, item: &ast::ForeignItem) -> Opti
/// Performs late verification that intrinsics are used correctly. At present,
/// the only intrinsic that needs such verification is `transmute`.
pub fn check_intrinsics(ccx: &CrateContext) {
for transmute_restriction in ccx.tcx
for transmute_restriction in ccx.tcx()
.transmute_restrictions
.borrow()
.iter() {
@ -276,7 +276,7 @@ pub fn trans_intrinsic_call<'a>(mut bcx: &'a Block<'a>, node: ast::NodeId,
let hash = ty::hash_crate_independent(
ccx.tcx(),
*substs.types.get(FnSpace, 0),
&ccx.link_meta.crate_hash);
&ccx.link_meta().crate_hash);
// NB: This needs to be kept in lockstep with the TypeId struct in
// the intrinsic module
C_named_struct(llret_ty, [C_u64(ccx, hash)])
@ -554,7 +554,7 @@ fn copy_intrinsic(bcx: &Block, allow_overlap: bool, volatile: bool,
let lltp_ty = type_of::type_of(ccx, tp_ty);
let align = C_i32(ccx, type_of::align_of(ccx, tp_ty) as i32);
let size = machine::llsize_of(ccx, lltp_ty);
let int_size = machine::llbitsize_of_real(ccx, ccx.int_type);
let int_size = machine::llbitsize_of_real(ccx, ccx.int_type());
let name = if allow_overlap {
if int_size == 32 {
"llvm.memmove.p0i8.p0i8.i32"
@ -583,7 +583,7 @@ fn memset_intrinsic(bcx: &Block, volatile: bool, tp_ty: ty::t,
let lltp_ty = type_of::type_of(ccx, tp_ty);
let align = C_i32(ccx, type_of::align_of(ccx, tp_ty) as i32);
let size = machine::llsize_of(ccx, lltp_ty);
let name = if machine::llbitsize_of_real(ccx, ccx.int_type) == 32 {
let name = if machine::llbitsize_of_real(ccx, ccx.int_type()) == 32 {
"llvm.memset.p0i8.i32"
} else {
"llvm.memset.p0i8.i64"

4
src/librustc/middle/trans/llrepr.rs
View file

@ -25,13 +25,13 @@ impl<'a, T:LlvmRepr> LlvmRepr for &'a [T] {
impl LlvmRepr for Type {
fn llrepr(&self, ccx: &CrateContext) -> String {
ccx.tn.type_to_string(*self)
ccx.tn().type_to_string(*self)
}
}
impl LlvmRepr for ValueRef {
fn llrepr(&self, ccx: &CrateContext) -> String {
ccx.tn.val_to_string(*self)
ccx.tn().val_to_string(*self)
}
}

18
src/librustc/middle/trans/machine.rs
View file

@ -23,7 +23,7 @@ use middle::trans::type_::Type;
// Returns the number of bytes clobbered by a Store to this type.
pub fn llsize_of_store(cx: &CrateContext, ty: Type) -> u64 {
unsafe {
return llvm::LLVMStoreSizeOfType(cx.td.lltd, ty.to_ref()) as u64;
return llvm::LLVMStoreSizeOfType(cx.td().lltd, ty.to_ref()) as u64;
}
}
@ -31,7 +31,7 @@ pub fn llsize_of_store(cx: &CrateContext, ty: Type) -> u64 {
// array of T. This is the "ABI" size. It includes any ABI-mandated padding.
pub fn llsize_of_alloc(cx: &CrateContext, ty: Type) -> u64 {
unsafe {
return llvm::LLVMABISizeOfType(cx.td.lltd, ty.to_ref()) as u64;
return llvm::LLVMABISizeOfType(cx.td().lltd, ty.to_ref()) as u64;
}
}
@ -45,7 +45,7 @@ pub fn llsize_of_alloc(cx: &CrateContext, ty: Type) -> u64 {
// below.
pub fn llsize_of_real(cx: &CrateContext, ty: Type) -> u64 {
unsafe {
let nbits = llvm::LLVMSizeOfTypeInBits(cx.td.lltd, ty.to_ref()) as u64;
let nbits = llvm::LLVMSizeOfTypeInBits(cx.td().lltd, ty.to_ref()) as u64;
if nbits & 7 != 0 {
// Not an even number of bytes, spills into "next" byte.
1 + (nbits >> 3)
@ -58,7 +58,7 @@ pub fn llsize_of_real(cx: &CrateContext, ty: Type) -> u64 {
/// Returns the "real" size of the type in bits.
pub fn llbitsize_of_real(cx: &CrateContext, ty: Type) -> u64 {
unsafe {
llvm::LLVMSizeOfTypeInBits(cx.td.lltd, ty.to_ref()) as u64
llvm::LLVMSizeOfTypeInBits(cx.td().lltd, ty.to_ref()) as u64
}
}
@ -79,7 +79,7 @@ pub fn llsize_of(cx: &CrateContext, ty: Type) -> ValueRef {
// space to be consumed.
pub fn nonzero_llsize_of(cx: &CrateContext, ty: Type) -> ValueRef {
if llbitsize_of_real(cx, ty) == 0 {
unsafe { llvm::LLVMConstInt(cx.int_type.to_ref(), 1, False) }
unsafe { llvm::LLVMConstInt(cx.int_type().to_ref(), 1, False) }
} else {
llsize_of(cx, ty)
}
@ -91,7 +91,7 @@ pub fn nonzero_llsize_of(cx: &CrateContext, ty: Type) -> ValueRef {
// allocations inside a stack frame, which LLVM has a free hand in.
pub fn llalign_of_pref(cx: &CrateContext, ty: Type) -> u64 {
unsafe {
return llvm::LLVMPreferredAlignmentOfType(cx.td.lltd, ty.to_ref()) as u64;
return llvm::LLVMPreferredAlignmentOfType(cx.td().lltd, ty.to_ref()) as u64;
}
}
@ -100,7 +100,7 @@ pub fn llalign_of_pref(cx: &CrateContext, ty: Type) -> u64 {
// and similar ABI-mandated things.
pub fn llalign_of_min(cx: &CrateContext, ty: Type) -> u64 {
unsafe {
return llvm::LLVMABIAlignmentOfType(cx.td.lltd, ty.to_ref()) as u64;
return llvm::LLVMABIAlignmentOfType(cx.td().lltd, ty.to_ref()) as u64;
}
}
@ -110,12 +110,12 @@ pub fn llalign_of_min(cx: &CrateContext, ty: Type) -> u64 {
pub fn llalign_of(cx: &CrateContext, ty: Type) -> ValueRef {
unsafe {
return llvm::LLVMConstIntCast(
llvm::LLVMAlignOf(ty.to_ref()), cx.int_type.to_ref(), False);
llvm::LLVMAlignOf(ty.to_ref()), cx.int_type().to_ref(), False);
}
}
pub fn llelement_offset(cx: &CrateContext, struct_ty: Type, element: uint) -> u64 {
unsafe {
return llvm::LLVMOffsetOfElement(cx.td.lltd, struct_ty.to_ref(), element as u32) as u64;
return llvm::LLVMOffsetOfElement(cx.td().lltd, struct_ty.to_ref(), element as u32) as u64;
}
}

20
src/librustc/middle/trans/meth.rs
View file

@ -196,7 +196,7 @@ pub fn trans_static_method_callee(bcx: &Block,
let vtable_key = MethodCall::expr(expr_id);
let vtbls = resolve_vtables_in_fn_ctxt(
bcx.fcx,
ccx.tcx.vtable_map.borrow().get(&vtable_key));
ccx.tcx().vtable_map.borrow().get(&vtable_key));
match *vtbls.get_self().unwrap().get(0) {
typeck::vtable_static(impl_did, ref rcvr_substs, ref rcvr_origins) => {
@ -228,12 +228,12 @@ pub fn trans_static_method_callee(bcx: &Block,
fn method_with_name(ccx: &CrateContext, impl_id: ast::DefId, name: ast::Name)
-> ast::DefId {
match ccx.impl_method_cache.borrow().find_copy(&(impl_id, name)) {
match ccx.impl_method_cache().borrow().find_copy(&(impl_id, name)) {
Some(m) => return m,
None => {}
}
let impl_items = ccx.tcx.impl_items.borrow();
let impl_items = ccx.tcx().impl_items.borrow();
let impl_items =
impl_items.find(&impl_id)
.expect("could not find impl while translating");
@ -241,7 +241,7 @@ fn method_with_name(ccx: &CrateContext, impl_id: ast::DefId, name: ast::Name)
.find(|&did| {
match *did {
ty::MethodTraitItemId(did) => {
ty::impl_or_trait_item(&ccx.tcx,
ty::impl_or_trait_item(ccx.tcx(),
did).ident()
.name ==
name
@ -250,7 +250,7 @@ fn method_with_name(ccx: &CrateContext, impl_id: ast::DefId, name: ast::Name)
}).expect("could not find method while \
translating");
ccx.impl_method_cache.borrow_mut().insert((impl_id, name),
ccx.impl_method_cache().borrow_mut().insert((impl_id, name),
meth_did.def_id());
meth_did.def_id()
}
@ -502,7 +502,7 @@ fn get_vtable(bcx: &Block,
// Check the cache.
let hash_id = (self_ty, monomorphize::make_vtable_id(ccx, origins.get(0)));
match ccx.vtables.borrow().find(&hash_id) {
match ccx.vtables().borrow().find(&hash_id) {
Some(&val) => { return val }
None => { }
}
@ -594,7 +594,7 @@ fn get_vtable(bcx: &Block,
let drop_glue = glue::get_drop_glue(ccx, self_ty);
let vtable = make_vtable(ccx, drop_glue, ll_size, ll_align, methods);
ccx.vtables.borrow_mut().insert(hash_id, vtable);
ccx.vtables().borrow_mut().insert(hash_id, vtable);
vtable
}
@ -614,7 +614,7 @@ pub fn make_vtable<I: Iterator<ValueRef>>(ccx: &CrateContext,
let tbl = C_struct(ccx, components.as_slice(), false);
let sym = token::gensym("vtable");
let vt_gvar = format!("vtable{}", sym.uint()).with_c_str(|buf| {
llvm::LLVMAddGlobal(ccx.llmod, val_ty(tbl).to_ref(), buf)
llvm::LLVMAddGlobal(ccx.llmod(), val_ty(tbl).to_ref(), buf)
});
llvm::LLVMSetInitializer(vt_gvar, tbl);
llvm::LLVMSetGlobalConstant(vt_gvar, llvm::True);
@ -684,9 +684,9 @@ pub fn vtable_ptr<'a>(bcx: &'a Block<'a>,
self_ty: ty::t) -> ValueRef {
let ccx = bcx.ccx();
let origins = {
let vtable_map = ccx.tcx.vtable_map.borrow();
let vtable_map = ccx.tcx().vtable_map.borrow();
// This trait cast might be because of implicit coercion
let adjs = ccx.tcx.adjustments.borrow();
let adjs = ccx.tcx().adjustments.borrow();
let adjust = adjs.find(&id);
let method_call = if adjust.is_some() && ty::adjust_is_object(adjust.unwrap()) {
MethodCall::autoobject(id)

20
src/librustc/middle/trans/monomorphize.rs
View file

@ -56,7 +56,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
params: real_substs.types.clone()
};
match ccx.monomorphized.borrow().find(&hash_id) {
match ccx.monomorphized().borrow().find(&hash_id) {
Some(&val) => {
debug!("leaving monomorphic fn {}",
ty::item_path_str(ccx.tcx(), fn_id));
@ -83,7 +83,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
let map_node = session::expect(
ccx.sess(),
ccx.tcx.map.find(fn_id.node),
ccx.tcx().map.find(fn_id.node),
|| {
format!("while monomorphizing {:?}, couldn't find it in \
the item map (may have attempted to monomorphize \
@ -93,7 +93,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
match map_node {
ast_map::NodeForeignItem(_) => {
if ccx.tcx.map.get_foreign_abi(fn_id.node) != abi::RustIntrinsic {
if ccx.tcx().map.get_foreign_abi(fn_id.node) != abi::RustIntrinsic {
// Foreign externs don't have to be monomorphized.
return (get_item_val(ccx, fn_id.node), true);
}
@ -104,11 +104,11 @@ pub fn monomorphic_fn(ccx: &CrateContext,
debug!("monomorphic_fn about to subst into {}", llitem_ty.repr(ccx.tcx()));
let mono_ty = llitem_ty.subst(ccx.tcx(), real_substs);
ccx.stats.n_monos.set(ccx.stats.n_monos.get() + 1);
ccx.stats().n_monos.set(ccx.stats().n_monos.get() + 1);
let depth;
{
let mut monomorphizing = ccx.monomorphizing.borrow_mut();
let mut monomorphizing = ccx.monomorphizing().borrow_mut();
depth = match monomorphizing.find(&fn_id) {
Some(&d) => d, None => 0
};
@ -117,7 +117,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
// recursively more than thirty times can probably safely be assumed
// to be causing an infinite expansion.
if depth > ccx.sess().recursion_limit.get() {
ccx.sess().span_fatal(ccx.tcx.map.span(fn_id.node),
ccx.sess().span_fatal(ccx.tcx().map.span(fn_id.node),
"reached the recursion limit during monomorphization");
}
@ -131,7 +131,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
mono_ty.hash(&mut state);
hash = format!("h{}", state.result());
ccx.tcx.map.with_path(fn_id.node, |path| {
ccx.tcx().map.with_path(fn_id.node, |path| {
exported_name(path, hash.as_slice())
})
};
@ -147,7 +147,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
decl_internal_rust_fn(ccx, mono_ty, s.as_slice())
};
ccx.monomorphized.borrow_mut().insert(hash_id.take().unwrap(), lldecl);
ccx.monomorphized().borrow_mut().insert(hash_id.take().unwrap(), lldecl);
lldecl
};
@ -177,7 +177,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
}
}
ast_map::NodeVariant(v) => {
let parent = ccx.tcx.map.get_parent(fn_id.node);
let parent = ccx.tcx().map.get_parent(fn_id.node);
let tvs = ty::enum_variants(ccx.tcx(), local_def(parent));
let this_tv = tvs.iter().find(|tv| { tv.id.node == fn_id.node}).unwrap();
let d = mk_lldecl(abi::Rust);
@ -254,7 +254,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
}
};
ccx.monomorphizing.borrow_mut().insert(fn_id, depth);
ccx.monomorphizing().borrow_mut().insert(fn_id, depth);
debug!("leaving monomorphic fn {}", ty::item_path_str(ccx.tcx(), fn_id));
(lldecl, true)

2
src/librustc/middle/trans/reflect.rs
View file

@ -335,7 +335,7 @@ impl<'a, 'b> Reflector<'a, 'b> {
let sym = mangle_internal_name_by_path_and_seq(
ast_map::Values([].iter()).chain(None), "get_disr");
let fn_ty = ty::mk_ctor_fn(&ccx.tcx, ast::DUMMY_NODE_ID,
let fn_ty = ty::mk_ctor_fn(ccx.tcx(), ast::DUMMY_NODE_ID,
[opaqueptrty], ty::mk_u64());
let llfdecl = decl_internal_rust_fn(ccx,
fn_ty,

6
src/librustc/middle/trans/tvec.rs
View file

@ -94,8 +94,8 @@ impl VecTypes {
format!("VecTypes {{unit_ty={}, llunit_ty={}, \
llunit_size={}, llunit_alloc_size={}}}",
ty_to_string(ccx.tcx(), self.unit_ty),
ccx.tn.type_to_string(self.llunit_ty),
ccx.tn.val_to_string(self.llunit_size),
ccx.tn().type_to_string(self.llunit_ty),
ccx.tn().val_to_string(self.llunit_size),
self.llunit_alloc_size)
}
}
@ -546,7 +546,7 @@ pub fn iter_vec_loop<'r,
let loop_counter = {
// i = 0
let i = alloca(loop_bcx, bcx.ccx().int_type, "__i");
let i = alloca(loop_bcx, bcx.ccx().int_type(), "__i");
Store(loop_bcx, C_uint(bcx.ccx(), 0), i);
Br(loop_bcx, cond_bcx.llbb);

34
src/librustc/middle/trans/type_.rs
View file

@ -53,7 +53,7 @@ impl Type {
}
pub fn void(ccx: &CrateContext) -> Type {
ty!(llvm::LLVMVoidTypeInContext(ccx.llcx))
ty!(llvm::LLVMVoidTypeInContext(ccx.llcx()))
}
pub fn nil(ccx: &CrateContext) -> Type {
@ -61,35 +61,35 @@ impl Type {
}
pub fn metadata(ccx: &CrateContext) -> Type {
ty!(llvm::LLVMMetadataTypeInContext(ccx.llcx))
ty!(llvm::LLVMMetadataTypeInContext(ccx.llcx()))
}
pub fn i1(ccx: &CrateContext) -> Type {
ty!(llvm::LLVMInt1TypeInContext(ccx.llcx))
ty!(llvm::LLVMInt1TypeInContext(ccx.llcx()))
}
pub fn i8(ccx: &CrateContext) -> Type {
ty!(llvm::LLVMInt8TypeInContext(ccx.llcx))
ty!(llvm::LLVMInt8TypeInContext(ccx.llcx()))
}
pub fn i16(ccx: &CrateContext) -> Type {
ty!(llvm::LLVMInt16TypeInContext(ccx.llcx))
ty!(llvm::LLVMInt16TypeInContext(ccx.llcx()))
}
pub fn i32(ccx: &CrateContext) -> Type {
ty!(llvm::LLVMInt32TypeInContext(ccx.llcx))
ty!(llvm::LLVMInt32TypeInContext(ccx.llcx()))
}
pub fn i64(ccx: &CrateContext) -> Type {
ty!(llvm::LLVMInt64TypeInContext(ccx.llcx))
ty!(llvm::LLVMInt64TypeInContext(ccx.llcx()))
}
pub fn f32(ccx: &CrateContext) -> Type {
ty!(llvm::LLVMFloatTypeInContext(ccx.llcx))
ty!(llvm::LLVMFloatTypeInContext(ccx.llcx()))
}
pub fn f64(ccx: &CrateContext) -> Type {
ty!(llvm::LLVMDoubleTypeInContext(ccx.llcx))
ty!(llvm::LLVMDoubleTypeInContext(ccx.llcx()))
}
pub fn bool(ccx: &CrateContext) -> Type {
@ -105,7 +105,7 @@ impl Type {
}
pub fn int(ccx: &CrateContext) -> Type {
match ccx.tcx.sess.targ_cfg.arch {
match ccx.tcx().sess.targ_cfg.arch {
X86 | Arm | Mips | Mipsel => Type::i32(ccx),
X86_64 => Type::i64(ccx)
}
@ -113,7 +113,7 @@ impl Type {
pub fn int_from_ty(ccx: &CrateContext, t: ast::IntTy) -> Type {
match t {
ast::TyI => ccx.int_type,
ast::TyI => ccx.int_type(),
ast::TyI8 => Type::i8(ccx),
ast::TyI16 => Type::i16(ccx),
ast::TyI32 => Type::i32(ccx),
@ -123,7 +123,7 @@ impl Type {
pub fn uint_from_ty(ccx: &CrateContext, t: ast::UintTy) -> Type {
match t {
ast::TyU => ccx.int_type,
ast::TyU => ccx.int_type(),
ast::TyU8 => Type::i8(ccx),
ast::TyU16 => Type::i16(ccx),
ast::TyU32 => Type::i32(ccx),
@ -152,13 +152,13 @@ impl Type {
pub fn struct_(ccx: &CrateContext, els: &[Type], packed: bool) -> Type {
let els : &[TypeRef] = unsafe { mem::transmute(els) };
ty!(llvm::LLVMStructTypeInContext(ccx.llcx, els.as_ptr(),
ty!(llvm::LLVMStructTypeInContext(ccx.llcx(), els.as_ptr(),
els.len() as c_uint,
packed as Bool))
}
pub fn named_struct(ccx: &CrateContext, name: &str) -> Type {
ty!(name.with_c_str(|s| llvm::LLVMStructCreateNamed(ccx.llcx, s)))
ty!(name.with_c_str(|s| llvm::LLVMStructCreateNamed(ccx.llcx(), s)))
}
pub fn empty_struct(ccx: &CrateContext) -> Type {
@ -170,13 +170,13 @@ impl Type {
}
pub fn generic_glue_fn(cx: &CrateContext) -> Type {
match cx.tn.find_type("glue_fn") {
match cx.tn().find_type("glue_fn") {
Some(ty) => return ty,
None => ()
}
let ty = Type::glue_fn(cx, Type::i8p(cx));
cx.tn.associate_type("glue_fn", &ty);
cx.tn().associate_type("glue_fn", &ty);
ty
}
@ -226,7 +226,7 @@ impl Type {
// The box pointed to by @T.
pub fn at_box(ccx: &CrateContext, ty: Type) -> Type {
Type::struct_(ccx, [
ccx.int_type, Type::glue_fn(ccx, Type::i8p(ccx)).ptr_to(),
ccx.int_type(), Type::glue_fn(ccx, Type::i8p(ccx)).ptr_to(),
Type::i8p(ccx), Type::i8p(ccx), ty
], false)
}

16
src/librustc/middle/trans/type_of.rs
View file

@ -156,7 +156,7 @@ pub fn type_of_fn_from_ty(cx: &CrateContext, fty: ty::t) -> Type {
// recursive types. For example, enum types rely on this behavior.
pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
match cx.llsizingtypes.borrow().find_copy(&t) {
match cx.llsizingtypes().borrow().find_copy(&t) {
Some(t) => return t,
None => ()
}
@ -217,7 +217,7 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
ty::ty_vec(_, None) | ty::ty_trait(..) | ty::ty_str => fail!("unreachable")
};
cx.llsizingtypes.borrow_mut().insert(t, llsizingty);
cx.llsizingtypes().borrow_mut().insert(t, llsizingty);
llsizingty
}
@ -249,7 +249,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
}
// Check the cache.
match cx.lltypes.borrow().find(&t) {
match cx.lltypes().borrow().find(&t) {
Some(&llty) => return llty,
None => ()
}
@ -270,8 +270,8 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
t,
t_norm.repr(cx.tcx()),
t_norm,
cx.tn.type_to_string(llty));
cx.lltypes.borrow_mut().insert(t, llty);
cx.tn().type_to_string(llty));
cx.lltypes().borrow_mut().insert(t, llty);
return llty;
}
@ -308,7 +308,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
ty::ty_str => {
// This means we get a nicer name in the output (str is always
// unsized).
cx.tn.find_type("str_slice").unwrap()
cx.tn().find_type("str_slice").unwrap()
}
ty::ty_trait(..) => Type::opaque_trait(cx),
_ if !ty::type_is_sized(cx.tcx(), ty) => {
@ -385,9 +385,9 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
debug!("--> mapped t={} {:?} to llty={}",
t.repr(cx.tcx()),
t,
cx.tn.type_to_string(llty));
cx.tn().type_to_string(llty));
cx.lltypes.borrow_mut().insert(t, llty);
cx.lltypes().borrow_mut().insert(t, llty);
// If this was an enum or struct, fill in the type now.
match ty::get(t).sty {