diff --git a/src/abi/mod.rs b/src/abi/mod.rs index 65613754d06..ec983667b1c 100644 --- a/src/abi/mod.rs +++ b/src/abi/mod.rs @@ -226,9 +226,9 @@ pub(crate) fn import_function<'tcx>( impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> { /// Instance must be monomorphized pub(crate) fn get_function_ref(&mut self, inst: Instance<'tcx>) -> FuncRef { - let func_id = import_function(self.codegen_cx.tcx, &mut self.codegen_cx.module, inst); + let func_id = import_function(self.cx.tcx, &mut self.cx.module, inst); let func_ref = self - .codegen_cx.module + .cx.module .declare_func_in_func(func_id, &mut self.bcx.func); #[cfg(debug_assertions)] @@ -250,11 +250,11 @@ impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> { call_conv: CallConv::triple_default(self.triple()), }; let func_id = self - .codegen_cx.module + .cx.module .declare_function(&name, Linkage::Import, &sig) .unwrap(); let func_ref = self - .codegen_cx.module + .cx.module .declare_func_in_func(func_id, &mut self.bcx.func); let call_inst = self.bcx.ins().call(func_ref, args); #[cfg(debug_assertions)] @@ -374,9 +374,9 @@ pub(crate) fn codegen_fn_prelude<'tcx>( .collect::, Ty<'tcx>)>>(); assert!(fx.caller_location.is_none()); - if fx.instance.def.requires_caller_location(fx.codegen_cx.tcx) { + if fx.instance.def.requires_caller_location(fx.cx.tcx) { // Store caller location for `#[track_caller]`. - fx.caller_location = Some(cvalue_for_param(fx, start_block, None, None, fx.codegen_cx.tcx.caller_location_ty()).unwrap()); + fx.caller_location = Some(cvalue_for_param(fx, start_block, None, None, fx.cx.tcx.caller_location_ty()).unwrap()); } fx.bcx.switch_to_block(start_block); @@ -398,7 +398,7 @@ pub(crate) fn codegen_fn_prelude<'tcx>( let local_decl = &fx.mir.local_decls[local]; // v this ! is important let internally_mutable = !val.layout().ty.is_freeze( - fx.codegen_cx.tcx.at(local_decl.source_info.span), + fx.cx.tcx.at(local_decl.source_info.span), ParamEnv::reveal_all(), ); if local_decl.mutability == mir::Mutability::Not && !internally_mutable { @@ -465,24 +465,24 @@ pub(crate) fn codegen_terminator_call<'tcx>( args: &[Operand<'tcx>], destination: Option<(Place<'tcx>, BasicBlock)>, ) { - let fn_ty = fx.monomorphize(&func.ty(fx.mir, fx.codegen_cx.tcx)); + let fn_ty = fx.monomorphize(&func.ty(fx.mir, fx.cx.tcx)); let fn_sig = fx - .codegen_cx.tcx - .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), &fn_ty.fn_sig(fx.codegen_cx.tcx)); + .cx.tcx + .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), &fn_ty.fn_sig(fx.cx.tcx)); let destination = destination.map(|(place, bb)| (trans_place(fx, place), bb)); // Handle special calls like instrinsics and empty drop glue. let instance = if let ty::FnDef(def_id, substs) = fn_ty.kind { - let instance = ty::Instance::resolve(fx.codegen_cx.tcx, ty::ParamEnv::reveal_all(), def_id, substs) + let instance = ty::Instance::resolve(fx.cx.tcx, ty::ParamEnv::reveal_all(), def_id, substs) .unwrap() .unwrap() - .polymorphize(fx.codegen_cx.tcx); + .polymorphize(fx.cx.tcx); - if fx.codegen_cx.tcx.symbol_name(instance).name.starts_with("llvm.") { + if fx.cx.tcx.symbol_name(instance).name.starts_with("llvm.") { crate::intrinsics::codegen_llvm_intrinsic_call( fx, - &fx.codegen_cx.tcx.symbol_name(instance).name, + &fx.cx.tcx.symbol_name(instance).name, substs, args, destination, @@ -510,7 +510,7 @@ pub(crate) fn codegen_terminator_call<'tcx>( let is_cold = instance.map(|inst| - fx.codegen_cx.tcx.codegen_fn_attrs(inst.def_id()) + fx.cx.tcx.codegen_fn_attrs(inst.def_id()) .flags.contains(CodegenFnAttrFlags::COLD)) .unwrap_or(false); if is_cold { @@ -558,7 +558,7 @@ pub(crate) fn codegen_terminator_call<'tcx>( nop_inst, format!( "virtual call; self arg pass mode: {:?}", - get_pass_mode(fx.codegen_cx.tcx, args[0].layout()) + get_pass_mode(fx.cx.tcx, args[0].layout()) ), ); } @@ -608,7 +608,7 @@ pub(crate) fn codegen_terminator_call<'tcx>( ) .collect::>(); - if instance.map(|inst| inst.def.requires_caller_location(fx.codegen_cx.tcx)).unwrap_or(false) { + if instance.map(|inst| inst.def.requires_caller_location(fx.cx.tcx)).unwrap_or(false) { // Pass the caller location for `#[track_caller]`. let caller_location = fx.get_caller_location(span); call_args.extend(adjust_arg_for_abi(fx, caller_location).into_iter()); @@ -616,7 +616,7 @@ pub(crate) fn codegen_terminator_call<'tcx>( let call_inst = if let Some(func_ref) = func_ref { let sig = clif_sig_from_fn_sig( - fx.codegen_cx.tcx, + fx.cx.tcx, fx.triple(), fn_sig, span, @@ -637,7 +637,7 @@ pub(crate) fn codegen_terminator_call<'tcx>( // FIXME find a cleaner way to support varargs if fn_sig.c_variadic { if fn_sig.abi != Abi::C { - fx.codegen_cx.tcx.sess.span_fatal(span, &format!("Variadic call for non-C abi {:?}", fn_sig.abi)); + fx.cx.tcx.sess.span_fatal(span, &format!("Variadic call for non-C abi {:?}", fn_sig.abi)); } let sig_ref = fx.bcx.func.dfg.call_signature(call_inst).unwrap(); let abi_params = call_args @@ -646,7 +646,7 @@ pub(crate) fn codegen_terminator_call<'tcx>( let ty = fx.bcx.func.dfg.value_type(arg); if !ty.is_int() { // FIXME set %al to upperbound on float args once floats are supported - fx.codegen_cx.tcx.sess.span_fatal(span, &format!("Non int ty {:?} for variadic call", ty)); + fx.cx.tcx.sess.span_fatal(span, &format!("Non int ty {:?} for variadic call", ty)); } AbiParam::new(ty) }) @@ -668,17 +668,17 @@ pub(crate) fn codegen_drop<'tcx>( drop_place: CPlace<'tcx>, ) { let ty = drop_place.layout().ty; - let drop_fn = Instance::resolve_drop_in_place(fx.codegen_cx.tcx, ty).polymorphize(fx.codegen_cx.tcx); + let drop_fn = Instance::resolve_drop_in_place(fx.cx.tcx, ty).polymorphize(fx.cx.tcx); if let ty::InstanceDef::DropGlue(_, None) = drop_fn.def { // we don't actually need to drop anything } else { - let drop_fn_ty = drop_fn.ty(fx.codegen_cx.tcx, ParamEnv::reveal_all()); - let fn_sig = fx.codegen_cx.tcx.normalize_erasing_late_bound_regions( + let drop_fn_ty = drop_fn.ty(fx.cx.tcx, ParamEnv::reveal_all()); + let fn_sig = fx.cx.tcx.normalize_erasing_late_bound_regions( ParamEnv::reveal_all(), - &drop_fn_ty.fn_sig(fx.codegen_cx.tcx), + &drop_fn_ty.fn_sig(fx.cx.tcx), ); - assert_eq!(fn_sig.output(), fx.codegen_cx.tcx.mk_unit()); + assert_eq!(fn_sig.output(), fx.cx.tcx.mk_unit()); match ty.kind { ty::Dynamic(..) => { @@ -687,7 +687,7 @@ pub(crate) fn codegen_drop<'tcx>( let drop_fn = crate::vtable::drop_fn_of_obj(fx, vtable.unwrap()); let sig = clif_sig_from_fn_sig( - fx.codegen_cx.tcx, + fx.cx.tcx, fx.triple(), fn_sig, span, @@ -702,7 +702,7 @@ pub(crate) fn codegen_drop<'tcx>( let arg_place = CPlace::new_stack_slot( fx, - fx.layout_of(fx.codegen_cx.tcx.mk_ref( + fx.layout_of(fx.cx.tcx.mk_ref( &ty::RegionKind::ReErased, TypeAndMut { ty, @@ -716,7 +716,7 @@ pub(crate) fn codegen_drop<'tcx>( let mut call_args: Vec = arg_value.into_iter().collect::>(); - if drop_fn.def.requires_caller_location(fx.codegen_cx.tcx) { + if drop_fn.def.requires_caller_location(fx.cx.tcx) { // Pass the caller location for `#[track_caller]`. let caller_location = fx.get_caller_location(span); call_args.extend(adjust_arg_for_abi(fx, caller_location).into_iter()); diff --git a/src/abi/pass_mode.rs b/src/abi/pass_mode.rs index 7172a56ad29..ffdd672ef7b 100644 --- a/src/abi/pass_mode.rs +++ b/src/abi/pass_mode.rs @@ -118,7 +118,7 @@ pub(super) fn adjust_arg_for_abi<'tcx>( fx: &mut FunctionCx<'_, 'tcx, impl Backend>, arg: CValue<'tcx>, ) -> EmptySinglePair { - match get_pass_mode(fx.codegen_cx.tcx, arg.layout()) { + match get_pass_mode(fx.cx.tcx, arg.layout()) { PassMode::NoPass => Empty, PassMode::ByVal(_) => Single(arg.load_scalar(fx)), PassMode::ByValPair(_, _) => { @@ -144,13 +144,13 @@ pub(super) fn cvalue_for_param<'tcx>( arg_ty: Ty<'tcx>, ) -> Option> { let layout = fx.layout_of(arg_ty); - let pass_mode = get_pass_mode(fx.codegen_cx.tcx, layout); + let pass_mode = get_pass_mode(fx.cx.tcx, layout); if let PassMode::NoPass = pass_mode { return None; } - let clif_types = pass_mode.get_param_ty(fx.codegen_cx.tcx); + let clif_types = pass_mode.get_param_ty(fx.cx.tcx); let block_params = clif_types.map(|t| fx.bcx.append_block_param(start_block, t)); #[cfg(debug_assertions)] diff --git a/src/abi/returning.rs b/src/abi/returning.rs index 51c0c144def..b0044b9ea0f 100644 --- a/src/abi/returning.rs +++ b/src/abi/returning.rs @@ -19,7 +19,7 @@ pub(super) fn codegen_return_param( start_block: Block, ) { let ret_layout = return_layout(fx); - let ret_pass_mode = get_pass_mode(fx.codegen_cx.tcx, ret_layout); + let ret_pass_mode = get_pass_mode(fx.cx.tcx, ret_layout); let ret_param = match ret_pass_mode { PassMode::NoPass => { fx.local_map @@ -66,7 +66,7 @@ pub(super) fn codegen_with_call_return_arg<'tcx, B: Backend, T>( ) -> (Inst, T) { let ret_layout = fx.layout_of(fn_sig.output()); - let output_pass_mode = get_pass_mode(fx.codegen_cx.tcx, ret_layout); + let output_pass_mode = get_pass_mode(fx.cx.tcx, ret_layout); let return_ptr = match output_pass_mode { PassMode::NoPass => None, PassMode::ByRef { size: Some(_)} => match ret_place { @@ -102,7 +102,7 @@ pub(super) fn codegen_with_call_return_arg<'tcx, B: Backend, T>( } pub(crate) fn codegen_return(fx: &mut FunctionCx<'_, '_, impl Backend>) { - match get_pass_mode(fx.codegen_cx.tcx, return_layout(fx)) { + match get_pass_mode(fx.cx.tcx, return_layout(fx)) { PassMode::NoPass | PassMode::ByRef { size: Some(_) } => { fx.bcx.ins().return_(&[]); } diff --git a/src/analyze.rs b/src/analyze.rs index 466e0a312c0..1e7d397bbe5 100644 --- a/src/analyze.rs +++ b/src/analyze.rs @@ -35,8 +35,8 @@ pub(crate) fn analyze(fx: &FunctionCx<'_, '_, impl Backend>) -> IndexVec { if let Some((dest_place, _dest_bb)) = destination { - let dest_layout = fx.layout_of(fx.monomorphize(&dest_place.ty(&fx.mir.local_decls, fx.codegen_cx.tcx).ty)); - if !crate::abi::can_return_to_ssa_var(fx.codegen_cx.tcx, dest_layout) { + let dest_layout = fx.layout_of(fx.monomorphize(&dest_place.ty(&fx.mir.local_decls, fx.cx.tcx).ty)); + if !crate::abi::can_return_to_ssa_var(fx.cx.tcx, dest_layout) { not_ssa(&mut flag_map, dest_place.local) } } diff --git a/src/atomic_shim.rs b/src/atomic_shim.rs index 00dca2c34a6..2cacef77d17 100644 --- a/src/atomic_shim.rs +++ b/src/atomic_shim.rs @@ -81,7 +81,7 @@ pub(crate) fn init_global_lock_constructor( } pub(crate) fn lock_global_lock(fx: &mut FunctionCx<'_, '_, impl Backend>) { - let atomic_mutex = fx.codegen_cx.module.declare_data( + let atomic_mutex = fx.cx.module.declare_data( "__cg_clif_global_atomic_mutex", Linkage::Import, true, @@ -89,24 +89,24 @@ pub(crate) fn lock_global_lock(fx: &mut FunctionCx<'_, '_, impl Backend>) { None, ).unwrap(); - let pthread_mutex_lock = fx.codegen_cx.module.declare_function("pthread_mutex_lock", Linkage::Import, &cranelift_codegen::ir::Signature { - call_conv: fx.codegen_cx.module.target_config().default_call_conv, + let pthread_mutex_lock = fx.cx.module.declare_function("pthread_mutex_lock", Linkage::Import, &cranelift_codegen::ir::Signature { + call_conv: fx.cx.module.target_config().default_call_conv, params: vec![ - AbiParam::new(fx.codegen_cx.module.target_config().pointer_type() /* *mut pthread_mutex_t */), + AbiParam::new(fx.cx.module.target_config().pointer_type() /* *mut pthread_mutex_t */), ], returns: vec![AbiParam::new(types::I32 /* c_int */)], }).unwrap(); - let pthread_mutex_lock = fx.codegen_cx.module.declare_func_in_func(pthread_mutex_lock, fx.bcx.func); + let pthread_mutex_lock = fx.cx.module.declare_func_in_func(pthread_mutex_lock, fx.bcx.func); - let atomic_mutex = fx.codegen_cx.module.declare_data_in_func(atomic_mutex, fx.bcx.func); - let atomic_mutex = fx.bcx.ins().global_value(fx.codegen_cx.module.target_config().pointer_type(), atomic_mutex); + let atomic_mutex = fx.cx.module.declare_data_in_func(atomic_mutex, fx.bcx.func); + let atomic_mutex = fx.bcx.ins().global_value(fx.cx.module.target_config().pointer_type(), atomic_mutex); fx.bcx.ins().call(pthread_mutex_lock, &[atomic_mutex]); } pub(crate) fn unlock_global_lock(fx: &mut FunctionCx<'_, '_, impl Backend>) { - let atomic_mutex = fx.codegen_cx.module.declare_data( + let atomic_mutex = fx.cx.module.declare_data( "__cg_clif_global_atomic_mutex", Linkage::Import, true, @@ -114,18 +114,18 @@ pub(crate) fn unlock_global_lock(fx: &mut FunctionCx<'_, '_, impl Backend>) { None, ).unwrap(); - let pthread_mutex_unlock = fx.codegen_cx.module.declare_function("pthread_mutex_unlock", Linkage::Import, &cranelift_codegen::ir::Signature { - call_conv: fx.codegen_cx.module.target_config().default_call_conv, + let pthread_mutex_unlock = fx.cx.module.declare_function("pthread_mutex_unlock", Linkage::Import, &cranelift_codegen::ir::Signature { + call_conv: fx.cx.module.target_config().default_call_conv, params: vec![ - AbiParam::new(fx.codegen_cx.module.target_config().pointer_type() /* *mut pthread_mutex_t */), + AbiParam::new(fx.cx.module.target_config().pointer_type() /* *mut pthread_mutex_t */), ], returns: vec![AbiParam::new(types::I32 /* c_int */)], }).unwrap(); - let pthread_mutex_unlock = fx.codegen_cx.module.declare_func_in_func(pthread_mutex_unlock, fx.bcx.func); + let pthread_mutex_unlock = fx.cx.module.declare_func_in_func(pthread_mutex_unlock, fx.bcx.func); - let atomic_mutex = fx.codegen_cx.module.declare_data_in_func(atomic_mutex, fx.bcx.func); - let atomic_mutex = fx.bcx.ins().global_value(fx.codegen_cx.module.target_config().pointer_type(), atomic_mutex); + let atomic_mutex = fx.cx.module.declare_data_in_func(atomic_mutex, fx.bcx.func); + let atomic_mutex = fx.bcx.ins().global_value(fx.cx.module.target_config().pointer_type(), atomic_mutex); fx.bcx.ins().call(pthread_mutex_unlock, &[atomic_mutex]); } diff --git a/src/base.rs b/src/base.rs index 92d910dd998..662054d4e4f 100644 --- a/src/base.rs +++ b/src/base.rs @@ -34,7 +34,7 @@ pub(crate) fn trans_fn<'tcx, B: Backend + 'static>( let clif_comments = crate::pretty_clif::CommentWriter::new(tcx, instance); let mut fx = FunctionCx { - codegen_cx: cx, + cx, pointer_type, instance, @@ -220,7 +220,7 @@ fn codegen_fn_content(fx: &mut FunctionCx<'_, '_, impl Backend>) { target, cleanup: _, } => { - if !fx.codegen_cx.tcx.sess.overflow_checks() { + if !fx.cx.tcx.sess.overflow_checks() { if let mir::AssertKind::OverflowNeg(_) = *msg { let target = fx.get_block(*target); fx.bcx.ins().jump(target, &[]); @@ -261,12 +261,12 @@ fn codegen_fn_content(fx: &mut FunctionCx<'_, '_, impl Backend>) { } }; - let def_id = fx.codegen_cx.tcx.lang_items().require(lang_item).unwrap_or_else(|s| { - fx.codegen_cx.tcx.sess.span_fatal(bb_data.terminator().source_info.span, &s) + let def_id = fx.cx.tcx.lang_items().require(lang_item).unwrap_or_else(|s| { + fx.cx.tcx.sess.span_fatal(bb_data.terminator().source_info.span, &s) }); - let instance = Instance::mono(fx.codegen_cx.tcx, def_id).polymorphize(fx.codegen_cx.tcx); - let symbol_name = fx.codegen_cx.tcx.symbol_name(instance).name; + let instance = Instance::mono(fx.cx.tcx, def_id).polymorphize(fx.cx.tcx); + let symbol_name = fx.cx.tcx.symbol_name(instance).name; fx.lib_call(&*symbol_name, vec![fx.pointer_type, fx.pointer_type, fx.pointer_type], vec![], &args); @@ -296,7 +296,7 @@ fn codegen_fn_content(fx: &mut FunctionCx<'_, '_, impl Backend>) { cleanup: _, from_hir_call: _, } => { - fx.codegen_cx.tcx.sess.time("codegen call", || crate::abi::codegen_terminator_call( + fx.cx.tcx.sess.time("codegen call", || crate::abi::codegen_terminator_call( fx, *fn_span, block, @@ -415,7 +415,7 @@ fn trans_stmt<'tcx>( let lhs = trans_operand(fx, lhs); let rhs = trans_operand(fx, rhs); - let res = if !fx.codegen_cx.tcx.sess.overflow_checks() { + let res = if !fx.cx.tcx.sess.overflow_checks() { let val = crate::num::trans_int_binop(fx, *bin_op, lhs, rhs).load_scalar(fx); let is_overflow = fx.bcx.ins().iconst(types::I8, 0); @@ -461,14 +461,14 @@ fn trans_stmt<'tcx>( lval.write_cvalue(fx, res); } Rvalue::Cast(CastKind::Pointer(PointerCast::ReifyFnPointer), operand, to_ty) => { - let from_ty = fx.monomorphize(&operand.ty(&fx.mir.local_decls, fx.codegen_cx.tcx)); + let from_ty = fx.monomorphize(&operand.ty(&fx.mir.local_decls, fx.cx.tcx)); let to_layout = fx.layout_of(fx.monomorphize(to_ty)); match from_ty.kind { ty::FnDef(def_id, substs) => { let func_ref = fx.get_function_ref( - Instance::resolve_for_fn_ptr(fx.codegen_cx.tcx, ParamEnv::reveal_all(), def_id, substs) + Instance::resolve_for_fn_ptr(fx.cx.tcx, ParamEnv::reveal_all(), def_id, substs) .unwrap() - .polymorphize(fx.codegen_cx.tcx), + .polymorphize(fx.cx.tcx), ); let func_addr = fx.bcx.ins().func_addr(fx.pointer_type, func_ref); lval.write_cvalue(fx, CValue::by_val(func_addr, to_layout)); @@ -497,7 +497,7 @@ fn trans_stmt<'tcx>( |ty::TypeAndMut { ty: pointee_ty, mutbl: _, - }| has_ptr_meta(fx.codegen_cx.tcx, pointee_ty), + }| has_ptr_meta(fx.cx.tcx, pointee_ty), ) .unwrap_or(false) } @@ -523,7 +523,7 @@ fn trans_stmt<'tcx>( match &operand.layout().variants { Variants::Single { index } => { - let discr = operand.layout().ty.discriminant_for_variant(fx.codegen_cx.tcx, *index).unwrap(); + let discr = operand.layout().ty.discriminant_for_variant(fx.cx.tcx, *index).unwrap(); let discr = if discr.ty.is_signed() { rustc_middle::mir::interpret::sign_extend(discr.val, fx.layout_of(discr.ty).size) } else { @@ -575,11 +575,11 @@ fn trans_stmt<'tcx>( match operand.layout().ty.kind { ty::Closure(def_id, substs) => { let instance = Instance::resolve_closure( - fx.codegen_cx.tcx, + fx.cx.tcx, def_id, substs, ty::ClosureKind::FnOnce, - ).polymorphize(fx.codegen_cx.tcx); + ).polymorphize(fx.cx.tcx); let func_ref = fx.get_function_ref(instance); let func_addr = fx.bcx.ins().func_addr(fx.pointer_type, func_ref); lval.write_cvalue(fx, CValue::by_val(func_addr, lval.layout())); @@ -602,9 +602,9 @@ fn trans_stmt<'tcx>( let operand = trans_operand(fx, operand); let times = fx .monomorphize(times) - .eval(fx.codegen_cx.tcx, ParamEnv::reveal_all()) + .eval(fx.cx.tcx, ParamEnv::reveal_all()) .val - .try_to_bits(fx.codegen_cx.tcx.data_layout.pointer_size) + .try_to_bits(fx.cx.tcx.data_layout.pointer_size) .unwrap(); for i in 0..times { let index = fx.bcx.ins().iconst(fx.pointer_type, i as i64); @@ -614,14 +614,14 @@ fn trans_stmt<'tcx>( } Rvalue::Len(place) => { let place = trans_place(fx, *place); - let usize_layout = fx.layout_of(fx.codegen_cx.tcx.types.usize); + let usize_layout = fx.layout_of(fx.cx.tcx.types.usize); let len = codegen_array_len(fx, place); lval.write_cvalue(fx, CValue::by_val(len, usize_layout)); } Rvalue::NullaryOp(NullOp::Box, content_ty) => { use rustc_hir::lang_items::ExchangeMallocFnLangItem; - let usize_type = fx.clif_type(fx.codegen_cx.tcx.types.usize).unwrap(); + let usize_type = fx.clif_type(fx.cx.tcx.types.usize).unwrap(); let content_ty = fx.monomorphize(content_ty); let layout = fx.layout_of(content_ty); let llsize = fx.bcx.ins().iconst(usize_type, layout.size.bytes() as i64); @@ -629,18 +629,18 @@ fn trans_stmt<'tcx>( .bcx .ins() .iconst(usize_type, layout.align.abi.bytes() as i64); - let box_layout = fx.layout_of(fx.codegen_cx.tcx.mk_box(content_ty)); + let box_layout = fx.layout_of(fx.cx.tcx.mk_box(content_ty)); // Allocate space: - let def_id = match fx.codegen_cx.tcx.lang_items().require(ExchangeMallocFnLangItem) { + let def_id = match fx.cx.tcx.lang_items().require(ExchangeMallocFnLangItem) { Ok(id) => id, Err(s) => { - fx.codegen_cx.tcx + fx.cx.tcx .sess .fatal(&format!("allocation of `{}` {}", box_layout.ty, s)); } }; - let instance = ty::Instance::mono(fx.codegen_cx.tcx, def_id).polymorphize(fx.codegen_cx.tcx); + let instance = ty::Instance::mono(fx.cx.tcx, def_id).polymorphize(fx.cx.tcx); let func_ref = fx.get_function_ref(instance); let call = fx.bcx.ins().call(func_ref, &[llsize, llalign]); let ptr = fx.bcx.inst_results(call)[0]; @@ -650,9 +650,9 @@ fn trans_stmt<'tcx>( assert!(lval .layout() .ty - .is_sized(fx.codegen_cx.tcx.at(stmt.source_info.span), ParamEnv::reveal_all())); + .is_sized(fx.cx.tcx.at(stmt.source_info.span), ParamEnv::reveal_all())); let ty_size = fx.layout_of(fx.monomorphize(ty)).size.bytes(); - let val = CValue::const_val(fx, fx.layout_of(fx.codegen_cx.tcx.types.usize), ty_size.into()); + let val = CValue::const_val(fx, fx.layout_of(fx.cx.tcx.types.usize), ty_size.into()); lval.write_cvalue(fx, val); } Rvalue::Aggregate(kind, operands) => match **kind { @@ -717,10 +717,10 @@ fn trans_stmt<'tcx>( let (eax, ebx, ecx, edx) = crate::intrinsics::codegen_cpuid_call(fx, leaf, subleaf); assert_eq!(outputs.len(), 4); - trans_place(fx, outputs[0]).write_cvalue(fx, CValue::by_val(eax, fx.layout_of(fx.codegen_cx.tcx.types.u32))); - trans_place(fx, outputs[1]).write_cvalue(fx, CValue::by_val(ebx, fx.layout_of(fx.codegen_cx.tcx.types.u32))); - trans_place(fx, outputs[2]).write_cvalue(fx, CValue::by_val(ecx, fx.layout_of(fx.codegen_cx.tcx.types.u32))); - trans_place(fx, outputs[3]).write_cvalue(fx, CValue::by_val(edx, fx.layout_of(fx.codegen_cx.tcx.types.u32))); + trans_place(fx, outputs[0]).write_cvalue(fx, CValue::by_val(eax, fx.layout_of(fx.cx.tcx.types.u32))); + trans_place(fx, outputs[1]).write_cvalue(fx, CValue::by_val(ebx, fx.layout_of(fx.cx.tcx.types.u32))); + trans_place(fx, outputs[2]).write_cvalue(fx, CValue::by_val(ecx, fx.layout_of(fx.cx.tcx.types.u32))); + trans_place(fx, outputs[3]).write_cvalue(fx, CValue::by_val(edx, fx.layout_of(fx.cx.tcx.types.u32))); } "xgetbv" => { assert_eq!(input_names, &[Symbol::intern("{ecx}")]); @@ -740,17 +740,17 @@ fn trans_stmt<'tcx>( crate::trap::trap_unimplemented(fx, "_xgetbv arch intrinsic is not supported"); } // ___chkstk, ___chkstk_ms and __alloca are only used on Windows - _ if fx.codegen_cx.tcx.symbol_name(fx.instance).name.starts_with("___chkstk") => { + _ if fx.cx.tcx.symbol_name(fx.instance).name.starts_with("___chkstk") => { crate::trap::trap_unimplemented(fx, "Stack probes are not supported"); } - _ if fx.codegen_cx.tcx.symbol_name(fx.instance).name == "__alloca" => { + _ if fx.cx.tcx.symbol_name(fx.instance).name == "__alloca" => { crate::trap::trap_unimplemented(fx, "Alloca is not supported"); } // Used in sys::windows::abort_internal "int $$0x29" => { crate::trap::trap_unimplemented(fx, "Windows abort"); } - _ => fx.codegen_cx.tcx.sess.span_fatal(stmt.source_info.span, "Inline assembly is not supported"), + _ => fx.cx.tcx.sess.span_fatal(stmt.source_info.span, "Inline assembly is not supported"), } } } @@ -763,8 +763,8 @@ fn codegen_array_len<'tcx>( match place.layout().ty.kind { ty::Array(_elem_ty, len) => { let len = fx.monomorphize(&len) - .eval(fx.codegen_cx.tcx, ParamEnv::reveal_all()) - .eval_usize(fx.codegen_cx.tcx, ParamEnv::reveal_all()) as i64; + .eval(fx.cx.tcx, ParamEnv::reveal_all()) + .eval_usize(fx.cx.tcx, ParamEnv::reveal_all()) as i64; fx.bcx.ins().iconst(fx.pointer_type, len) } ty::Slice(_elem_ty) => place @@ -817,7 +817,7 @@ pub(crate) fn trans_place<'tcx>( let ptr = cplace.to_ptr(); cplace = CPlace::for_ptr( ptr.offset_i64(fx, elem_layout.size.bytes() as i64 * i64::from(from)), - fx.layout_of(fx.codegen_cx.tcx.mk_array(elem_ty, u64::from(to) - u64::from(from))), + fx.layout_of(fx.cx.tcx.mk_array(elem_ty, u64::from(to) - u64::from(from))), ); } ty::Slice(elem_ty) => { diff --git a/src/cast.rs b/src/cast.rs index db465a58127..25ce5812f9b 100644 --- a/src/cast.rs +++ b/src/cast.rs @@ -86,14 +86,14 @@ pub(crate) fn clif_int_or_float_cast( ); let from_rust_ty = if from_signed { - fx.codegen_cx.tcx.types.i128 + fx.cx.tcx.types.i128 } else { - fx.codegen_cx.tcx.types.u128 + fx.cx.tcx.types.u128 }; let to_rust_ty = match to_ty { - types::F32 => fx.codegen_cx.tcx.types.f32, - types::F64 => fx.codegen_cx.tcx.types.f64, + types::F32 => fx.cx.tcx.types.f32, + types::F64 => fx.cx.tcx.types.f64, _ => unreachable!(), }; @@ -131,15 +131,15 @@ pub(crate) fn clif_int_or_float_cast( ); let from_rust_ty = match from_ty { - types::F32 => fx.codegen_cx.tcx.types.f32, - types::F64 => fx.codegen_cx.tcx.types.f64, + types::F32 => fx.cx.tcx.types.f32, + types::F64 => fx.cx.tcx.types.f64, _ => unreachable!(), }; let to_rust_ty = if to_signed { - fx.codegen_cx.tcx.types.i128 + fx.cx.tcx.types.i128 } else { - fx.codegen_cx.tcx.types.u128 + fx.cx.tcx.types.u128 }; return fx diff --git a/src/codegen_i128.rs b/src/codegen_i128.rs index bb927a4dd70..0b02d32c651 100644 --- a/src/codegen_i128.rs +++ b/src/codegen_i128.rs @@ -9,7 +9,7 @@ pub(crate) fn maybe_codegen<'tcx>( lhs: CValue<'tcx>, rhs: CValue<'tcx>, ) -> Option> { - if lhs.layout().ty != fx.codegen_cx.tcx.types.u128 && lhs.layout().ty != fx.codegen_cx.tcx.types.i128 { + if lhs.layout().ty != fx.cx.tcx.types.u128 && lhs.layout().ty != fx.cx.tcx.types.i128 { return None; } @@ -25,7 +25,7 @@ pub(crate) fn maybe_codegen<'tcx>( } BinOp::Add | BinOp::Sub if !checked => return None, BinOp::Add => { - let out_ty = fx.codegen_cx.tcx.mk_tup([lhs.layout().ty, fx.codegen_cx.tcx.types.bool].iter()); + let out_ty = fx.cx.tcx.mk_tup([lhs.layout().ty, fx.cx.tcx.types.bool].iter()); return Some(if is_signed { fx.easy_call("__rust_i128_addo", &[lhs, rhs], out_ty) } else { @@ -33,7 +33,7 @@ pub(crate) fn maybe_codegen<'tcx>( }); } BinOp::Sub => { - let out_ty = fx.codegen_cx.tcx.mk_tup([lhs.layout().ty, fx.codegen_cx.tcx.types.bool].iter()); + let out_ty = fx.cx.tcx.mk_tup([lhs.layout().ty, fx.cx.tcx.types.bool].iter()); return Some(if is_signed { fx.easy_call("__rust_i128_subo", &[lhs, rhs], out_ty) } else { @@ -43,7 +43,7 @@ pub(crate) fn maybe_codegen<'tcx>( BinOp::Offset => unreachable!("offset should only be used on pointers, not 128bit ints"), BinOp::Mul => { let res = if checked { - let out_ty = fx.codegen_cx.tcx.mk_tup([lhs.layout().ty, fx.codegen_cx.tcx.types.bool].iter()); + let out_ty = fx.cx.tcx.mk_tup([lhs.layout().ty, fx.cx.tcx.types.bool].iter()); if is_signed { fx.easy_call("__rust_i128_mulo", &[lhs, rhs], out_ty) } else { @@ -51,9 +51,9 @@ pub(crate) fn maybe_codegen<'tcx>( } } else { let val_ty = if is_signed { - fx.codegen_cx.tcx.types.i128 + fx.cx.tcx.types.i128 } else { - fx.codegen_cx.tcx.types.u128 + fx.cx.tcx.types.u128 }; fx.easy_call("__multi3", &[lhs, rhs], val_ty) }; @@ -62,17 +62,17 @@ pub(crate) fn maybe_codegen<'tcx>( BinOp::Div => { assert!(!checked); if is_signed { - Some(fx.easy_call("__divti3", &[lhs, rhs], fx.codegen_cx.tcx.types.i128)) + Some(fx.easy_call("__divti3", &[lhs, rhs], fx.cx.tcx.types.i128)) } else { - Some(fx.easy_call("__udivti3", &[lhs, rhs], fx.codegen_cx.tcx.types.u128)) + Some(fx.easy_call("__udivti3", &[lhs, rhs], fx.cx.tcx.types.u128)) } } BinOp::Rem => { assert!(!checked); if is_signed { - Some(fx.easy_call("__modti3", &[lhs, rhs], fx.codegen_cx.tcx.types.i128)) + Some(fx.easy_call("__modti3", &[lhs, rhs], fx.cx.tcx.types.i128)) } else { - Some(fx.easy_call("__umodti3", &[lhs, rhs], fx.codegen_cx.tcx.types.u128)) + Some(fx.easy_call("__umodti3", &[lhs, rhs], fx.cx.tcx.types.u128)) } } BinOp::Lt | BinOp::Le | BinOp::Eq | BinOp::Ge | BinOp::Gt | BinOp::Ne => { @@ -104,7 +104,7 @@ pub(crate) fn maybe_codegen<'tcx>( let val = match (bin_op, is_signed) { (BinOp::Shr, false) => { let val = fx.bcx.ins().iconcat(lhs_msb, all_zeros); - Some(CValue::by_val(val, fx.layout_of(fx.codegen_cx.tcx.types.u128))) + Some(CValue::by_val(val, fx.layout_of(fx.cx.tcx.types.u128))) } (BinOp::Shr, true) => { let sign = fx.bcx.ins().icmp_imm(IntCC::SignedLessThan, lhs_msb, 0); @@ -112,13 +112,13 @@ pub(crate) fn maybe_codegen<'tcx>( let all_sign_bits = fx.bcx.ins().select(sign, all_zeros, all_ones); let val = fx.bcx.ins().iconcat(lhs_msb, all_sign_bits); - Some(CValue::by_val(val, fx.layout_of(fx.codegen_cx.tcx.types.i128))) + Some(CValue::by_val(val, fx.layout_of(fx.cx.tcx.types.i128))) } (BinOp::Shl, _) => { let val_ty = if is_signed { - fx.codegen_cx.tcx.types.i128 + fx.cx.tcx.types.i128 } else { - fx.codegen_cx.tcx.types.u128 + fx.cx.tcx.types.u128 }; let val = fx.bcx.ins().iconcat(all_zeros, lhs_lsb); Some(CValue::by_val(val, fx.layout_of(val_ty))) @@ -127,7 +127,7 @@ pub(crate) fn maybe_codegen<'tcx>( }; if let Some(val) = val { if let Some(is_overflow) = is_overflow { - let out_ty = fx.codegen_cx.tcx.mk_tup([lhs.layout().ty, fx.codegen_cx.tcx.types.bool].iter()); + let out_ty = fx.cx.tcx.mk_tup([lhs.layout().ty, fx.cx.tcx.types.bool].iter()); let val = val.load_scalar(fx); return Some(CValue::by_val_pair(val, is_overflow, fx.layout_of(out_ty))); } else { @@ -137,24 +137,24 @@ pub(crate) fn maybe_codegen<'tcx>( } let truncated_rhs = clif_intcast(fx, rhs_val, types::I32, false); - let truncated_rhs = CValue::by_val(truncated_rhs, fx.layout_of(fx.codegen_cx.tcx.types.u32)); + let truncated_rhs = CValue::by_val(truncated_rhs, fx.layout_of(fx.cx.tcx.types.u32)); let val = match (bin_op, is_signed) { (BinOp::Shl, false) => { - fx.easy_call("__ashlti3", &[lhs, truncated_rhs], fx.codegen_cx.tcx.types.u128) + fx.easy_call("__ashlti3", &[lhs, truncated_rhs], fx.cx.tcx.types.u128) } (BinOp::Shl, true) => { - fx.easy_call("__ashlti3", &[lhs, truncated_rhs], fx.codegen_cx.tcx.types.i128) + fx.easy_call("__ashlti3", &[lhs, truncated_rhs], fx.cx.tcx.types.i128) } (BinOp::Shr, false) => { - fx.easy_call("__lshrti3", &[lhs, truncated_rhs], fx.codegen_cx.tcx.types.u128) + fx.easy_call("__lshrti3", &[lhs, truncated_rhs], fx.cx.tcx.types.u128) } (BinOp::Shr, true) => { - fx.easy_call("__ashrti3", &[lhs, truncated_rhs], fx.codegen_cx.tcx.types.i128) + fx.easy_call("__ashrti3", &[lhs, truncated_rhs], fx.cx.tcx.types.i128) } (_, _) => unreachable!(), }; if let Some(is_overflow) = is_overflow { - let out_ty = fx.codegen_cx.tcx.mk_tup([lhs.layout().ty, fx.codegen_cx.tcx.types.bool].iter()); + let out_ty = fx.cx.tcx.mk_tup([lhs.layout().ty, fx.cx.tcx.types.bool].iter()); let val = val.load_scalar(fx); Some(CValue::by_val_pair(val, is_overflow, fx.layout_of(out_ty))) } else { diff --git a/src/common.rs b/src/common.rs index bf7fc570818..7283630f748 100644 --- a/src/common.rs +++ b/src/common.rs @@ -265,7 +265,7 @@ pub(crate) fn type_sign(ty: Ty<'_>) -> bool { } pub(crate) struct FunctionCx<'clif, 'tcx, B: Backend + 'static> { - pub(crate) codegen_cx: &'clif mut crate::CodegenCx<'tcx, B>, + pub(crate) cx: &'clif mut crate::CodegenCx<'tcx, B>, pub(crate) pointer_type: Type, // Cached from module pub(crate) instance: Instance<'tcx>, @@ -296,11 +296,11 @@ impl<'tcx, B: Backend> LayoutOf for FunctionCx<'_, 'tcx, B> { fn layout_of(&self, ty: Ty<'tcx>) -> TyAndLayout<'tcx> { assert!(!ty.still_further_specializable()); - self.codegen_cx.tcx + self.cx.tcx .layout_of(ParamEnv::reveal_all().and(&ty)) .unwrap_or_else(|e| { if let layout::LayoutError::SizeOverflow(_) = e { - self.codegen_cx.tcx.sess.fatal(&e.to_string()) + self.cx.tcx.sess.fatal(&e.to_string()) } else { bug!("failed to get layout for `{}`: {}", ty, e) } @@ -310,13 +310,13 @@ impl<'tcx, B: Backend> LayoutOf for FunctionCx<'_, 'tcx, B> { impl<'tcx, B: Backend + 'static> layout::HasTyCtxt<'tcx> for FunctionCx<'_, 'tcx, B> { fn tcx<'b>(&'b self) -> TyCtxt<'tcx> { - self.codegen_cx.tcx + self.cx.tcx } } impl<'tcx, B: Backend + 'static> rustc_target::abi::HasDataLayout for FunctionCx<'_, 'tcx, B> { fn data_layout(&self) -> &rustc_target::abi::TargetDataLayout { - &self.codegen_cx.tcx.data_layout + &self.cx.tcx.data_layout } } @@ -328,7 +328,7 @@ impl<'tcx, B: Backend + 'static> layout::HasParamEnv<'tcx> for FunctionCx<'_, 't impl<'tcx, B: Backend + 'static> HasTargetSpec for FunctionCx<'_, 'tcx, B> { fn target_spec(&self) -> &Target { - &self.codegen_cx.tcx.sess.target.target + &self.cx.tcx.sess.target.target } } @@ -338,22 +338,22 @@ impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> { T: TypeFoldable<'tcx> + Copy, { if let Some(substs) = self.instance.substs_for_mir_body() { - self.codegen_cx.tcx.subst_and_normalize_erasing_regions( + self.cx.tcx.subst_and_normalize_erasing_regions( substs, ty::ParamEnv::reveal_all(), value, ) } else { - self.codegen_cx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), *value) + self.cx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), *value) } } pub(crate) fn clif_type(&self, ty: Ty<'tcx>) -> Option { - clif_type_from_ty(self.codegen_cx.tcx, ty) + clif_type_from_ty(self.cx.tcx, ty) } pub(crate) fn clif_pair_type(&self, ty: Ty<'tcx>) -> Option<(Type, Type)> { - clif_pair_type_from_ty(self.codegen_cx.tcx, ty) + clif_pair_type_from_ty(self.cx.tcx, ty) } pub(crate) fn get_block(&self, bb: BasicBlock) -> Block { @@ -378,8 +378,8 @@ impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> { } let topmost = span.ctxt().outer_expn().expansion_cause().unwrap_or(span); - let caller = self.codegen_cx.tcx.sess.source_map().lookup_char_pos(topmost.lo()); - let const_loc = self.codegen_cx.tcx.const_caller_location(( + let caller = self.cx.tcx.sess.source_map().lookup_char_pos(topmost.lo()); + let const_loc = self.cx.tcx.const_caller_location(( rustc_span::symbol::Symbol::intern(&caller.file.name.to_string()), caller.line as u32, caller.col_display as u32 + 1, @@ -387,12 +387,12 @@ impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> { crate::constant::trans_const_value( self, const_loc, - self.codegen_cx.tcx.caller_location_ty(), + self.cx.tcx.caller_location_ty(), ) } pub(crate) fn triple(&self) -> &target_lexicon::Triple { - self.codegen_cx.module.isa().triple() + self.cx.module.isa().triple() } pub(crate) fn anonymous_str(&mut self, prefix: &str, msg: &str) -> Value { @@ -405,7 +405,7 @@ impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> { let mut data_ctx = DataContext::new(); data_ctx.define(msg.as_bytes().to_vec().into_boxed_slice()); let msg_id = self - .codegen_cx.module + .cx.module .declare_data( &format!("__{}_{:08x}", prefix, msg_hash), Linkage::Local, @@ -416,9 +416,9 @@ impl<'tcx, B: Backend + 'static> FunctionCx<'_, 'tcx, B> { .unwrap(); // Ignore DuplicateDefinition error, as the data will be the same - let _ = self.codegen_cx.module.define_data(msg_id, &data_ctx); + let _ = self.cx.module.define_data(msg_id, &data_ctx); - let local_msg_id = self.codegen_cx.module.declare_data_in_func(msg_id, self.bcx.func); + let local_msg_id = self.cx.module.declare_data_in_func(msg_id, self.bcx.func); #[cfg(debug_assertions)] { self.add_comment(local_msg_id, msg); diff --git a/src/constant.rs b/src/constant.rs index 7f047b04c9d..764d8a48ccf 100644 --- a/src/constant.rs +++ b/src/constant.rs @@ -41,10 +41,10 @@ pub(crate) fn check_constants(fx: &mut FunctionCx<'_, '_, impl Backend>) { match const_.val { ConstKind::Value(_) => {} ConstKind::Unevaluated(def, ref substs, promoted) => { - if let Err(err) = fx.codegen_cx.tcx.const_eval_resolve(ParamEnv::reveal_all(), def, substs, promoted, None) { + if let Err(err) = fx.cx.tcx.const_eval_resolve(ParamEnv::reveal_all(), def, substs, promoted, None) { match err { ErrorHandled::Reported(ErrorReported) | ErrorHandled::Linted => { - fx.codegen_cx.tcx.sess.span_err(constant.span, "erroneous constant encountered"); + fx.cx.tcx.sess.span_err(constant.span, "erroneous constant encountered"); } ErrorHandled::TooGeneric => { span_bug!(constant.span, "codgen encountered polymorphic constant: {:?}", err); @@ -67,8 +67,8 @@ pub(crate) fn codegen_tls_ref<'tcx>( def_id: DefId, layout: TyAndLayout<'tcx>, ) -> CValue<'tcx> { - let data_id = data_id_for_static(fx.codegen_cx.tcx, &mut fx.codegen_cx.module, def_id, false); - let local_data_id = fx.codegen_cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); + let data_id = data_id_for_static(fx.cx.tcx, &mut fx.cx.module, def_id, false); + let local_data_id = fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); #[cfg(debug_assertions)] fx.add_comment(local_data_id, format!("tls {:?}", def_id)); let tls_ptr = fx.bcx.ins().tls_value(fx.pointer_type, local_data_id); @@ -80,8 +80,8 @@ fn codegen_static_ref<'tcx>( def_id: DefId, layout: TyAndLayout<'tcx>, ) -> CPlace<'tcx> { - let data_id = data_id_for_static(fx.codegen_cx.tcx, &mut fx.codegen_cx.module, def_id, false); - let local_data_id = fx.codegen_cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); + let data_id = data_id_for_static(fx.cx.tcx, &mut fx.cx.module, def_id, false); + let local_data_id = fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); #[cfg(debug_assertions)] fx.add_comment(local_data_id, format!("{:?}", def_id)); let global_ptr = fx.bcx.ins().global_value(fx.pointer_type, local_data_id); @@ -97,7 +97,7 @@ pub(crate) fn trans_constant<'tcx>( let const_ = fx.monomorphize(&constant.literal); let const_val = match const_.val { ConstKind::Value(const_val) => const_val, - ConstKind::Unevaluated(def, ref substs, promoted) if fx.codegen_cx.tcx.is_static(def.did) => { + ConstKind::Unevaluated(def, ref substs, promoted) if fx.cx.tcx.is_static(def.did) => { assert!(substs.is_empty()); assert!(promoted.is_none()); @@ -108,11 +108,11 @@ pub(crate) fn trans_constant<'tcx>( ).to_cvalue(fx); } ConstKind::Unevaluated(def, ref substs, promoted) => { - match fx.codegen_cx.tcx.const_eval_resolve(ParamEnv::reveal_all(), def, substs, promoted, None) { + match fx.cx.tcx.const_eval_resolve(ParamEnv::reveal_all(), def, substs, promoted, None) { Ok(const_val) => const_val, Err(_) => { if promoted.is_none() { - fx.codegen_cx.tcx.sess.span_err(constant.span, "erroneous constant encountered"); + fx.cx.tcx.sess.span_err(constant.span, "erroneous constant encountered"); } return crate::trap::trap_unreachable_ret_value( fx, @@ -154,7 +154,7 @@ pub(crate) fn trans_const_value<'tcx>( ); let ptr = Pointer::new(AllocId(!0), Size::ZERO); // The alloc id is never used alloc.write_scalar(fx, ptr, x.into(), size).unwrap(); - let alloc = fx.codegen_cx.tcx.intern_const_alloc(alloc); + let alloc = fx.cx.tcx.intern_const_alloc(alloc); return CValue::by_ref(pointer_for_allocation(fx, alloc), layout); } @@ -164,25 +164,25 @@ pub(crate) fn trans_const_value<'tcx>( return CValue::const_val(fx, layout, data); } Scalar::Ptr(ptr) => { - let alloc_kind = fx.codegen_cx.tcx.get_global_alloc(ptr.alloc_id); + let alloc_kind = fx.cx.tcx.get_global_alloc(ptr.alloc_id); let base_addr = match alloc_kind { Some(GlobalAlloc::Memory(alloc)) => { - fx.codegen_cx.constants_cx.todo.push(TodoItem::Alloc(ptr.alloc_id)); - let data_id = data_id_for_alloc_id(&mut fx.codegen_cx.module, ptr.alloc_id, alloc.align, alloc.mutability); - let local_data_id = fx.codegen_cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); + fx.cx.constants_cx.todo.push(TodoItem::Alloc(ptr.alloc_id)); + let data_id = data_id_for_alloc_id(&mut fx.cx.module, ptr.alloc_id, alloc.align, alloc.mutability); + let local_data_id = fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); #[cfg(debug_assertions)] fx.add_comment(local_data_id, format!("{:?}", ptr.alloc_id)); fx.bcx.ins().global_value(fx.pointer_type, local_data_id) } Some(GlobalAlloc::Function(instance)) => { - let func_id = crate::abi::import_function(fx.codegen_cx.tcx, &mut fx.codegen_cx.module, instance); - let local_func_id = fx.codegen_cx.module.declare_func_in_func(func_id, &mut fx.bcx.func); + let func_id = crate::abi::import_function(fx.cx.tcx, &mut fx.cx.module, instance); + let local_func_id = fx.cx.module.declare_func_in_func(func_id, &mut fx.bcx.func); fx.bcx.ins().func_addr(fx.pointer_type, local_func_id) } Some(GlobalAlloc::Static(def_id)) => { - assert!(fx.codegen_cx.tcx.is_static(def_id)); - let data_id = data_id_for_static(fx.codegen_cx.tcx, &mut fx.codegen_cx.module, def_id, false); - let local_data_id = fx.codegen_cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); + assert!(fx.cx.tcx.is_static(def_id)); + let data_id = data_id_for_static(fx.cx.tcx, &mut fx.cx.module, def_id, false); + let local_data_id = fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); #[cfg(debug_assertions)] fx.add_comment(local_data_id, format!("{:?}", def_id)); fx.bcx.ins().global_value(fx.pointer_type, local_data_id) @@ -215,11 +215,11 @@ fn pointer_for_allocation<'tcx>( fx: &mut FunctionCx<'_, 'tcx, impl Backend>, alloc: &'tcx Allocation, ) -> crate::pointer::Pointer { - let alloc_id = fx.codegen_cx.tcx.create_memory_alloc(alloc); - fx.codegen_cx.constants_cx.todo.push(TodoItem::Alloc(alloc_id)); - let data_id = data_id_for_alloc_id(&mut fx.codegen_cx.module, alloc_id, alloc.align, alloc.mutability); + let alloc_id = fx.cx.tcx.create_memory_alloc(alloc); + fx.cx.constants_cx.todo.push(TodoItem::Alloc(alloc_id)); + let data_id = data_id_for_alloc_id(&mut fx.cx.module, alloc_id, alloc.align, alloc.mutability); - let local_data_id = fx.codegen_cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); + let local_data_id = fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); #[cfg(debug_assertions)] fx.add_comment(local_data_id, format!("{:?}", alloc_id)); let global_ptr = fx.bcx.ins().global_value(fx.pointer_type, local_data_id); @@ -419,7 +419,7 @@ pub(crate) fn mir_operand_get_const_val<'tcx>( match operand { Operand::Copy(_) | Operand::Move(_) => None, Operand::Constant(const_) => { - Some(fx.monomorphize(&const_.literal).eval(fx.codegen_cx.tcx, ParamEnv::reveal_all())) + Some(fx.monomorphize(&const_.literal).eval(fx.cx.tcx, ParamEnv::reveal_all())) } } } diff --git a/src/discriminant.rs b/src/discriminant.rs index efe95322aae..97a92eaf512 100644 --- a/src/discriminant.rs +++ b/src/discriminant.rs @@ -26,7 +26,7 @@ pub(crate) fn codegen_set_discriminant<'tcx>( let ptr = place.place_field(fx, mir::Field::new(tag_field)); let to = layout .ty - .discriminant_for_variant(fx.codegen_cx.tcx, variant_index) + .discriminant_for_variant(fx.cx.tcx, variant_index) .unwrap() .val; let discr = CValue::const_val(fx, ptr.layout(), to); @@ -73,7 +73,7 @@ pub(crate) fn codegen_get_discriminant<'tcx>( Variants::Single { index } => { let discr_val = layout .ty - .discriminant_for_variant(fx.codegen_cx.tcx, *index) + .discriminant_for_variant(fx.cx.tcx, *index) .map_or(u128::from(index.as_u32()), |discr| discr.val); return CValue::const_val(fx, dest_layout, discr_val); } diff --git a/src/inline_asm.rs b/src/inline_asm.rs index f0ae0854f84..0f162d6e94b 100644 --- a/src/inline_asm.rs +++ b/src/inline_asm.rs @@ -70,10 +70,10 @@ pub(crate) fn codegen_inline_asm<'tcx>( let inline_asm_index = fx.inline_asm_index; fx.inline_asm_index += 1; - let asm_name = format!("{}__inline_asm_{}", fx.codegen_cx.tcx.symbol_name(fx.instance).name, inline_asm_index); + let asm_name = format!("{}__inline_asm_{}", fx.cx.tcx.symbol_name(fx.instance).name, inline_asm_index); let generated_asm = generate_asm_wrapper(&asm_name, InlineAsmArch::X86_64, options, template, clobbered_regs, &inputs, &outputs); - fx.codegen_cx.global_asm.push_str(&generated_asm); + fx.cx.global_asm.push_str(&generated_asm); call_inline_asm(fx, &asm_name, slot_size, inputs, outputs); } @@ -169,12 +169,12 @@ fn call_inline_asm<'tcx>( #[cfg(debug_assertions)] fx.add_comment(stack_slot, "inline asm scratch slot"); - let inline_asm_func = fx.codegen_cx.module.declare_function(asm_name, Linkage::Import, &Signature { + let inline_asm_func = fx.cx.module.declare_function(asm_name, Linkage::Import, &Signature { call_conv: CallConv::SystemV, params: vec![AbiParam::new(fx.pointer_type)], returns: vec![], }).unwrap(); - let inline_asm_func = fx.codegen_cx.module.declare_func_in_func(inline_asm_func, &mut fx.bcx.func); + let inline_asm_func = fx.cx.module.declare_func_in_func(inline_asm_func, &mut fx.bcx.func); #[cfg(debug_assertions)] fx.add_comment(inline_asm_func, asm_name); diff --git a/src/intrinsics/llvm.rs b/src/intrinsics/llvm.rs index 171eb51ccdf..45d655fb5ed 100644 --- a/src/intrinsics/llvm.rs +++ b/src/intrinsics/llvm.rs @@ -30,13 +30,13 @@ pub(crate) fn codegen_llvm_intrinsic_call<'tcx>( intrinsic_match! { fx, intrinsic, substs, args, _ => { - fx.codegen_cx.tcx.sess.warn(&format!("unsupported llvm intrinsic {}; replacing with trap", intrinsic)); + fx.cx.tcx.sess.warn(&format!("unsupported llvm intrinsic {}; replacing with trap", intrinsic)); crate::trap::trap_unimplemented(fx, intrinsic); }; // Used by `_mm_movemask_epi8` and `_mm256_movemask_epi8` llvm.x86.sse2.pmovmskb.128 | llvm.x86.avx2.pmovmskb | llvm.x86.sse2.movmsk.pd, (c a) { - let (lane_layout, lane_count) = lane_type_and_count(fx.codegen_cx.tcx, a.layout()); + let (lane_layout, lane_count) = lane_type_and_count(fx.cx.tcx, a.layout()); let lane_ty = fx.clif_type(lane_layout.ty).unwrap(); assert!(lane_count <= 32); @@ -61,7 +61,7 @@ pub(crate) fn codegen_llvm_intrinsic_call<'tcx>( res = fx.bcx.ins().bor(res, a_lane_sign); } - let res = CValue::by_val(res, fx.layout_of(fx.codegen_cx.tcx.types.i32)); + let res = CValue::by_val(res, fx.layout_of(fx.cx.tcx.types.i32)); ret.write_cvalue(fx, res); }; llvm.x86.sse2.cmp.ps | llvm.x86.sse2.cmp.pd, (c x, c y, o kind) { diff --git a/src/intrinsics/mod.rs b/src/intrinsics/mod.rs index f73e9f765c0..454a0d2b91b 100644 --- a/src/intrinsics/mod.rs +++ b/src/intrinsics/mod.rs @@ -88,7 +88,7 @@ macro call_intrinsic_match { let ($($arg,)*) = ( $(trans_operand($fx, $arg),)* ); - let res = $fx.easy_call(stringify!($func), &[$($arg),*], $fx.codegen_cx.tcx.types.$ty); + let res = $fx.easy_call(stringify!($func), &[$($arg),*], $fx.cx.tcx.types.$ty); $ret.write_cvalue($fx, res); if let Some((_, dest)) = $destination { @@ -144,7 +144,7 @@ macro validate_atomic_type($fx:ident, $intrinsic:ident, $span:ident, $ty:expr) { match $ty.kind { ty::Uint(_) | ty::Int(_) => {} _ => { - $fx.codegen_cx.tcx.sess.span_err($span, &format!("`{}` intrinsic: expected basic integer type, found `{:?}`", $intrinsic, $ty)); + $fx.cx.tcx.sess.span_err($span, &format!("`{}` intrinsic: expected basic integer type, found `{:?}`", $intrinsic, $ty)); // Prevent verifier error crate::trap::trap_unreachable($fx, "compilation should not have succeeded"); return; @@ -154,7 +154,7 @@ macro validate_atomic_type($fx:ident, $intrinsic:ident, $span:ident, $ty:expr) { macro validate_simd_type($fx:ident, $intrinsic:ident, $span:ident, $ty:expr) { if !$ty.is_simd() { - $fx.codegen_cx.tcx.sess.span_err($span, &format!("invalid monomorphization of `{}` intrinsic: expected SIMD input type, found non-SIMD `{}`", $intrinsic, $ty)); + $fx.cx.tcx.sess.span_err($span, &format!("invalid monomorphization of `{}` intrinsic: expected SIMD input type, found non-SIMD `{}`", $intrinsic, $ty)); // Prevent verifier error crate::trap::trap_unreachable($fx, "compilation should not have succeeded"); return; @@ -203,8 +203,8 @@ fn simd_for_each_lane<'tcx, B: Backend>( ) { let layout = val.layout(); - let (lane_layout, lane_count) = lane_type_and_count(fx.codegen_cx.tcx, layout); - let (ret_lane_layout, ret_lane_count) = lane_type_and_count(fx.codegen_cx.tcx, ret.layout()); + let (lane_layout, lane_count) = lane_type_and_count(fx.cx.tcx, layout); + let (ret_lane_layout, ret_lane_count) = lane_type_and_count(fx.cx.tcx, ret.layout()); assert_eq!(lane_count, ret_lane_count); for lane_idx in 0..lane_count { @@ -233,8 +233,8 @@ fn simd_pair_for_each_lane<'tcx, B: Backend>( assert_eq!(x.layout(), y.layout()); let layout = x.layout(); - let (lane_layout, lane_count) = lane_type_and_count(fx.codegen_cx.tcx, layout); - let (ret_lane_layout, ret_lane_count) = lane_type_and_count(fx.codegen_cx.tcx, ret.layout()); + let (lane_layout, lane_count) = lane_type_and_count(fx.cx.tcx, layout); + let (ret_lane_layout, ret_lane_count) = lane_type_and_count(fx.cx.tcx, ret.layout()); assert_eq!(lane_count, ret_lane_count); for lane in 0..lane_count { @@ -273,7 +273,7 @@ fn bool_to_zero_or_max_uint<'tcx>( macro simd_cmp { ($fx:expr, $cc:ident($x:ident, $y:ident) -> $ret:ident) => { - let vector_ty = clif_vector_type($fx.codegen_cx.tcx, $x.layout()); + let vector_ty = clif_vector_type($fx.cx.tcx, $x.layout()); if let Some(vector_ty) = vector_ty { let x = $x.load_scalar($fx); @@ -390,7 +390,7 @@ pub(crate) fn codegen_intrinsic_call<'tcx>( let def_id = instance.def_id(); let substs = instance.substs; - let intrinsic = fx.codegen_cx.tcx.item_name(def_id).as_str(); + let intrinsic = fx.cx.tcx.item_name(def_id).as_str(); let intrinsic = &intrinsic[..]; let ret = match destination { @@ -423,7 +423,7 @@ pub(crate) fn codegen_intrinsic_call<'tcx>( return; } - let usize_layout = fx.layout_of(fx.codegen_cx.tcx.types.usize); + let usize_layout = fx.layout_of(fx.cx.tcx.types.usize); call_intrinsic_match! { fx, intrinsic, substs, ret, destination, args, @@ -473,7 +473,7 @@ pub(crate) fn codegen_intrinsic_call<'tcx>( intrinsic_match! { fx, intrinsic, substs, args, _ => { - fx.codegen_cx.tcx.sess.span_fatal(span, &format!("unsupported intrinsic {}", intrinsic)); + fx.cx.tcx.sess.span_fatal(span, &format!("unsupported intrinsic {}", intrinsic)); }; assume, (c _a) {}; @@ -494,10 +494,10 @@ pub(crate) fn codegen_intrinsic_call<'tcx>( if intrinsic.contains("nonoverlapping") { // FIXME emit_small_memcpy - fx.bcx.call_memcpy(fx.codegen_cx.module.target_config(), dst, src, byte_amount); + fx.bcx.call_memcpy(fx.cx.module.target_config(), dst, src, byte_amount); } else { // FIXME emit_small_memmove - fx.bcx.call_memmove(fx.codegen_cx.module.target_config(), dst, src, byte_amount); + fx.bcx.call_memmove(fx.cx.module.target_config(), dst, src, byte_amount); } }; // NOTE: the volatile variants have src and dst swapped @@ -513,10 +513,10 @@ pub(crate) fn codegen_intrinsic_call<'tcx>( // FIXME make the copy actually volatile when using emit_small_mem{cpy,move} if intrinsic.contains("nonoverlapping") { // FIXME emit_small_memcpy - fx.bcx.call_memcpy(fx.codegen_cx.module.target_config(), dst, src, byte_amount); + fx.bcx.call_memcpy(fx.cx.module.target_config(), dst, src, byte_amount); } else { // FIXME emit_small_memmove - fx.bcx.call_memmove(fx.codegen_cx.module.target_config(), dst, src, byte_amount); + fx.bcx.call_memmove(fx.cx.module.target_config(), dst, src, byte_amount); } }; discriminant_value, (c ptr) { @@ -680,11 +680,11 @@ pub(crate) fn codegen_intrinsic_call<'tcx>( let dst_ptr = dst.load_scalar(fx); // FIXME make the memset actually volatile when switching to emit_small_memset // FIXME use emit_small_memset - fx.bcx.call_memset(fx.codegen_cx.module.target_config(), dst_ptr, val, count); + fx.bcx.call_memset(fx.cx.module.target_config(), dst_ptr, val, count); }; ctlz | ctlz_nonzero, (v arg) { // FIXME trap on `ctlz_nonzero` with zero arg. - let res = if T == fx.codegen_cx.tcx.types.u128 || T == fx.codegen_cx.tcx.types.i128 { + let res = if T == fx.cx.tcx.types.u128 || T == fx.cx.tcx.types.i128 { // FIXME verify this algorithm is correct let (lsb, msb) = fx.bcx.ins().isplit(arg); let lsb_lz = fx.bcx.ins().clz(lsb); @@ -701,7 +701,7 @@ pub(crate) fn codegen_intrinsic_call<'tcx>( }; cttz | cttz_nonzero, (v arg) { // FIXME trap on `cttz_nonzero` with zero arg. - let res = if T == fx.codegen_cx.tcx.types.u128 || T == fx.codegen_cx.tcx.types.i128 { + let res = if T == fx.cx.tcx.types.u128 || T == fx.cx.tcx.types.i128 { // FIXME verify this algorithm is correct let (lsb, msb) = fx.bcx.ins().isplit(arg); let lsb_tz = fx.bcx.ins().ctz(lsb); @@ -842,7 +842,7 @@ pub(crate) fn codegen_intrinsic_call<'tcx>( size_of | pref_align_of | min_align_of | needs_drop | type_id | type_name | variant_count, () { let const_val = - fx.codegen_cx.tcx.const_eval_instance(ParamEnv::reveal_all(), instance, None).unwrap(); + fx.cx.tcx.const_eval_instance(ParamEnv::reveal_all(), instance, None).unwrap(); let val = crate::constant::trans_const_value( fx, const_val, @@ -852,7 +852,7 @@ pub(crate) fn codegen_intrinsic_call<'tcx>( }; ptr_offset_from, (v ptr, v base) { - let isize_layout = fx.layout_of(fx.codegen_cx.tcx.types.isize); + let isize_layout = fx.layout_of(fx.cx.tcx.types.isize); let pointee_size: u64 = fx.layout_of(T).size.bytes(); let diff = fx.bcx.ins().isub(ptr, base); @@ -1011,22 +1011,22 @@ pub(crate) fn codegen_intrinsic_call<'tcx>( minnumf32, (v a, v b) { let val = fx.bcx.ins().fmin(a, b); - let val = CValue::by_val(val, fx.layout_of(fx.codegen_cx.tcx.types.f32)); + let val = CValue::by_val(val, fx.layout_of(fx.cx.tcx.types.f32)); ret.write_cvalue(fx, val); }; minnumf64, (v a, v b) { let val = fx.bcx.ins().fmin(a, b); - let val = CValue::by_val(val, fx.layout_of(fx.codegen_cx.tcx.types.f64)); + let val = CValue::by_val(val, fx.layout_of(fx.cx.tcx.types.f64)); ret.write_cvalue(fx, val); }; maxnumf32, (v a, v b) { let val = fx.bcx.ins().fmax(a, b); - let val = CValue::by_val(val, fx.layout_of(fx.codegen_cx.tcx.types.f32)); + let val = CValue::by_val(val, fx.layout_of(fx.cx.tcx.types.f32)); ret.write_cvalue(fx, val); }; maxnumf64, (v a, v b) { let val = fx.bcx.ins().fmax(a, b); - let val = CValue::by_val(val, fx.layout_of(fx.codegen_cx.tcx.types.f64)); + let val = CValue::by_val(val, fx.layout_of(fx.cx.tcx.types.f64)); ret.write_cvalue(fx, val); }; diff --git a/src/intrinsics/simd.rs b/src/intrinsics/simd.rs index bdda4bd9840..0a564be44a0 100644 --- a/src/intrinsics/simd.rs +++ b/src/intrinsics/simd.rs @@ -11,13 +11,13 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>( let def_id = instance.def_id(); let substs = instance.substs; - let intrinsic = fx.codegen_cx.tcx.item_name(def_id).as_str(); + let intrinsic = fx.cx.tcx.item_name(def_id).as_str(); let intrinsic = &intrinsic[..]; intrinsic_match! { fx, intrinsic, substs, args, _ => { - fx.codegen_cx.tcx.sess.span_fatal(span, &format!("Unknown SIMD intrinsic {}", intrinsic)); + fx.cx.tcx.sess.span_fatal(span, &format!("Unknown SIMD intrinsic {}", intrinsic)); }; simd_cast, (c a) { @@ -68,8 +68,8 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>( assert_eq!(x.layout(), y.layout()); let layout = x.layout(); - let (lane_type, lane_count) = lane_type_and_count(fx.codegen_cx.tcx, layout); - let (ret_lane_type, ret_lane_count) = lane_type_and_count(fx.codegen_cx.tcx, ret.layout()); + let (lane_type, lane_count) = lane_type_and_count(fx.cx.tcx, layout); + let (ret_lane_type, ret_lane_count) = lane_type_and_count(fx.cx.tcx, ret.layout()); assert_eq!(lane_type, ret_lane_type); assert_eq!(n, ret_lane_count); @@ -92,7 +92,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>( (0..ret_lane_count).map(|i| { let i = usize::try_from(i).unwrap(); let idx = rustc_middle::mir::interpret::read_target_uint( - fx.codegen_cx.tcx.data_layout.endian, + fx.cx.tcx.data_layout.endian, &idx_bytes[4*i.. 4*i + 4], ).expect("read_target_uint"); u16::try_from(idx).expect("try_from u32") @@ -119,7 +119,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>( let idx_const = if let Some(idx_const) = crate::constant::mir_operand_get_const_val(fx, idx) { idx_const } else { - fx.codegen_cx.tcx.sess.span_warn( + fx.cx.tcx.sess.span_warn( fx.mir.span, "`#[rustc_arg_required_const(..)]` is not yet supported. Calling this function will panic.", ); @@ -128,9 +128,9 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>( }; let idx = idx_const.val.try_to_bits(Size::from_bytes(4 /* u32*/)).expect(&format!("kind not scalar: {:?}", idx_const)); - let (_lane_type, lane_count) = lane_type_and_count(fx.codegen_cx.tcx, base.layout()); + let (_lane_type, lane_count) = lane_type_and_count(fx.cx.tcx, base.layout()); if idx >= lane_count.into() { - fx.codegen_cx.tcx.sess.span_fatal(fx.mir.span, &format!("[simd_insert] idx {} >= lane_count {}", idx, lane_count)); + fx.cx.tcx.sess.span_fatal(fx.mir.span, &format!("[simd_insert] idx {} >= lane_count {}", idx, lane_count)); } ret.write_cvalue(fx, base); @@ -143,7 +143,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>( let idx_const = if let Some(idx_const) = crate::constant::mir_operand_get_const_val(fx, idx) { idx_const } else { - fx.codegen_cx.tcx.sess.span_warn( + fx.cx.tcx.sess.span_warn( fx.mir.span, "`#[rustc_arg_required_const(..)]` is not yet supported. Calling this function will panic.", ); @@ -153,9 +153,9 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>( }; let idx = idx_const.val.try_to_bits(Size::from_bytes(4 /* u32*/)).expect(&format!("kind not scalar: {:?}", idx_const)); - let (_lane_type, lane_count) = lane_type_and_count(fx.codegen_cx.tcx, v.layout()); + let (_lane_type, lane_count) = lane_type_and_count(fx.cx.tcx, v.layout()); if idx >= lane_count.into() { - fx.codegen_cx.tcx.sess.span_fatal(fx.mir.span, &format!("[simd_extract] idx {} >= lane_count {}", idx, lane_count)); + fx.cx.tcx.sess.span_fatal(fx.mir.span, &format!("[simd_extract] idx {} >= lane_count {}", idx, lane_count)); } let ret_lane = v.value_field(fx, mir::Field::new(idx.try_into().unwrap())); @@ -205,8 +205,8 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>( assert_eq!(a.layout(), c.layout()); let layout = a.layout(); - let (_lane_layout, lane_count) = lane_type_and_count(fx.codegen_cx.tcx, layout); - let (ret_lane_layout, ret_lane_count) = lane_type_and_count(fx.codegen_cx.tcx, ret.layout()); + let (_lane_layout, lane_count) = lane_type_and_count(fx.cx.tcx, layout); + let (ret_lane_layout, ret_lane_count) = lane_type_and_count(fx.cx.tcx, ret.layout()); assert_eq!(lane_count, ret_lane_count); for lane in 0..lane_count { diff --git a/src/num.rs b/src/num.rs index 06721e1af12..5b1097b2be7 100644 --- a/src/num.rs +++ b/src/num.rs @@ -48,7 +48,7 @@ fn codegen_compare_bin_op<'tcx>( let intcc = crate::num::bin_op_to_intcc(bin_op, signed).unwrap(); let val = fx.bcx.ins().icmp(intcc, lhs, rhs); let val = fx.bcx.ins().bint(types::I8, val); - CValue::by_val(val, fx.layout_of(fx.codegen_cx.tcx.types.bool)) + CValue::by_val(val, fx.layout_of(fx.cx.tcx.types.bool)) } pub(crate) fn codegen_binop<'tcx>( @@ -66,8 +66,8 @@ pub(crate) fn codegen_binop<'tcx>( let rhs = in_rhs.load_scalar(fx); let (lhs, rhs) = if (bin_op == BinOp::Eq || bin_op == BinOp::Ne) - && (in_lhs.layout().ty.kind == fx.codegen_cx.tcx.types.i8.kind - || in_lhs.layout().ty.kind == fx.codegen_cx.tcx.types.i16.kind) + && (in_lhs.layout().ty.kind == fx.cx.tcx.types.i8.kind + || in_lhs.layout().ty.kind == fx.cx.tcx.types.i16.kind) { // FIXME(CraneStation/cranelift#896) icmp_imm.i8/i16 with eq/ne for signed ints is implemented wrong. ( @@ -118,7 +118,7 @@ pub(crate) fn trans_bool_binop<'tcx>( _ => unreachable!("{:?}({:?}, {:?})", bin_op, in_lhs, in_rhs), }; - CValue::by_val(res, fx.layout_of(fx.codegen_cx.tcx.types.bool)) + CValue::by_val(res, fx.layout_of(fx.cx.tcx.types.bool)) } pub(crate) fn trans_int_binop<'tcx>( @@ -323,7 +323,7 @@ pub(crate) fn trans_checked_int_binop<'tcx>( // FIXME directly write to result place instead let out_place = CPlace::new_stack_slot( fx, - fx.layout_of(fx.codegen_cx.tcx.mk_tup([in_lhs.layout().ty, fx.codegen_cx.tcx.types.bool].iter())), + fx.layout_of(fx.cx.tcx.mk_tup([in_lhs.layout().ty, fx.cx.tcx.types.bool].iter())), ); let out_layout = out_place.layout(); out_place.write_cvalue(fx, CValue::by_val_pair(res, has_overflow, out_layout)); @@ -368,7 +368,7 @@ pub(crate) fn trans_float_binop<'tcx>( }; let val = fx.bcx.ins().fcmp(fltcc, lhs, rhs); let val = fx.bcx.ins().bint(types::I8, val); - return CValue::by_val(val, fx.layout_of(fx.codegen_cx.tcx.types.bool)); + return CValue::by_val(val, fx.layout_of(fx.cx.tcx.types.bool)); } _ => unreachable!("{:?}({:?}, {:?})", bin_op, in_lhs, in_rhs), }; @@ -383,7 +383,7 @@ pub(crate) fn trans_ptr_binop<'tcx>( in_rhs: CValue<'tcx>, ) -> CValue<'tcx> { let is_thin_ptr = in_lhs.layout().ty.builtin_deref(true).map(|TypeAndMut { ty, mutbl: _}| { - !has_ptr_meta(fx.codegen_cx.tcx, ty) + !has_ptr_meta(fx.cx.tcx, ty) }).unwrap_or(true); if is_thin_ptr { @@ -440,7 +440,7 @@ pub(crate) fn trans_ptr_binop<'tcx>( CValue::by_val( fx.bcx.ins().bint(types::I8, res), - fx.layout_of(fx.codegen_cx.tcx.types.bool), + fx.layout_of(fx.cx.tcx.types.bool), ) } } diff --git a/src/trap.rs b/src/trap.rs index d48bf6a4298..9b75e61ba76 100644 --- a/src/trap.rs +++ b/src/trap.rs @@ -2,24 +2,24 @@ use crate::prelude::*; fn codegen_print(fx: &mut FunctionCx<'_, '_, impl cranelift_module::Backend>, msg: &str) { let puts = fx - .codegen_cx.module + .cx.module .declare_function( "puts", Linkage::Import, &Signature { call_conv: CallConv::triple_default(fx.triple()), - params: vec![AbiParam::new(pointer_ty(fx.codegen_cx.tcx))], + params: vec![AbiParam::new(pointer_ty(fx.cx.tcx))], returns: vec![AbiParam::new(types::I32)], }, ) .unwrap(); - let puts = fx.codegen_cx.module.declare_func_in_func(puts, &mut fx.bcx.func); + let puts = fx.cx.module.declare_func_in_func(puts, &mut fx.bcx.func); #[cfg(debug_assertions)] { fx.add_comment(puts, "puts"); } - let symbol_name = fx.codegen_cx.tcx.symbol_name(fx.instance); + let symbol_name = fx.cx.tcx.symbol_name(fx.instance); let real_msg = format!("trap at {:?} ({}): {}\0", fx.instance, symbol_name, msg); let msg_ptr = fx.anonymous_str("trap", &real_msg); fx.bcx.ins().call(puts, &[msg_ptr]); diff --git a/src/unsize.rs b/src/unsize.rs index fec1bfd799f..5746f109afd 100644 --- a/src/unsize.rs +++ b/src/unsize.rs @@ -15,12 +15,12 @@ pub(crate) fn unsized_info<'tcx>( old_info: Option, ) -> Value { let (source, target) = - fx.codegen_cx.tcx + fx.cx.tcx .struct_lockstep_tails_erasing_lifetimes(source, target, ParamEnv::reveal_all()); match (&source.kind, &target.kind) { (&ty::Array(_, len), &ty::Slice(_)) => fx.bcx.ins().iconst( fx.pointer_type, - len.eval_usize(fx.codegen_cx.tcx, ParamEnv::reveal_all()) as i64, + len.eval_usize(fx.cx.tcx, ParamEnv::reveal_all()) as i64, ), (&ty::Dynamic(..), &ty::Dynamic(..)) => { // For now, upcasts are limited to changes in marker diff --git a/src/value_and_place.rs b/src/value_and_place.rs index 4483691013d..abe9437d429 100644 --- a/src/value_and_place.rs +++ b/src/value_and_place.rs @@ -35,10 +35,10 @@ fn codegen_field<'tcx>( let unaligned_offset = field_offset.bytes(); let (_, unsized_align) = crate::unsize::size_and_align_of_dst(fx, field_layout, extra); - let one = fx.bcx.ins().iconst(pointer_ty(fx.codegen_cx.tcx), 1); + let one = fx.bcx.ins().iconst(pointer_ty(fx.cx.tcx), 1); let align_sub_1 = fx.bcx.ins().isub(unsized_align, one); let and_lhs = fx.bcx.ins().iadd_imm(align_sub_1, unaligned_offset as i64); - let zero = fx.bcx.ins().iconst(pointer_ty(fx.codegen_cx.tcx), 0); + let zero = fx.bcx.ins().iconst(pointer_ty(fx.cx.tcx), 0); let and_rhs = fx.bcx.ins().isub(zero, unsized_align); let offset = fx.bcx.ins().band(and_lhs, and_rhs); @@ -119,9 +119,9 @@ impl<'tcx> CValue<'tcx> { match self.0 { CValueInner::ByRef(ptr, None) => { let clif_ty = match layout.abi { - Abi::Scalar(ref scalar) => scalar_to_clif_type(fx.codegen_cx.tcx, scalar.clone()), + Abi::Scalar(ref scalar) => scalar_to_clif_type(fx.cx.tcx, scalar.clone()), Abi::Vector { ref element, count } => { - scalar_to_clif_type(fx.codegen_cx.tcx, element.clone()) + scalar_to_clif_type(fx.cx.tcx, element.clone()) .by(u16::try_from(count).unwrap()).unwrap() } _ => unreachable!("{:?}", layout.ty), @@ -146,9 +146,9 @@ impl<'tcx> CValue<'tcx> { Abi::ScalarPair(a, b) => (a, b), _ => unreachable!("load_scalar_pair({:?})", self), }; - let b_offset = scalar_pair_calculate_b_offset(fx.codegen_cx.tcx, a_scalar, b_scalar); - let clif_ty1 = scalar_to_clif_type(fx.codegen_cx.tcx, a_scalar.clone()); - let clif_ty2 = scalar_to_clif_type(fx.codegen_cx.tcx, b_scalar.clone()); + let b_offset = scalar_pair_calculate_b_offset(fx.cx.tcx, a_scalar, b_scalar); + let clif_ty1 = scalar_to_clif_type(fx.cx.tcx, a_scalar.clone()); + let clif_ty2 = scalar_to_clif_type(fx.cx.tcx, b_scalar.clone()); let val1 = ptr.load(fx, clif_ty1, MemFlags::new()); let val2 = ptr.offset(fx, b_offset).load(fx, clif_ty2, MemFlags::new()); (val1, val2) @@ -419,13 +419,13 @@ impl<'tcx> CPlace<'tcx> { assert_assignable(fx, a, b); } (ty::FnPtr(_), ty::FnPtr(_)) => { - let from_sig = fx.codegen_cx.tcx.normalize_erasing_late_bound_regions( + let from_sig = fx.cx.tcx.normalize_erasing_late_bound_regions( ParamEnv::reveal_all(), - &from_ty.fn_sig(fx.codegen_cx.tcx), + &from_ty.fn_sig(fx.cx.tcx), ); - let to_sig = fx.codegen_cx.tcx.normalize_erasing_late_bound_regions( + let to_sig = fx.cx.tcx.normalize_erasing_late_bound_regions( ParamEnv::reveal_all(), - &to_ty.fn_sig(fx.codegen_cx.tcx), + &to_ty.fn_sig(fx.cx.tcx), ); assert_eq!( from_sig, to_sig, @@ -436,10 +436,10 @@ impl<'tcx> CPlace<'tcx> { } (ty::Dynamic(from_traits, _), ty::Dynamic(to_traits, _)) => { let from_traits = fx - .codegen_cx.tcx + .cx.tcx .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), from_traits); let to_traits = fx - .codegen_cx.tcx + .cx.tcx .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), to_traits); assert_eq!( from_traits, to_traits, @@ -569,7 +569,7 @@ impl<'tcx> CPlace<'tcx> { } Abi::ScalarPair(ref a_scalar, ref b_scalar) => { let (value, extra) = from.load_scalar_pair(fx); - let b_offset = scalar_pair_calculate_b_offset(fx.codegen_cx.tcx, a_scalar, b_scalar); + let b_offset = scalar_pair_calculate_b_offset(fx.cx.tcx, a_scalar, b_scalar); to_ptr.store(fx, value, MemFlags::new()); to_ptr.offset(fx, b_offset).store(fx, extra, MemFlags::new()); return; @@ -595,7 +595,7 @@ impl<'tcx> CPlace<'tcx> { let src_align = src_layout.align.abi.bytes() as u8; let dst_align = dst_layout.align.abi.bytes() as u8; fx.bcx.emit_small_memory_copy( - fx.codegen_cx.module.target_config(), + fx.cx.module.target_config(), to_addr, from_addr, size, @@ -673,7 +673,7 @@ impl<'tcx> CPlace<'tcx> { pub(crate) fn place_deref(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> CPlace<'tcx> { let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap().ty); - if has_ptr_meta(fx.codegen_cx.tcx, inner_layout.ty) { + if has_ptr_meta(fx.cx.tcx, inner_layout.ty) { let (addr, extra) = self.to_cvalue(fx).load_scalar_pair(fx); CPlace::for_ptr_with_extra(Pointer::new(addr), extra, inner_layout) } else { @@ -682,7 +682,7 @@ impl<'tcx> CPlace<'tcx> { } pub(crate) fn write_place_ref(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>, dest: CPlace<'tcx>) { - if has_ptr_meta(fx.codegen_cx.tcx, self.layout().ty) { + if has_ptr_meta(fx.cx.tcx, self.layout().ty) { let (ptr, extra) = self.to_ptr_maybe_unsized(); let ptr = CValue::by_val_pair( ptr.get_addr(fx), diff --git a/src/vtable.rs b/src/vtable.rs index 6be801c8445..8163d15836c 100644 --- a/src/vtable.rs +++ b/src/vtable.rs @@ -13,9 +13,9 @@ fn vtable_memflags() -> MemFlags { } pub(crate) fn drop_fn_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value { - let usize_size = fx.layout_of(fx.codegen_cx.tcx.types.usize).size.bytes() as usize; + let usize_size = fx.layout_of(fx.cx.tcx.types.usize).size.bytes() as usize; fx.bcx.ins().load( - pointer_ty(fx.codegen_cx.tcx), + pointer_ty(fx.cx.tcx), vtable_memflags(), vtable, (DROP_FN_INDEX * usize_size) as i32, @@ -23,9 +23,9 @@ pub(crate) fn drop_fn_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: } pub(crate) fn size_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value { - let usize_size = fx.layout_of(fx.codegen_cx.tcx.types.usize).size.bytes() as usize; + let usize_size = fx.layout_of(fx.cx.tcx.types.usize).size.bytes() as usize; fx.bcx.ins().load( - pointer_ty(fx.codegen_cx.tcx), + pointer_ty(fx.cx.tcx), vtable_memflags(), vtable, (SIZE_INDEX * usize_size) as i32, @@ -33,9 +33,9 @@ pub(crate) fn size_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Val } pub(crate) fn min_align_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value { - let usize_size = fx.layout_of(fx.codegen_cx.tcx.types.usize).size.bytes() as usize; + let usize_size = fx.layout_of(fx.cx.tcx.types.usize).size.bytes() as usize; fx.bcx.ins().load( - pointer_ty(fx.codegen_cx.tcx), + pointer_ty(fx.cx.tcx), vtable_memflags(), vtable, (ALIGN_INDEX * usize_size) as i32, @@ -57,9 +57,9 @@ pub(crate) fn get_ptr_and_method_ref<'tcx>( ) }; - let usize_size = fx.layout_of(fx.codegen_cx.tcx.types.usize).size.bytes(); + let usize_size = fx.layout_of(fx.cx.tcx.types.usize).size.bytes(); let func_ref = fx.bcx.ins().load( - pointer_ty(fx.codegen_cx.tcx), + pointer_ty(fx.cx.tcx), vtable_memflags(), vtable, ((idx + 3) * usize_size as usize) as i32, @@ -72,15 +72,15 @@ pub(crate) fn get_vtable<'tcx>( layout: TyAndLayout<'tcx>, trait_ref: Option>, ) -> Value { - let data_id = if let Some(data_id) = fx.codegen_cx.vtables.get(&(layout.ty, trait_ref)) { + let data_id = if let Some(data_id) = fx.cx.vtables.get(&(layout.ty, trait_ref)) { *data_id } else { let data_id = build_vtable(fx, layout, trait_ref); - fx.codegen_cx.vtables.insert((layout.ty, trait_ref), data_id); + fx.cx.vtables.insert((layout.ty, trait_ref), data_id); data_id }; - let local_data_id = fx.codegen_cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); + let local_data_id = fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func); fx.bcx.ins().global_value(fx.pointer_type, local_data_id) } @@ -89,11 +89,11 @@ fn build_vtable<'tcx>( layout: TyAndLayout<'tcx>, trait_ref: Option>, ) -> DataId { - let tcx = fx.codegen_cx.tcx; - let usize_size = fx.layout_of(fx.codegen_cx.tcx.types.usize).size.bytes() as usize; + let tcx = fx.cx.tcx; + let usize_size = fx.layout_of(fx.cx.tcx.types.usize).size.bytes() as usize; let drop_in_place_fn = - import_function(tcx, &mut fx.codegen_cx.module, Instance::resolve_drop_in_place(tcx, layout.ty).polymorphize(fx.codegen_cx.tcx)); + import_function(tcx, &mut fx.cx.module, Instance::resolve_drop_in_place(tcx, layout.ty).polymorphize(fx.cx.tcx)); let mut components: Vec<_> = vec![Some(drop_in_place_fn), None, None]; @@ -108,8 +108,8 @@ fn build_vtable<'tcx>( opt_mth.map_or(None, |(def_id, substs)| { Some(import_function( tcx, - &mut fx.codegen_cx.module, - Instance::resolve_for_vtable(tcx, ParamEnv::reveal_all(), def_id, substs).unwrap().polymorphize(fx.codegen_cx.tcx), + &mut fx.cx.module, + Instance::resolve_for_vtable(tcx, ParamEnv::reveal_all(), def_id, substs).unwrap().polymorphize(fx.cx.tcx), )) }) }); @@ -121,19 +121,19 @@ fn build_vtable<'tcx>( .collect::>() .into_boxed_slice(); - write_usize(fx.codegen_cx.tcx, &mut data, SIZE_INDEX, layout.size.bytes()); - write_usize(fx.codegen_cx.tcx, &mut data, ALIGN_INDEX, layout.align.abi.bytes()); + write_usize(fx.cx.tcx, &mut data, SIZE_INDEX, layout.size.bytes()); + write_usize(fx.cx.tcx, &mut data, ALIGN_INDEX, layout.align.abi.bytes()); data_ctx.define(data); for (i, component) in components.into_iter().enumerate() { if let Some(func_id) = component { - let func_ref = fx.codegen_cx.module.declare_func_in_data(func_id, &mut data_ctx); + let func_ref = fx.cx.module.declare_func_in_data(func_id, &mut data_ctx); data_ctx.write_function_addr((i * usize_size) as u32, func_ref); } } let data_id = fx - .codegen_cx.module + .cx.module .declare_data( &format!( "__vtable.{}.for.{:?}.{}", @@ -142,13 +142,13 @@ fn build_vtable<'tcx>( .map(|trait_ref| format!("{:?}", trait_ref.skip_binder()).into()) .unwrap_or(std::borrow::Cow::Borrowed("???")), layout.ty, - fx.codegen_cx.vtables.len(), + fx.cx.vtables.len(), ), Linkage::Local, false, false, Some( - fx.codegen_cx.tcx + fx.cx.tcx .data_layout .pointer_align .pref @@ -159,7 +159,7 @@ fn build_vtable<'tcx>( ) .unwrap(); - fx.codegen_cx.module.define_data(data_id, &data_ctx).unwrap(); + fx.cx.module.define_data(data_id, &data_ctx).unwrap(); data_id }