Implement trait objects (cc rust-lang#14)

Author: bjorn3

0006-Disable-all-trait-object-unsizing.patch

@@ -24,6 +24,7 @@ target-lexicon = "0.0.3"
 faerie = "0.5.0"
 ar = "0.6.0"
 bitflags = "1.0.3"
+byteorder = "1.2.6"
 
 # Uncomment to use local checkout of cranelift
 #[patch."https://github.com/CraneStation/cranelift.git"]

Cargo.lock

@@ -31,6 +31,18 @@ impl Termination for () {
     }
 }
 
+trait SomeTrait {
+    fn object_safe(&self);
+}
+
+impl SomeTrait for &'static str {
+    fn object_safe(&self) {
+        unsafe {
+            puts(*self as *const str as *const u8);
+        }
+    }
+}
+
 #[lang = "start"]
 fn start<T: Termination + 'static>(
     main: fn() -> T,
@@ -45,15 +57,28 @@ static NUM_REF: &'static u8 = unsafe { &NUM };
 
 fn main() {
     unsafe {
-        let slice: &[u8] = b"Hello\0" as &[u8; 6];
-        if intrinsics::size_of_val(slice) as u8 != 6 {
-            panic(&("eji", "frjio", 0, 0));
-        };
-        let ptr: *const u8 = slice as *const [u8] as *const u8;
-        let world = box "World!\0";
+        let hello: &[u8] = b"Hello\0" as &[u8; 6];
+        let ptr: *const u8 = hello as *const [u8] as *const u8;
         puts(ptr);
+
+        let world = box "World!\0";
         puts(*world as *const str as *const u8);
-    }
 
-    //panic(&("panic msg", "abc.rs", 0, 43));
+        if intrinsics::size_of_val(hello) as u8 != 6 {
+            panic(&("", "", 0, 0));
+        };
+
+        let chars = &['C', 'h', 'a', 'r', 's'];
+        let chars = chars as &[char];
+        if intrinsics::size_of_val(chars) as u8 != 4 * 5 {
+            panic(&("", "", 0, 0));
+        }
+
+        let a: &dyn SomeTrait = &"abc\0";
+        a.object_safe();
+
+        if intrinsics::size_of_val(a) as u8 != 16 {
+            panic(&("", "", 0, 0));
+        }
+    }
 }

Cargo.toml

@@ -50,6 +50,18 @@ fn get_pass_mode<'a, 'tcx: 'a>(
     }
 }
 
