asdf

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -173,7 +173,36 @@ fn call_simple_intrinsic<'ll, 'tcx>(
     ))
 }
 
+fn emit_offload_preload<'ll, 'tcx>(
+    bx: &mut Builder<'_, 'll, 'tcx>,
+    tcx: TyCtxt<'tcx>,
+    instance: ty::Instance<'tcx>,
+    args: &[OperandRef<'tcx, &'ll llvm::Value>],
+    is_mut: bool,
+) {
+    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);
+    }
+
+    dbg!("HI!");
+    codegen_offload_preload(bx, tcx, instance, args);
+}
+
 impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
+    fn codegen_offload_preload_call(
+        &mut self,
+        instance: ty::Instance<'tcx>,
+        args: &[OperandRef<'tcx, &'ll llvm::Value>],
+        is_mut: bool,
+    ) {
+        let tcx = self.tcx;
+        emit_offload_preload(self, tcx, instance, args, is_mut);
+    }
+
     fn codegen_intrinsic_call(
         &mut self,
         instance: ty::Instance<'tcx>,
@@ -246,18 +275,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);
-                }
+            //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);
-                }
+            //    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;
-            }
+            //    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(
@@ -1960,6 +1989,7 @@ fn codegen_offload_preload<'ll, 'tcx>(
     let metadata = &[meta];
     let types = bx.cx.layout_of(pointee_ty).llvm_type(bx.cx);
 
+    dbg!("asdf");
     let offload_globals_ref = cx.offload_globals.borrow();
     let offload_globals = match offload_globals_ref.as_ref() {
         Some(globals) => globals,
@@ -1968,6 +1998,7 @@ fn codegen_offload_preload<'ll, 'tcx>(
             return;
         }
     };
+    dbg!("asdf");
     let target_symbol = "asdf_I_ll_nameclash".to_owned();
     let offload_data = gen_define_handling(&cx, metadata, target_symbol, offload_globals);
     let has_dynamic = metadata.iter().any(|m| !matches!(m.payload_size, OffloadSize::Static(_)));

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -919,6 +919,26 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     fn_span,
                 );
 
+                if Some(instance.def_id()) == bx.tcx().lang_items().preload_fn() {
+                    let cg_args: Vec<_> =
+                        args.iter().map(|arg| self.codegen_operand(bx, &arg.node)).collect();
+
+                    bx.codegen_offload_preload_call(
+                        instance, &cg_args, //source_info,
+                        false, // immutable preload
+                    );
+                }
+
+                if Some(instance.def_id()) == bx.tcx().lang_items().preload_mut_fn() {
+                    let cg_args: Vec<_> =
+                        args.iter().map(|arg| self.codegen_operand(bx, &arg.node)).collect();
+
+                    bx.codegen_offload_preload_call(
+                        instance, &cg_args, //source_info,
+                        true, // mutable preload
+                    );
+                }
+
                 match instance.def {
                     // We don't need AsyncDropGlueCtorShim here because it is not `noop func`,
                     // it is `func returning noop future`

compiler/rustc_codegen_ssa/src/traits/intrinsic.rs

@@ -31,6 +31,14 @@ pub trait IntrinsicCallBuilderMethods<'tcx>: BackendTypes {
         span: Span,
     ) -> IntrinsicResult<'tcx, Self::Value>;
 
+    fn codegen_offload_preload_call(
+        &mut self,
+        instance: ty::Instance<'tcx>,
+        args: &[OperandRef<'tcx, Self::Value>],
+        //source_info: mir::SourceInfo,
+        is_mut: bool,
+    );
+
     fn codegen_llvm_intrinsic_call(
         &mut self,
         instance: ty::Instance<'tcx>,