make src test compile, not generating llvm yet

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs

@@ -6,6 +6,7 @@ use rustc_abi::Align;
 use rustc_codegen_ssa::MemFlags;
 use rustc_codegen_ssa::common::TypeKind;
 use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
+use rustc_codegen_ssa::mir::place::PlaceValue;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods};
 use rustc_middle::bug;
 use rustc_middle::ty::offload_meta::{MappingFlags, OffloadMetadata, OffloadSize};
@@ -151,6 +152,7 @@ impl<'ll> OffloadKernelDims<'ll> {
         let OperandValue::Ref(place) = workgroup_op.val else {
             bug!("expected array operand by reference");
         };
+        let place: PlaceValue<&Value> = place;
         let workgroup_val = builder.load(arr_ty, place.llval, four);
 
         let OperandValue::Ref(place) = thread_op.val else {

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -243,6 +243,18 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 // offload *has* a return type, but somehow works without mentioning the place
                 return IntrinsicResult::WroteIntoPlace;
             }
+            sym::preload => {
+                if tcx.sess.opts.unstable_opts.offload.is_empty() {
+                    let _ = tcx.dcx().emit_almost_fatal(OffloadWithoutEnable);
+                }
+
+                if tcx.sess.lto() != rustc_session::config::Lto::Fat {
+                    let _ = tcx.dcx().emit_almost_fatal(OffloadWithoutFatLTO);
+                }
+
+                codegen_offload_preload(self, tcx, instance, args);
+                return IntrinsicResult::WroteIntoPlace;
+            }
             sym::is_val_statically_known => {
                 if let OperandValue::Immediate(imm) = args[0].val {
                     self.call_intrinsic(
@@ -1905,6 +1917,60 @@ fn codegen_autodiff<'ll, 'tcx>(
     );
 }
 
+// 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.
+//
+// Current steps:
+// 0. Alloca some variables for the following steps
+// 1. set insert point before PreLoad call.
+// 2. generate all the GEPS and stores, to be used in 3)
+// 3. generate __tgt_target_data_begin calls to move data to the GPU
+//
+// unchanged: keep kernel call. Later move the kernel to the GPU
+//
+// 4. set insert point after kernel call.
+// 5. generate all the GEPS and stores, to be used in 6)
+// 6. generate __tgt_target_data_end calls to move data from the GPU
+fn codegen_offload_preload<'ll, 'tcx>(
+    bx: &mut Builder<'_, 'll, 'tcx>,
+    tcx: TyCtxt<'tcx>,
+    instance: ty::Instance<'tcx>,
+    args: &[OperandRef<'tcx, &'ll Value>],
+) {
+    let cx = bx.cx;
+    //let fn_args = instance.args;
+
+    register_offload(cx);
+
+    //let OperandValue::Ref(place) = args[0].val else {
+    //    bug!("expected array operand by reference");
+    //};
+    //let arg_ty = place.layout.llvm_type(bx.cx);
+    ////let workgroup_val = bx.load(arr_ty, place.llval, four);
+
+    //let a = OffloadMetadata::from_ty(tcx, arg_ty);
+
+    let arg = &args[0];
+
+    let arg_ty = arg.layout.ty;
+
+    let ty::Ref(_, pointee_ty, _) = *arg_ty.kind() else {
+        bug!("expected preload argument to be a reference, got {arg_ty:?}");
+    };
+
+    let meta = OffloadMetadata::from_ty(tcx, pointee_ty);
+
+    let offload_globals_ref = cx.offload_globals.borrow();
+    let offload_globals = match offload_globals_ref.as_ref() {
+        Some(globals) => globals,
+        None => {
+            // Offload is not initialized, cannot continue
+            return;
+        }
+    };
+}
+
 // Generates the LLVM code to offload a Rust function to a target device (e.g., GPU).
 // For each kernel call, it generates the necessary globals (including metadata such as
 // size and pass mode), manages memory mapping to and from the device, handles all

compiler/rustc_hir/src/lang_items.rs

@@ -325,6 +325,12 @@ language_item_table! {
     DropGlue,                sym::drop_glue,           drop_glue_fn,               Target::Fn,             GenericRequirement::Exact(1);
     AllocLayout,             sym::alloc_layout,        alloc_layout,               Target::Struct,         GenericRequirement::None;
 
+    // Compiler-generated mapper functions for gpu offloading
+    PreloadStruct,        sym::preload_type,        preload_type,        Target::Struct, GenericRequirement::None;
+    PreloadMutStruct,     sym::preload_mut_type,    preload_mut_type,    Target::Struct, GenericRequirement::None;
+    PreloadFn,            sym::preload,             preload_fn,          Target::Fn,     GenericRequirement::None;
+    PreloadMutFn,         sym::preload_mut,         preload_mut_fn,      Target::Fn,     GenericRequirement::None;
+
     /// For all binary crates without `#![no_main]`, Rust will generate a "main" function.
     /// The exact name and signature are target-dependent. The "main" function will invoke
     /// this lang item, passing it the `argc` and `argv` (or null, if those don't exist

compiler/rustc_span/src/symbol.rs

@@ -1560,6 +1560,10 @@ symbols! {
         prefetch_write_instruction,
         prefix_nops,
         preg,
+        preload,
+        preload_mut,
+        preload_type,
+        preload_mut_type,
         prelude,
         prelude_import,
         preserves_flags,

library/core/src/lib.rs

@@ -233,6 +233,8 @@ pub mod autodiff {
     #[unstable(feature = "autodiff", issue = "124509")]
     pub use crate::macros::builtin::{autodiff_forward, autodiff_reverse};
 }
+#[unstable(feature = "offload", issue = "124509")]
+pub mod offload;
 
 #[unstable(feature = "contracts", issue = "128044")]
 pub mod contracts;

library/core/src/offload.rs

@@ -0,0 +1,27 @@
+use crate::marker::PhantomData;
+
+#[lang = "preload_type"]
+#[unstable(feature = "offload", issue = "124509")]
+pub struct Preload<'a, T: ?Sized> {
+    cpu_ptr: *const T,
+    _marker: PhantomData<&'a T>,
+}
+
+#[lang = "preload_mut_type"]
+#[unstable(feature = "offload", issue = "124509")]
+pub struct PreloadMut<'a, T: ?Sized> {
+    cpu_ptr: *mut T,
+    _marker: PhantomData<&'a mut T>,
+}
+
+#[lang = "preload"]
+#[unstable(feature = "offload", issue = "124509")]
+pub fn preload<'a, T: ?Sized>(x: &'a T) -> Preload<'a, T> {
+    Preload { cpu_ptr: x as *const T, _marker: PhantomData }
+}
+
+#[lang = "preload_mut"]
+#[unstable(feature = "offload", issue = "124509")]
+pub fn preload_mut<'a, T: ?Sized>(x: &'a mut T) -> PreloadMut<'a, T> {
+    PreloadMut { cpu_ptr: x as *mut T, _marker: PhantomData }
+}