+fn adjust_arg_for_abi<'a, 'tcx: 'a>(
+    fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
+    sig: FnSig<'tcx>,
+    arg: CValue<'tcx>,
+) -> Value {
+    match get_pass_mode(fx.tcx, sig.abi, arg.layout().ty, false) {
+        PassMode::NoPass => unimplemented!("pass mode nopass"),
+        PassMode::ByVal(_) => arg.load_value(fx),
+        PassMode::ByRef => arg.force_stack(fx),
+    }
+}
+
 pub fn cton_sig_from_fn_ty<'a, 'tcx: 'a>(
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     fn_ty: Ty<'tcx>,
@@ -164,12 +176,16 @@ pub fn get_function_name_and_sig<'a, 'tcx>(
 
 impl<'a, 'tcx: 'a, B: Backend + 'a> FunctionCx<'a, 'tcx, B> {
     /// Instance must be monomorphized
-    pub fn get_function_ref(&mut self, inst: Instance<'tcx>) -> FuncRef {
+    pub fn get_function_id(&mut self, inst: Instance<'tcx>) -> FuncId {
         let (name, sig) = get_function_name_and_sig(self.tcx, inst);
-        let func_id = self
-            .module
+        self.module
             .declare_function(&name, Linkage::Import, &sig)
-            .unwrap();
+            .unwrap()
+    }
+
+    /// Instance must be monomorphized
+    pub fn get_function_ref(&mut self, inst: Instance<'tcx>) -> FuncRef {
+        let func_id = self.get_function_id(inst);
         self.module
             .declare_func_in_func(func_id, &mut self.bcx.func)
     }
@@ -468,29 +484,51 @@ pub fn codegen_call<'a, 'tcx: 'a>(
         PassMode::ByVal(_) => None,
     };
 
-    let call_args: Vec<Value> = return_ptr
-        .into_iter()
-        .chain(args.into_iter().map(|arg| {
-            match get_pass_mode(fx.tcx, sig.abi, arg.layout().ty, false) {
-                PassMode::NoPass => unimplemented!("pass mode nopass"),
-                PassMode::ByVal(_) => arg.load_value(fx),
-                PassMode::ByRef => arg.force_stack(fx),
-            }
-        })).collect::<Vec<_>>();
-
-    let call_inst = match fn_ty.sty {
+    let instance = match fn_ty.sty {
         ty::FnDef(def_id, substs) => {
-            let inst = Instance::resolve(fx.tcx, ParamEnv::reveal_all(), def_id, substs).unwrap();
-            let func_ref = fx.get_function_ref(inst);
-            fx.bcx.ins().call(func_ref, &call_args)
+            Some(Instance::resolve(fx.tcx, ParamEnv::reveal_all(), def_id, substs).unwrap())
         }
-        ty::FnPtr(_) => {
-            let func = trans_operand(fx, func);
-            let func = func.load_value(fx);
-            let sig = fx.bcx.import_signature(cton_sig_from_fn_ty(fx.tcx, fn_ty));
-            fx.bcx.ins().call_indirect(sig, func, &call_args)
-        }
-        _ => bug!("{:?}", fn_ty),
+        _ => None,
+    };
+
+    let func_ref: Option<Value>; // Indirect call target
+
+    let first_arg = {
+        if let Some(Instance {
+            def: InstanceDef::Virtual(_, idx),
+            ..
+        }) = instance
+        {
+            let (ptr, method) = crate::vtable::get_ptr_and_method_ref(fx, args[0], idx);
+            func_ref = Some(method);
+            Some(ptr)
+        } else {
+            func_ref = if instance.is_none() {
+                let func = trans_operand(fx, func);
+                Some(func.load_value(fx))
+            } else {
+                None
+            };
+
+            args.get(0).map(|arg| adjust_arg_for_abi(fx, sig, *arg))
+        }.into_iter()
+    };
+
+    let call_args: Vec<Value> = return_ptr
+        .into_iter()
+        .chain(first_arg)
+        .chain(
+            args.into_iter()
+                .skip(1)
+                .map(|arg| adjust_arg_for_abi(fx, sig, arg)),
+        ).collect::<Vec<_>>();
+
+    let sig = fx.bcx.import_signature(cton_sig_from_fn_ty(fx.tcx, fn_ty));
+    let call_inst = if let Some(func_ref) = func_ref {
+        fx.bcx.ins().call_indirect(sig, func_ref, &call_args)
+    } else {
+        let func_ref = fx.get_function_ref(instance.expect("non-indirect call on non-FnDef type"));
+        fx.bcx.ins().call(func_ref, &call_args)
     };
 
     match output_pass_mode {
@@ -610,6 +648,7 @@ fn codegen_intrinsic_call<'a, 'tcx: 'a>(
                             let elem_size = fx.layout_of(elem).size.bytes();
                             fx.bcx.ins().imul_imm(len, elem_size as i64)
                         }
+                        ty::Dynamic(..) => crate::vtable::size_of_obj(fx, args[0]),
                         ty => unimplemented!("size_of_val for {:?}", ty),
                     };
                     ret.write_cvalue(fx, CValue::ByVal(size, usize_layout));

examples/mini_core_hello_world.rs

@@ -12,7 +12,7 @@ impl<F: Fn() -> String> Drop for PrintOnPanic<F> {
 pub fn trans_mono_item<'a, 'tcx: 'a>(
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     module: &mut Module<impl Backend>,
-    caches: &mut Caches,
+    caches: &mut Caches<'tcx>,
     ccx: &mut crate::constant::ConstantCx,
     mono_item: MonoItem<'tcx>,
 ) {
@@ -59,7 +59,7 @@ fn trans_fn<'a, 'tcx: 'a>(
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     module: &mut Module<impl Backend>,
     constants: &mut crate::constant::ConstantCx,
-    caches: &mut Caches,
+    caches: &mut Caches<'tcx>,
     instance: Instance<'tcx>,
 ) {
     // Step 1. Get mir

src/abi.rs

@@ -236,9 +236,13 @@ impl<'tcx> CValue<'tcx> {
                         }
                         _ => bug!("unsize non array {:?} to slice", ty),
                     },
-                    ty::Dynamic(_, _) => match ty.sty {
+                    ty::Dynamic(data, _) => match ty.sty {
                         ty::Dynamic(_, _) => self.load_value_pair(fx),
-                        _ => unimpl!("unsize of type ... to {:?}", dest.layout().ty),
+                        _ => {
+                            let ptr = self.load_value(fx);
+                            let vtable = crate::vtable::get_vtable(fx, ty, data.principal());
+                            (ptr, vtable)
+                        }
                     },
                     _ => bug!(
                         "unsize of type {:?} to {:?}",
@@ -556,7 +560,7 @@ pub struct FunctionCx<'a, 'tcx: 'a, B: Backend + 'a> {
     pub local_map: HashMap<Local, CPlace<'tcx>>,
     pub comments: HashMap<Inst, String>,
     pub constants: &'a mut crate::constant::ConstantCx,
-    pub caches: &'a mut Caches,
+    pub caches: &'a mut Caches<'tcx>,
 
     /// add_global_comment inserts a comment here
     pub top_nop: Option<Inst>,