Introduce vtable_for intrinsic. Passes hir analysis, far from functional

Author: ivarflakstad

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -67,6 +67,22 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 let val = self.const_val_to_op(val, dest.layout.ty, Some(dest.layout))?;
                 self.copy_op(&val, dest)?;
             }
+            sym::vtable_for => {
+                let tp_ty = instance.args.type_at(0);
+                let result_ty = instance.args.type_at(1);
+                //let dyn_metadata = tcx.require_lang_item(LangItem::DynMetadata, span);
+
+                ensure_monomorphic_enough(tcx, tp_ty)?;
+                ensure_monomorphic_enough(tcx, result_ty)?;
+
+                // Get vtable
+                //let vtable_ptr = self.get_vtable_ptr(tp_ty, result_ty.into())?;
+
+                //let dyn_metadata = metadata(vtable_ptr);
+                //let val = ConstValue::from_u128(tcx.type_id_hash(tp_ty).as_u128());
+                //let val = self.const_val_to_op(val, dest.layout.ty, Some(dest.layout))?;
+                //self.copy_op(&val, dest)?;
+            }
             sym::variant_count => {
                 let tp_ty = instance.args.type_at(0);
                 let ty = match tp_ty.kind() {

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -93,6 +93,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::three_way_compare
         | sym::discriminant_value
         | sym::type_id
+        | sym::vtable_for
         | sym::select_unpredictable
         | sym::cold_path
         | sym::ptr_guaranteed_cmp
@@ -543,6 +544,20 @@ pub(crate) fn check_intrinsic_type(
             (0, 0, vec![Ty::new_imm_ptr(tcx, tcx.types.unit)], tcx.types.usize)
         }
 
+        sym::vtable_for => {
+            let dyn_metadata = tcx.require_lang_item(LangItem::DynMetadata, span);
+            let dyn_metadata_adt_ref = tcx.adt_def(dyn_metadata);
+            let dyn_metadata_args = tcx.mk_args(&[param(1).into()]);
+            let dyn_ty = Ty::new_adt(tcx, dyn_metadata_adt_ref, dyn_metadata_args);
+
+            let option_did = tcx.require_lang_item(LangItem::Option, span);
+            let option_adt_ref = tcx.adt_def(option_did);
+            let option_args = tcx.mk_args(&[dyn_ty.into()]);
+            let ret_ty = Ty::new_adt(tcx, option_adt_ref, option_args);
+
+            (2, 0, vec![], ret_ty)
+        }
+
         // This type check is not particularly useful, but the `where` bounds
         // on the definition in `core` do the heavy lifting for checking it.
         sym::aggregate_raw_ptr => (3, 0, vec![param(1), param(2)], param(0)),

compiler/rustc_span/src/symbol.rs

@@ -2345,6 +2345,7 @@ symbols! {
         vreg_low16,
         vsx,
         vtable_align,
+        vtable_for,
         vtable_size,
         warn,
         wasip2,

library/core/src/intrinsics/mod.rs

@@ -2626,6 +2626,17 @@ pub unsafe fn vtable_size(ptr: *const ()) -> usize;
 #[rustc_intrinsic]
 pub unsafe fn vtable_align(ptr: *const ()) -> usize;
 
+/// FIXME: write actual docs (ivarflakstad)
+/// The intrinsic will return the vtable of `t` through the lens of `U`.
+///
+/// # Safety
+///
+/// `ptr` must point to a vtable.
+#[rustc_nounwind]
+#[unstable(feature = "core_intrinsics", issue = "none")]
+#[rustc_intrinsic]
+pub const fn vtable_for<T: 'static, U: ?Sized + 'static>() -> Option<ptr::DynMetadata<U>>;
+
 /// The size of a type in bytes.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;

library/coretests/tests/intrinsics.rs

@@ -193,3 +193,20 @@ fn carrying_mul_add_fallback_i128() {
         (u128::MAX - 1, -(i128::MIN / 2)),
     );
 }
+
+#[test]
+fn test_vtable_for() {
+    use std::fmt::Debug;
+    use std::intrinsics::vtable_for;
+    use std::option::Option;
+    use std::ptr::DynMetadata;
+
+    #[allow(dead_code)]
+    #[derive(Debug)]
+    struct A {
+        index: usize,
+    }
+    const debug_vtable: Option<DynMetadata<dyn Debug>> = vtable_for::<A, dyn Debug>();
+
+    println!("{debug_vtable:?}");
+}