cleanpu

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs

@@ -368,11 +368,9 @@ pub(crate) fn gen_define_handling<'ll>(
 
     let offload_entry_ty = offload_globals.offload_entry_ty;
 
-    let mut arg_iter = types.iter().zip(metadata);
-
     // It seems like non-pointer values are automatically mapped. So here, we focus on pointer (or
     // reference) types.
-    let ptr_meta = arg_iter.filter_map(|(&x, meta)| match cx.type_kind(x) {
+    let ptr_meta = types.iter().zip(metadata).filter_map(|(&x, meta)| match cx.type_kind(x) {
         rustc_codegen_ssa::common::TypeKind::Pointer => Some(meta),
         _ => None,
     });
@@ -481,7 +479,6 @@ pub(crate) fn gen_call_handling<'ll, 'tcx>(
     host_llfn: &'ll Value,
     host_llty: &'ll Type,
 ) {
-    dbg!(&host_llfn);
     let cx = builder.cx;
     let OffloadKernelGlobals { offload_sizes, offload_entry, memtransfer_types, region_id } =
         offload_data;
@@ -504,7 +501,12 @@ pub(crate) fn gen_call_handling<'ll, 'tcx>(
 
     // FIXME(Sa4dUs): dummy loads are a temp workaround, we should find a proper way to prevent these
     // variables from being optimized away
-    for val in [offload_sizes] {
+    let to_keep: &[&llvm::Value] = if let Some(offload_entry) = offload_entry {
+        &[offload_sizes, offload_entry]
+    } else {
+        &[offload_sizes]
+    };
+    for val in to_keep {
         //for val in [offload_sizes, offload_entry] {
         unsafe {
             let dummy = llvm::LLVMBuildLoad2(
@@ -638,33 +640,13 @@ pub(crate) fn gen_call_handling<'ll, 'tcx>(
     let args = vec![
         s_ident_t,
         // FIXME(offload) give users a way to select which GPU to use.
-        //cx.get_const_i64(0), // MAX == -1.
         cx.get_const_i64(u64::MAX), // MAX == -1.
         num_workgroups,
         threads_per_block,
         region_id,
         a5,
     ];
     if host {
-        //let new_args = vec![];
-        //dbg!(&args);// were overwritten above, now hold omp stuff (shadowed)
-        dbg!(&vals);
-        dbg!(&types);
-        //dbg!(&fn_ty);
-        //let host_llty = cx.llvm_ty(host_llfn);
-        dbg!(&host_fnc_name);
-        dbg!(cx.get_defined_value(&host_fnc_name));
-        //let user_fn = unsafe {
-        //    llvm::LLVMRustGetOrInsertFunction(
-        //        builder.llmod,
-        //        host_fnc_name.as_c_char_ptr(),
-        //        host_fnc_name.len(),
-        //        fn_ty,
-        //    )
-        //};
-        //dbg!(&user_fn);
-        // void *omp_get_mapped_ptr(void *ptr, int device_num);
-
         let fn_name = "omp_get_mapped_ptr";
         let ty2: &'ll Type = cx.type_func(&[cx.type_ptr(), cx.type_i32()], cx.type_ptr());
         let mapper_fn = unsafe {
@@ -679,17 +661,14 @@ pub(crate) fn gen_call_handling<'ll, 'tcx>(
         let mut device_vals = Vec::with_capacity(vals.len());
         let device_num = cx.get_const_i32(0);
         for arg in vals {
-            dbg!(&mapper_fn);
-            dbg!(&ty2);
             let device_arg =
                 builder.call(ty2, None, None, mapper_fn, &[arg, device_num], None, None);
             device_vals.push(device_arg);
         }
         builder.call(host_llty, None, None, host_llfn, &device_vals, None, None);
-        //builder.call(fn_ty, None, None, host_llfn, &vals, None, None);
     } else {
-        builder.call(tgt_target_kernel_ty, None, None, tgt_decl, &args, None, None);
         // %41 = call i32 @__tgt_target_kernel(ptr @1, i64 -1, i32 2097152, i32 256, ptr @.kernel_1.region_id, ptr %kernel_args)
+        builder.call(tgt_target_kernel_ty, None, None, tgt_decl, &args, None, None);
     }
 
     // Step 4)