Don't force static refs to const memory

Author: bjorn3

src/constant.rs

@@ -11,6 +11,7 @@ use rustc_mir::interpret::{
     StackPopCleanup, StackPopInfo,
 };
 
+use cranelift_codegen::ir::GlobalValue;
 use cranelift_module::*;
 
 use crate::prelude::*;
@@ -47,7 +48,10 @@ fn codegen_static_ref<'tcx>(
 ) -> CPlace<'tcx> {
     let linkage = crate::linkage::get_static_ref_linkage(fx.tcx, def_id);
     let data_id = data_id_for_static(fx.tcx, fx.module, def_id, linkage);
-    cplace_for_dataid(fx, layout, data_id)
+    let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+    #[cfg(debug_assertions)]
+    fx.add_entity_comment(local_data_id, format!("{:?}", def_id));
+    cplace_for_dataid(fx, layout, local_data_id)
 }
 
 pub fn trans_constant<'tcx>(
@@ -119,53 +123,52 @@ pub fn trans_const_value<'tcx>(
             layout,
         );
     }
-
     let const_val = match const_.val {
         ConstKind::Value(const_val) => const_val,
         _ => unreachable!("Const {:?} should have been evaluated", const_),
     };
 
     match const_val {
         ConstValue::Scalar(x) => {
-            let scalar = match layout.abi {
-                layout::Abi::Scalar(ref x) => x,
-                _ => bug!("from_const: invalid ByVal layout: {:#?}", layout),
-            };
+            if fx.clif_type(layout.ty).is_none() {
+                return trans_const_place(fx, const_).to_cvalue(fx);
+            }
 
-            match ty.kind {
-                ty::Bool | ty::Uint(_) => {
-                    let bits = const_.val.try_to_bits(layout.size).unwrap_or_else(|| {
-                        panic!("{:?}\n{:?}", const_, layout);
-                    });
-                    CValue::const_val(fx, layout, bits)
+            match x {
+                Scalar::Raw { data, size } => {
+                    assert_eq!(u64::from(size), layout.size.bytes());
+                    return CValue::const_val(fx, layout, data);
                 }
-                ty::Int(_) => {
-                    let bits = const_.val.try_to_bits(layout.size).unwrap();
-                    CValue::const_val(
-                        fx,
-                        layout,
-                        rustc::mir::interpret::sign_extend(bits, layout.size),
-                    )
-                }
-                ty::Float(fty) => {
-                    let bits = const_.val.try_to_bits(layout.size).unwrap();
-                    let val = match fty {
-                        FloatTy::F32 => fx
-                            .bcx
-                            .ins()
-                            .f32const(Ieee32::with_bits(u32::try_from(bits).unwrap())),
-                        FloatTy::F64 => fx
-                            .bcx
-                            .ins()
-                            .f64const(Ieee64::with_bits(u64::try_from(bits).unwrap())),
+                Scalar::Ptr(ptr) => {
+                    let alloc_kind = fx.tcx.alloc_map.lock().get(ptr.alloc_id);
+                    let base_addr = match alloc_kind {
+                        Some(GlobalAlloc::Memory(alloc)) => {
+                            fx.constants_cx.todo.insert(TodoItem::Alloc(ptr.alloc_id));
+                            let data_id = data_id_for_alloc_id(fx.module, ptr.alloc_id, alloc.align);
+                            let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+                            #[cfg(debug_assertions)]
+                            fx.add_entity_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);
+                            fx.bcx.ins().func_addr(fx.pointer_type, local_func_id)
+                        }
+                        Some(GlobalAlloc::Static(def_id)) => {
+                            assert!(fx.tcx.is_static(def_id));
+                            let linkage = crate::linkage::get_static_ref_linkage(fx.tcx, def_id);
+                            let data_id = data_id_for_static(fx.tcx, fx.module, def_id, linkage);
+                            let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+                            #[cfg(debug_assertions)]
+                            fx.add_entity_comment(local_data_id, format!("{:?}", def_id));
+                            fx.bcx.ins().global_value(fx.pointer_type, local_data_id)
+                        }
+                        None => bug!("missing allocation {:?}", ptr.alloc_id),
                     };
-                    CValue::by_val(val, layout)
+                    let val = fx.bcx.ins().iadd_imm(base_addr, i64::try_from(ptr.offset.bytes()).unwrap());
+                    return CValue::by_val(val, layout);
                 }
-                ty::FnDef(_def_id, _substs) => CValue::by_ref(
-                    crate::pointer::Pointer::const_addr(fx, fx.pointer_type.bytes() as i64),
-                    layout,
-                ),
-                _ => trans_const_place(fx, const_).to_cvalue(fx),
             }
         }
         ConstValue::ByRef { alloc, offset } => {
@@ -228,7 +231,10 @@ fn trans_const_place<'tcx>(
     let alloc_id = fx.tcx.alloc_map.lock().create_memory_alloc(alloc);
     fx.constants_cx.todo.insert(TodoItem::Alloc(alloc_id));
     let data_id = data_id_for_alloc_id(fx.module, alloc_id, alloc.align);
-    cplace_for_dataid(fx, fx.layout_of(const_.ty), data_id)
+    let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+    #[cfg(debug_assertions)]
+    fx.add_entity_comment(local_data_id, format!("{:?}", alloc_id));
+    cplace_for_dataid(fx, fx.layout_of(const_.ty), local_data_id)
 }
 
 fn data_id_for_alloc_id<B: Backend>(
@@ -305,9 +311,8 @@ fn data_id_for_static(
 fn cplace_for_dataid<'tcx>(
     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
     layout: TyLayout<'tcx>,
-    data_id: DataId,
+    local_data_id: GlobalValue,
 ) -> CPlace<'tcx> {
-    let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
     let global_ptr = fx.bcx.ins().global_value(fx.pointer_type, local_data_id);
     assert!(!layout.is_unsized(), "unsized statics aren't supported");
     CPlace::for_ptr(crate::pointer::Pointer::new(global_ptr), layout)