use crate::prelude::*;
-pub(crate) fn trans_fn<'clif, 'tcx, B: Backend + 'static>(
- cx: &mut crate::CodegenCx<'clif, 'tcx, B>,
+pub(crate) fn trans_fn<'tcx, B: Backend + 'static>(
+ cx: &mut crate::CodegenCx<'tcx, B>,
instance: Instance<'tcx>,
linkage: Linkage,
) {
let mut fx = FunctionCx {
tcx,
- module: cx.module,
+ module: &mut cx.module,
pointer_type,
instance,
impl<'tcx> UnwindContext<'tcx> {
pub(crate) fn new(
tcx: TyCtxt<'tcx>,
- module: &mut Module<impl Backend>,
+ isa: &dyn TargetIsa,
) -> Self {
let mut frame_table = FrameTable::default();
- let cie_id = if let Some(cie) = module.isa().create_systemv_cie() {
+ let cie_id = if let Some(cie) = isa.create_systemv_cie() {
Some(frame_table.add_cie(cie))
} else {
None
let cgu = tcx.codegen_unit(cgu_name);
let mono_items = cgu.items_in_deterministic_order(tcx);
- let mut module = new_module(tcx, cgu_name.as_str().to_string());
+ let module = new_module(tcx, cgu_name.as_str().to_string());
- let mut debug = if tcx.sess.opts.debuginfo != DebugInfo::None {
- let debug = DebugContext::new(
- tcx,
- module.isa(),
- );
- Some(debug)
- } else {
- None
- };
-
- let mut unwind_context = UnwindContext::new(tcx, &mut module);
-
- super::codegen_mono_items(tcx, &mut module, debug.as_mut(), &mut unwind_context, mono_items);
+ let mut cx = CodegenCx::new(tcx, module, tcx.sess.opts.debuginfo != DebugInfo::None);
+ super::codegen_mono_items(&mut cx, mono_items);
+ let (mut module, debug, mut unwind_context) = tcx.sess.time("finalize CodegenCx", || cx.finalize());
crate::main_shim::maybe_create_entry_wrapper(tcx, &mut module, &mut unwind_context);
emit_module(
tcx.sess.abort_if_errors();
let mut allocator_module = new_module(tcx, "allocator_shim".to_string());
- let mut allocator_unwind_context = UnwindContext::new(tcx, &mut allocator_module);
+ let mut allocator_unwind_context = UnwindContext::new(tcx, allocator_module.isa());
let created_alloc_shim = crate::allocator::codegen(
tcx,
&mut allocator_module,
.into_iter()
.collect::<Vec<(_, (_, _))>>();
- let mut unwind_context = UnwindContext::new(tcx, &mut jit_module);
+ let mut cx = CodegenCx::new(tcx, jit_module, false);
- super::time(tcx, "codegen mono items", || {
- super::codegen_mono_items(tcx, &mut jit_module, None, &mut unwind_context, mono_items);
+ let (mut jit_module, _debug, mut unwind_context) = super::time(tcx, "codegen mono items", || {
+ super::codegen_mono_items(&mut cx, mono_items);
+ tcx.sess.time("finalize CodegenCx", || cx.finalize())
});
crate::main_shim::maybe_create_entry_wrapper(tcx, &mut jit_module, &mut unwind_context);
crate::allocator::codegen(tcx, &mut jit_module, &mut unwind_context);
}
fn codegen_mono_items<'tcx>(
- tcx: TyCtxt<'tcx>,
- module: &mut Module<impl Backend + 'static>,
- debug_context: Option<&mut DebugContext<'tcx>>,
- unwind_context: &mut UnwindContext<'tcx>,
+ cx: &mut CodegenCx<'tcx, impl Backend + 'static>,
mono_items: Vec<(MonoItem<'tcx>, (RLinkage, Visibility))>,
) {
- let mut cx = CodegenCx::new(tcx, module, debug_context, unwind_context);
-
- tcx.sess.time("predefine functions", || {
+ cx.tcx.sess.time("predefine functions", || {
for &(mono_item, (linkage, visibility)) in &mono_items {
match mono_item {
MonoItem::Fn(instance) => {
let (name, sig) =
- get_function_name_and_sig(tcx, cx.module.isa().triple(), instance, false);
+ get_function_name_and_sig(cx.tcx, cx.module.isa().triple(), instance, false);
let linkage = crate::linkage::get_clif_linkage(mono_item, linkage, visibility);
cx.module.declare_function(&name, linkage, &sig).unwrap();
}
for (mono_item, (linkage, visibility)) in mono_items {
let linkage = crate::linkage::get_clif_linkage(mono_item, linkage, visibility);
- trans_mono_item(&mut cx, mono_item, linkage);
+ trans_mono_item(cx, mono_item, linkage);
}
-
- tcx.sess.time("finalize CodegenCx", || cx.finalize());
}
-fn trans_mono_item<'clif, 'tcx, B: Backend + 'static>(
- cx: &mut crate::CodegenCx<'clif, 'tcx, B>,
+fn trans_mono_item<'tcx, B: Backend + 'static>(
+ cx: &mut crate::CodegenCx<'tcx, B>,
mono_item: MonoItem<'tcx>,
linkage: Linkage,
) {
}
}
-pub(crate) struct CodegenCx<'clif, 'tcx, B: Backend + 'static> {
+pub(crate) struct CodegenCx<'tcx, B: Backend + 'static> {
tcx: TyCtxt<'tcx>,
- module: &'clif mut Module<B>,
+ module: Module<B>,
constants_cx: ConstantCx,
cached_context: Context,
vtables: FxHashMap<(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>), DataId>,
- debug_context: Option<&'clif mut DebugContext<'tcx>>,
- unwind_context: &'clif mut UnwindContext<'tcx>,
+ debug_context: Option<DebugContext<'tcx>>,
+ unwind_context: UnwindContext<'tcx>,
}
-impl<'clif, 'tcx, B: Backend + 'static> CodegenCx<'clif, 'tcx, B> {
+impl<'tcx, B: Backend + 'static> CodegenCx<'tcx, B> {
fn new(
tcx: TyCtxt<'tcx>,
- module: &'clif mut Module<B>,
- debug_context: Option<&'clif mut DebugContext<'tcx>>,
- unwind_context: &'clif mut UnwindContext<'tcx>,
+ module: Module<B>,
+ debug_info: bool,
) -> Self {
+ let unwind_context = UnwindContext::new(tcx, module.isa());
+ let debug_context = if debug_info {
+ Some(DebugContext::new(
+ tcx,
+ module.isa(),
+ ))
+ } else {
+ None
+ };
CodegenCx {
tcx,
module,
}
}
- fn finalize(self) {
- self.constants_cx.finalize(self.tcx, self.module);
+ fn finalize(mut self) -> (Module<B>, Option<DebugContext<'tcx>>, UnwindContext<'tcx>) {
+ self.constants_cx.finalize(self.tcx, &mut self.module);
+ (self.module, self.debug_context, self.unwind_context)
}
}