X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Flibrustc_trans%2Ftrans%2Fbase.rs;h=7460ef82ebee4d493e79f1b49fe5474565c1e3d9;hb=faf6d1e87391b25196b35909c3c95e5d873cacf0;hp=ea4259f8262a7b484c38314b0b12e0b5aa2a9934;hpb=00a4eeadaf10156e2e2b7a0c050c2ca1ac826f76;p=rust.git diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index ea4259f8262..7460ef82ebe 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -85,6 +85,7 @@ use trans::type_of; use trans::type_of::*; use trans::value::Value; +use trans::Disr; use util::common::indenter; use util::sha2::Sha256; use util::nodemap::{NodeMap, NodeSet}; @@ -489,7 +490,7 @@ fn iter_variant<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, for (i, field) in variant.fields.iter().enumerate() { let arg = monomorphize::field_ty(tcx, substs, field); cx = f(cx, - adt::trans_field_ptr(cx, repr, av, variant.disr_val, i), + adt::trans_field_ptr(cx, repr, av, Disr::from(variant.disr_val), i), arg); } return cx; @@ -509,7 +510,7 @@ fn iter_variant<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, let repr = adt::represent_type(cx.ccx(), t); let VariantInfo { fields, discr } = VariantInfo::from_ty(cx.tcx(), t, None); for (i, &Field(_, field_ty)) in fields.iter().enumerate() { - let llfld_a = adt::trans_field_ptr(cx, &*repr, value, discr, i); + let llfld_a = adt::trans_field_ptr(cx, &*repr, value, Disr::from(discr), i); let val = if common::type_is_sized(cx.tcx(), field_ty) { llfld_a @@ -525,7 +526,7 @@ fn iter_variant<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, ty::TyClosure(_, ref substs) => { let repr = adt::represent_type(cx.ccx(), t); for (i, upvar_ty) in substs.upvar_tys.iter().enumerate() { - let llupvar = adt::trans_field_ptr(cx, &*repr, value, 0, i); + let llupvar = adt::trans_field_ptr(cx, &*repr, value, Disr(0), i); cx = f(cx, llupvar, upvar_ty); } } @@ -541,7 +542,7 @@ fn iter_variant<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, ty::TyTuple(ref args) => { let repr = adt::represent_type(cx.ccx(), t); for (i, arg) in args.iter().enumerate() { - let llfld_a = adt::trans_field_ptr(cx, &*repr, value, 0, i); + let llfld_a = adt::trans_field_ptr(cx, &*repr, value, Disr(0), i); cx = f(cx, llfld_a, *arg); } } @@ -588,7 +589,7 @@ fn iter_variant<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, let variant_cx = fcx.new_temp_block(&format!("enum-iter-variant-{}", &variant.disr_val .to_string())); - let case_val = adt::trans_case(cx, &*repr, variant.disr_val); + let case_val = adt::trans_case(cx, &*repr, Disr::from(variant.disr_val)); AddCase(llswitch, case_val, variant_cx.llbb); let variant_cx = iter_variant(variant_cx, &*repr, @@ -720,8 +721,8 @@ pub fn coerce_unsized_into<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, continue; } - let src_f = adt::trans_field_ptr(bcx, &src_repr, src, 0, i); - let dst_f = adt::trans_field_ptr(bcx, &dst_repr, dst, 0, i); + let src_f = adt::trans_field_ptr(bcx, &src_repr, src, Disr(0), i); + let dst_f = adt::trans_field_ptr(bcx, &dst_repr, dst, Disr(0), i); if src_fty == dst_fty { memcpy_ty(bcx, dst_f, src_f, src_fty); } else { @@ -2111,7 +2112,7 @@ pub fn trans_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, pub fn trans_enum_variant<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ctor_id: ast::NodeId, - disr: ty::Disr, + disr: Disr, param_substs: &'tcx Substs<'tcx>, llfndecl: ValueRef) { let _icx = push_ctxt("trans_enum_variant"); @@ -2121,7 +2122,7 @@ pub fn trans_enum_variant<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, ctor_ty: Ty<'tcx>, - disr: ty::Disr, + disr: Disr, args: callee::CallArgs, dest: expr::Dest, debug_loc: DebugLoc) @@ -2197,12 +2198,12 @@ pub fn trans_tuple_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, llfndecl: ValueRef) { let _icx = push_ctxt("trans_tuple_struct"); - trans_enum_variant_or_tuple_like_struct(ccx, ctor_id, 0, param_substs, llfndecl); + trans_enum_variant_or_tuple_like_struct(ccx, ctor_id, Disr(0), param_substs, llfndecl); } fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ctor_id: ast::NodeId, - disr: ty::Disr, + disr: Disr, param_substs: &'tcx Substs<'tcx>, llfndecl: ValueRef) { let ctor_ty = ccx.tcx().node_id_to_type(ctor_id); @@ -2233,7 +2234,7 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx let repr = adt::represent_type(ccx, result_ty.unwrap()); let mut llarg_idx = fcx.arg_offset() as c_uint; for (i, arg_ty) in arg_tys.into_iter().enumerate() { - let lldestptr = adt::trans_field_ptr(bcx, &*repr, dest_val, disr, i); + let lldestptr = adt::trans_field_ptr(bcx, &*repr, dest_val, Disr::from(disr), i); if common::type_is_fat_ptr(bcx.tcx(), arg_ty) { Store(bcx, get_param(fcx.llfn, llarg_idx), @@ -3322,6 +3323,14 @@ fn visit_item(&mut self, i: &hir::Item) { // giving `trans_item` access to this item, so also record a read. tcx.dep_graph.with_task(DepNode::TransCrateItem(def_id), || { tcx.dep_graph.read(DepNode::Hir(def_id)); + + // We are going to be accessing various tables + // generated by TypeckItemBody; we also assume + // that the body passes type check. These tables + // are not individually tracked, so just register + // a read here. + tcx.dep_graph.read(DepNode::TypeckItemBody(def_id)); + trans_item(self.ccx, i); });