more handling drop for PreloadMut

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -188,6 +188,17 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
         codegen_offload_preload(self, tcx, instance, args);
     }
 
+    fn codegen_offload_preload_mut_drop(
+        &mut self,
+        preload_ty: Ty<'tcx>,
+        place: PlaceRef<'tcx, &'ll llvm::Value>,
+    ) {
+        let tcx = self.tcx;
+        dbg!("Dropping PreloadMut; emit offload end mapper");
+
+        codegen_offload_preload_mut_drop(self, tcx, preload_ty, place);
+    }
+
     fn codegen_intrinsic_call(
         &mut self,
         instance: ty::Instance<'tcx>,
@@ -1911,6 +1922,55 @@ fn codegen_autodiff<'ll, 'tcx>(
     );
 }
 
+fn codegen_offload_preload_mut_drop<'ll, 'tcx>(
+    bx: &mut Builder<'_, 'll, 'tcx>,
+    tcx: TyCtxt<'tcx>,
+    preload_ty: Ty<'tcx>,
+    place: PlaceRef<'tcx, &'ll llvm::Value>,
+) {
+    let cx = bx.cx;
+    dbg!("Starting the PreloadMut drop handling!");
+    // PreloadMut<'a, T> -> extract T.
+    let ty::Adt(_adt_def, generic_args) = preload_ty.kind() else {
+        bug!("expected PreloadMut ADT, got {preload_ty:?}");
+    };
+
+    // This should be the `T` parameter of PreloadMut<'a, T>.
+    // If this indexes the lifetime in your tree, use the correct type arg index
+    // or `generic_args.types().next().unwrap()`.
+    let pointee_ty: Ty<'tcx> =
+        generic_args.types().next().unwrap_or_else(|| bug!("PreloadMut without type parameter"));
+
+    // Load field 0: `cpu_ptr: *mut T`.
+    let cpu_ptr_place = place.project_field(bx, 0);
+    let cpu_ptr_operand = bx.load_operand(cpu_ptr_place);
+
+    let args: Vec<&'ll Value> = match cpu_ptr_operand.val {
+        OperandValue::Immediate(ptr) => vec![ptr],
+        OperandValue::Pair(_data, _meta) => {
+            bug!("unsized PreloadMut drop not handled yet")
+        }
+        _ => bug!("unexpected PreloadMut cpu_ptr operand"),
+    };
+
+    let meta = OffloadMetadata::from_ty(tcx, pointee_ty);
+    let metadata: &[OffloadMetadata; 1] = &[meta];
+
+    let types: &Type = cx.layout_of(pointee_ty).llvm_type(cx);
+
+    let offload_globals_ref = cx.offload_globals.borrow();
+    let offload_globals = match offload_globals_ref.as_ref() {
+        Some(globals) => globals,
+        None => {
+            dbg!("Have to initialize offload? This is a bug!");
+            return;
+        }
+    };
+
+    let target_symbol = cx.generate_local_symbol_name("");
+    dbg!("done for now");
+}
+
 // For each PreLoad *call*, we now use some of our previous declared globals to move data to the gpu.
 // For now, we only handle the data transfer part of it. Consecutive calls become a no-op on the
 // LLVM side.

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -9,7 +9,7 @@ use rustc_lint_defs::builtin::TAIL_CALL_TRACK_CALLER;
 use rustc_middle::mir::{self, AssertKind, InlineAsmMacro, SwitchTargets, UnwindTerminateReason};
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, ValidityRequirement};
 use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
-use rustc_middle::ty::{self, Instance, Ty, TypeVisitableExt};
+use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::OptLevel;
 use rustc_span::{Span, Spanned};
@@ -27,6 +27,14 @@ use crate::mir::IntrinsicResult;
 use crate::traits::*;
 use crate::{MemFlags, meth};
 
+fn is_preload_mut_type<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
+    let ty::Adt(adt_def, _) = ty.kind() else {
+        return false;
+    };
+
+    Some(adt_def.did()) == tcx.lang_items().preload_mut_type()
+}
+
 // Indicates if we are in the middle of merging a BB's successor into it. This
 // can happen when BB jumps directly to its successor and the successor has no
 // other predecessors.
@@ -591,14 +599,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         bx.ret(llval);
     }
 
-    fn is_preload_mut_type<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
-        let ty::Adt(adt_def, _) = ty.kind() else {
-            return false;
-        };
-
-        Some(adt_def.did()) == tcx.lang_items().preload_mut_type()
-    }
-
     #[tracing::instrument(level = "trace", skip(self, helper, bx))]
     fn codegen_drop_terminator(
         &mut self,

compiler/rustc_codegen_ssa/src/traits/intrinsic.rs

@@ -5,7 +5,7 @@ use super::BackendTypes;
 use crate::RetagInfo;
 use crate::mir::IntrinsicResult;
 use crate::mir::operand::OperandRef;
-use crate::mir::place::PlaceValue;
+use crate::mir::place::{PlaceRef, PlaceValue};
 
 pub trait IntrinsicCallBuilderMethods<'tcx>: BackendTypes {
     /// Higher-level interface to emitting calls to intrinsics
@@ -40,7 +40,7 @@ pub trait IntrinsicCallBuilderMethods<'tcx>: BackendTypes {
 
     fn codegen_offload_preload_mut_drop(
         &mut self,
-        preload_ty: Ty<'tcx>,
+        preload_ty: ty::Ty<'tcx>,
         place: PlaceRef<'tcx, Self::Value>,
     );