cleanup and temporary dbg/print statements

Author: ZuseZ4

Diff for: compiler/rustc_codegen_llvm/src/builder/autodiff.rs

@@ -62,7 +62,7 @@ fn generate_enzyme_call<'ll>(
     // add outer_fn name to ad_name to make it unique, in case users apply autodiff to multiple
     // functions. Unwrap will only panic, if LLVM gave us an invalid string.
     let name = llvm::get_value_name(outer_fn);
-    let outer_fn_name = std::ffi::CStr::from_bytes_with_nul(name).unwrap().to_str().unwrap();
+    let outer_fn_name = std::str::from_utf8(name).unwrap();
     ad_name.push_str(outer_fn_name.to_string().as_str());
 
     // Let us assume the user wrote the following function square:
@@ -255,21 +255,29 @@ fn generate_enzyme_call<'ll>(
             // have no debug info to copy, which would then be ok.
             trace!("no dbg info");
         }
+        // Dump module:
+        llvm::LLVMDumpModule(cx.llmod);
+        // now print the last instruction:
+        llvm::LLVMDumpValue(last_inst);
+
         // Now that we copied the metadata, get rid of dummy code.
         llvm::LLVMRustEraseInstBefore(entry, last_inst);
-        llvm::LLVMRustEraseInstFromParent(last_inst);
+        dbg!("cleaneup done");
+        llvm::LLVMDumpValue(outer_fn);
 
         if cx.val_ty(outer_fn) != cx.type_void() {
             builder.ret(call);
         } else {
             builder.ret_void();
         }
+        dbg!("build ret done");
 
         // Let's crash in case that we messed something up above and generated invalid IR.
         llvm::LLVMRustVerifyFunction(
             outer_fn,
             llvm::LLVMRustVerifierFailureAction::LLVMAbortProcessAction,
         );
+        dbg!("verification done");
     }
 }
 
@@ -308,33 +316,34 @@ pub(crate) fn differentiate<'ll>(
         };
 
         generate_enzyme_call(&cx, fn_def, fn_target, item.attrs.clone());
+        dbg!("generated enzyme call");
     }
 
     // FIXME(ZuseZ4): support SanitizeHWAddress and prevent illegal/unsupported opts
 
-    if let Some(opt_level) = config.opt_level {
-        let opt_stage = match cgcx.lto {
-            Lto::Fat => llvm::OptStage::PreLinkFatLTO,
-            Lto::Thin | Lto::ThinLocal => llvm::OptStage::PreLinkThinLTO,
-            _ if cgcx.opts.cg.linker_plugin_lto.enabled() => llvm::OptStage::PreLinkThinLTO,
-            _ => llvm::OptStage::PreLinkNoLTO,
-        };
-        // This is our second opt call, so now we run all opts,
-        // to make sure we get the best performance.
-        let skip_size_increasing_opts = false;
-        trace!("running Module Optimization after differentiation");
-        unsafe {
-            llvm_optimize(
-                cgcx,
-                diag_handler.handle(),
-                module,
-                config,
-                opt_level,
-                opt_stage,
-                skip_size_increasing_opts,
-            )?
-        };
-    }
+    //if let Some(opt_level) = config.opt_level {
+    //    let opt_stage = match cgcx.lto {
+    //        Lto::Fat => llvm::OptStage::PreLinkFatLTO,
+    //        Lto::Thin | Lto::ThinLocal => llvm::OptStage::PreLinkThinLTO,
+    //        _ if cgcx.opts.cg.linker_plugin_lto.enabled() => llvm::OptStage::PreLinkThinLTO,
+    //        _ => llvm::OptStage::PreLinkNoLTO,
+    //    };
+    //    // This is our second opt call, so now we run all opts,
+    //    // to make sure we get the best performance.
+    //    let skip_size_increasing_opts = false;
+    //    trace!("running Module Optimization after differentiation");
+    //    unsafe {
+    //        llvm_optimize(
+    //            cgcx,
+    //            diag_handler.handle(),
+    //            module,
+    //            config,
+    //            opt_level,
+    //            opt_stage,
+    //            skip_size_increasing_opts,
+    //        )?
+    //    };
+    //}
     trace!("done with differentiate()");
 
     Ok(())

Diff for: compiler/rustc_codegen_ssa/src/back/write.rs

@@ -401,12 +401,12 @@ fn generate_lto_work<B: ExtraBackendMethods>(
 
     if !needs_fat_lto.is_empty() {
         assert!(needs_thin_lto.is_empty());
-        let module =
+        let mut module =
             B::run_fat_lto(cgcx, needs_fat_lto, import_only_modules).unwrap_or_else(|e| e.raise());
         if cgcx.lto == Lto::Fat {
-            let _config = cgcx.config(ModuleKind::Regular);
-            todo!("fat LTO with autodiff is not yet implemented");
-            //module = unsafe { module.autodiff(cgcx, autodiff, config).unwrap() };
+            let config = cgcx.config(ModuleKind::Regular);
+            //todo!("fat LTO with autodiff is not yet implemented");
+            module = unsafe { module.autodiff(cgcx, autodiff, config).unwrap() };
         }
         // We are adding a single work item, so the cost doesn't matter.
         vec![(WorkItem::LTO(module), 0)]