Merge pull request #1076 from CohenArthur/use-codegencx-in-functioncx

Use CodegenCx in FunctionCx

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.tcx, self.module, inst);
+        let func_id = import_function(self.tcx, &mut self.cx.module, inst);
         let func_ref = self
-            .module
+            .cx.module
             .declare_func_in_func(func_id, &mut self.bcx.func);
 
         #[cfg(debug_assertions)]
@@ -250,11 +250,11 @@ pub(crate) fn lib_call(
             call_conv: CallConv::triple_default(self.triple()),
         };
         let func_id = self
-            .module
+            .cx.module
             .declare_function(&name, Linkage::Import, &sig)
             .unwrap();
         let func_ref = self
-            .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)]

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.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.module.declare_function("pthread_mutex_lock", Linkage::Import, &cranelift_codegen::ir::Signature {
-        call_conv: fx.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.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.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.module.declare_data_in_func(atomic_mutex, fx.bcx.func);
-    let atomic_mutex = fx.bcx.ins().global_value(fx.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.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.module.declare_function("pthread_mutex_unlock", Linkage::Import, &cranelift_codegen::ir::Signature {
-        call_conv: fx.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.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.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.module.declare_data_in_func(atomic_mutex, fx.bcx.func);
-    let atomic_mutex = fx.bcx.ins().global_value(fx.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]);
 }

src/base.rs

@@ -16,14 +16,16 @@ pub(crate) fn trans_fn<'tcx, B: Backend + 'static>(
     let (name, sig) = get_function_name_and_sig(tcx, cx.module.isa().triple(), instance, false);
     let func_id = cx.module.declare_function(&name, linkage, &sig).unwrap();
 
-    // Make FunctionBuilder
-    let context = &mut cx.cached_context;
-    context.clear();
-    context.func.name = ExternalName::user(0, func_id.as_u32());
-    context.func.signature = sig;
-    context.func.collect_debug_info();
+    cx.cached_context.clear();
+
+    // Make the FunctionBuilder
     let mut func_ctx = FunctionBuilderContext::new();
-    let mut bcx = FunctionBuilder::new(&mut context.func, &mut func_ctx);
+    let mut func = std::mem::replace(&mut cx.cached_context.func, Function::new());
+    func.name = ExternalName::user(0, func_id.as_u32());
+    func.signature = sig;
+    func.collect_debug_info();
+
+    let mut bcx = FunctionBuilder::new(&mut func, &mut func_ctx);
 
     // Predefine blocks
     let start_block = bcx.create_block();
@@ -34,9 +36,8 @@ pub(crate) fn trans_fn<'tcx, B: Backend + 'static>(
     let clif_comments = crate::pretty_clif::CommentWriter::new(tcx, instance);
 
     let mut fx = FunctionCx {
+        cx,
         tcx,
-        module: &mut cx.module,
-        global_asm: &mut cx.global_asm,
         pointer_type,
 
         instance,
@@ -49,8 +50,6 @@ pub(crate) fn trans_fn<'tcx, B: Backend + 'static>(
         cold_blocks: EntitySet::new(),
 
         clif_comments,
-        constants_cx: &mut cx.constants_cx,
-        vtables: &mut cx.vtables,
         source_info_set: indexmap::IndexSet::new(),
         next_ssa_var: 0,
 
@@ -77,8 +76,12 @@ pub(crate) fn trans_fn<'tcx, B: Backend + 'static>(
     let local_map = fx.local_map;
     let cold_blocks = fx.cold_blocks;
 
+    // Store function in context
+    let context = &mut cx.cached_context;
+    context.func = func;
+
     crate::pretty_clif::write_clif_file(
-        cx.tcx,
+        tcx,
         "unopt",
         None,
         instance,
@@ -113,7 +116,7 @@ pub(crate) fn trans_fn<'tcx, B: Backend + 'static>(
 
     // Write optimized function to file for debugging
     crate::pretty_clif::write_clif_file(
-        cx.tcx,
+        tcx,
         "opt",
         Some(cx.module.isa()),
         instance,

src/common.rs

@@ -265,10 +265,8 @@ pub(crate) fn type_sign(ty: Ty<'_>) -> bool {
 }
 
 pub(crate) struct FunctionCx<'clif, 'tcx, B: Backend + 'static> {
-    // FIXME use a reference to `CodegenCx` instead of `tcx`, `module` and `constants` and `caches`
+    pub(crate) cx: &'clif mut crate::CodegenCx<'tcx, B>,
     pub(crate) tcx: TyCtxt<'tcx>,
-    pub(crate) module: &'clif mut Module<B>,
-    pub(crate) global_asm: &'clif mut String,
     pub(crate) pointer_type: Type, // Cached from module
 
     pub(crate) instance: Instance<'tcx>,
@@ -285,9 +283,6 @@ pub(crate) struct FunctionCx<'clif, 'tcx, B: Backend + 'static> {
     pub(crate) cold_blocks: EntitySet<Block>,
 
     pub(crate) clif_comments: crate::pretty_clif::CommentWriter,
-    pub(crate) constants_cx: &'clif mut crate::constant::ConstantCx,
-    pub(crate) vtables: &'clif mut FxHashMap<(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>), DataId>,
-
     pub(crate) source_info_set: indexmap::IndexSet<SourceInfo>,
 
     /// This should only be accessed by `CPlace::new_var`.
@@ -398,7 +393,7 @@ pub(crate) fn get_caller_location(&mut self, span: Span) -> CValue<'tcx> {
     }
 
     pub(crate) fn triple(&self) -> &target_lexicon::Triple {
-        self.module.isa().triple()
+        self.cx.module.isa().triple()
     }
 
     pub(crate) fn anonymous_str(&mut self, prefix: &str, msg: &str) -> Value {
@@ -411,7 +406,7 @@ pub(crate) fn anonymous_str(&mut self, prefix: &str, msg: &str) -> Value {
         let mut data_ctx = DataContext::new();
         data_ctx.define(msg.as_bytes().to_vec().into_boxed_slice());
         let msg_id = self
-            .module
+            .cx.module
             .declare_data(
                 &format!("__{}_{:08x}", prefix, msg_hash),
                 Linkage::Local,
@@ -422,9 +417,9 @@ pub(crate) fn anonymous_str(&mut self, prefix: &str, msg: &str) -> Value {
             .unwrap();
 
         // Ignore DuplicateDefinition error, as the data will be the same
-        let _ = self.module.define_data(msg_id, &data_ctx);
+        let _ = self.cx.module.define_data(msg_id, &data_ctx);
 
-        let local_msg_id = self.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);

src/constant.rs

@@ -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.tcx, fx.module, def_id, false);
-    let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+    let data_id = data_id_for_static(fx.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.tcx, fx.module, def_id, false);
-    let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+    let data_id = data_id_for_static(fx.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);
@@ -167,22 +167,22 @@ pub(crate) fn trans_const_value<'tcx>(
                     let alloc_kind = fx.tcx.get_global_alloc(ptr.alloc_id);
                     let base_addr = match alloc_kind {
                         Some(GlobalAlloc::Memory(alloc)) => {
-                            fx.constants_cx.todo.push(TodoItem::Alloc(ptr.alloc_id));
-                            let data_id = data_id_for_alloc_id(fx.module, ptr.alloc_id, alloc.align, alloc.mutability);
-                            let local_data_id = fx.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.tcx, fx.module, instance);
-                            let local_func_id = fx.module.declare_func_in_func(func_id, &mut fx.bcx.func);
+                            let func_id = crate::abi::import_function(fx.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.tcx.is_static(def_id));
-                            let data_id = data_id_for_static(fx.tcx, fx.module, def_id, false);
-                            let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+                            let data_id = data_id_for_static(fx.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)
@@ -216,10 +216,10 @@ fn pointer_for_allocation<'tcx>(
     alloc: &'tcx Allocation,
 ) -> crate::pointer::Pointer {
     let alloc_id = fx.tcx.create_memory_alloc(alloc);
-    fx.constants_cx.todo.push(TodoItem::Alloc(alloc_id));
-    let data_id = data_id_for_alloc_id(fx.module, alloc_id, alloc.align, alloc.mutability);
+    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.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);

src/driver/mod.rs

@@ -85,7 +85,7 @@ fn trans_mono_item<'tcx, B: Backend + 'static>(
                 }
             });
 
-            cx.tcx.sess.time("codegen fn", || crate::base::trans_fn(cx, inst, linkage));
+            tcx.sess.time("codegen fn", || crate::base::trans_fn(cx, inst, linkage));
         }
         MonoItem::Static(def_id) => {
             crate::constant::codegen_static(&mut cx.constants_cx, def_id);

src/inline_asm.rs

@@ -73,7 +73,7 @@ pub(crate) fn codegen_inline_asm<'tcx>(
     let asm_name = format!("{}__inline_asm_{}", fx.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.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.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.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);
 

src/intrinsics/mod.rs

@@ -494,10 +494,10 @@ pub(crate) fn codegen_intrinsic_call<'tcx>(
 
             if intrinsic.contains("nonoverlapping") {
                 // FIXME emit_small_memcpy
-                fx.bcx.call_memcpy(fx.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.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.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.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,7 +680,7 @@ 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.module.target_config(), dst_ptr, val, count);
+            fx.bcx.call_memset(fx.cx.module.target_config(), dst_ptr, val, count);
         };
         ctlz | ctlz_nonzero, <T> (v arg) {
             // FIXME trap on `ctlz_nonzero` with zero arg.

src/trap.rs

@@ -2,7 +2,7 @@
 
 fn codegen_print(fx: &mut FunctionCx<'_, '_, impl cranelift_module::Backend>, msg: &str) {
     let puts = fx
-        .module
+        .cx.module
         .declare_function(
             "puts",
             Linkage::Import,
@@ -13,7 +13,7 @@ fn codegen_print(fx: &mut FunctionCx<'_, '_, impl cranelift_module::Backend>, ms
             },
         )
         .unwrap();
-    let puts = fx.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");

src/value_and_place.rs

@@ -595,7 +595,7 @@ fn transmute_value<'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.module.target_config(),
+                    fx.cx.module.target_config(),
                     to_addr,
                     from_addr,
                     size,

src/vtable.rs

@@ -72,15 +72,15 @@ pub(crate) fn get_vtable<'tcx>(
     layout: TyAndLayout<'tcx>,
     trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
 ) -> Value {
-    let data_id = if let Some(data_id) = fx.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.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.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)
 }
 
@@ -93,7 +93,7 @@ fn build_vtable<'tcx>(
     let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
 
     let drop_in_place_fn =
-        import_function(tcx, fx.module, Instance::resolve_drop_in_place(tcx, layout.ty).polymorphize(fx.tcx));
+        import_function(tcx, &mut fx.cx.module, Instance::resolve_drop_in_place(tcx, layout.ty).polymorphize(fx.tcx));
 
     let mut components: Vec<_> = vec![Some(drop_in_place_fn), None, None];
 
@@ -108,7 +108,7 @@ fn build_vtable<'tcx>(
         opt_mth.map_or(None, |(def_id, substs)| {
             Some(import_function(
                 tcx,
-                fx.module,
+                &mut fx.cx.module,
                 Instance::resolve_for_vtable(tcx, ParamEnv::reveal_all(), def_id, substs).unwrap().polymorphize(fx.tcx),
             ))
         })
@@ -127,13 +127,13 @@ fn build_vtable<'tcx>(
 
     for (i, component) in components.into_iter().enumerate() {
         if let Some(func_id) = component {
-            let func_ref = fx.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
-        .module
+        .cx.module
         .declare_data(
             &format!(
                 "__vtable.{}.for.{:?}.{}",
@@ -142,7 +142,7 @@ fn build_vtable<'tcx>(
                     .map(|trait_ref| format!("{:?}", trait_ref.skip_binder()).into())
                     .unwrap_or(std::borrow::Cow::Borrowed("???")),
                 layout.ty,
-                fx.vtables.len(),
+                fx.cx.vtables.len(),
             ),
             Linkage::Local,
             false,
@@ -159,7 +159,7 @@ fn build_vtable<'tcx>(
         )
         .unwrap();
 
-    fx.module.define_data(data_id, &data_ctx).unwrap();
+    fx.cx.module.define_data(data_id, &data_ctx).unwrap();
 
     data_id
 }