cleanups

Author: ZuseZ4

compiler/rustc_ast/src/mut_visit.rs

@@ -381,7 +381,7 @@ pub fn visit_bounds<T: MutVisitor>(bounds: &mut GenericBounds, vis: &mut T) {
 }
 
 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-pub fn visit_fn_sig<T: MutVisitor>(FnSig { header, decl, span, .. }: &mut FnSig, vis: &mut T) {
+pub fn visit_fn_sig<T: MutVisitor>(FnSig { header, decl, span }: &mut FnSig, vis: &mut T) {
     vis.visit_fn_header(header);
     vis.visit_fn_decl(decl);
     vis.visit_span(span);

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -273,7 +273,6 @@ fn fat_lto(
         info!("pushing cached module {:?}", wp.cgu_name);
         (buffer, CString::new(wp.cgu_name).unwrap())
     }));
-
     for module in modules {
         match module {
             FatLtoInput::InMemory(m) => in_memory.push(m),

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -628,15 +628,13 @@ fn get_params(fnc: &Value) -> Vec<&Value> {
     }
 }
 
-// TODO: cleanup
+// TODO: Here we could start adding length checks for the shaddow args.
 unsafe fn create_wrapper<'a>(
     llmod: &'a llvm::Module,
-    //module: &'a ModuleCodegen<ModuleLlvm>,
     fnc: &'a Value,
     u_type: &Type,
     fnc_name: String,
 ) -> (&'a Value, &'a BasicBlock, Vec<&'a Value>, Vec<&'a Value>, CString) {
-    //let llmod = module.module_llvm.llmod();
     let context = LLVMGetModuleContext(llmod);
     let inner_fnc_name = "inner_".to_string() + &fnc_name;
     let c_inner_fnc_name = CString::new(inner_fnc_name.clone()).unwrap();
@@ -656,22 +654,13 @@ unsafe fn create_wrapper<'a>(
     (outer_fnc, basic_block, outer_params, inner_params, c_inner_fnc_name)
 }
 
-//pub(crate) fn get_type(t: LLVMTypeRef) -> CString {
-//    unsafe { CString::from_raw(LLVMPrintTypeToString(t)) }
-//}
-
-// TODO: Don't write a wrapper function, just unwrap the struct inside of the same fnc.
-// Might help during debugging, if you have one function less to jump trough
 pub(crate) unsafe fn extract_return_type<'a>(
     llmod: &'a llvm::Module,
     fnc: &'a Value,
     u_type: &Type,
     fnc_name: String,
 ) -> &'a Value {
-    //let llmod = module.module_llvm.llmod();
     let context = llvm::LLVMGetModuleContext(llmod);
-    //dbg!("Unpacking", fnc_name.clone());
-    //dbg!("From: ", f_type, " into ", u_type);
 
     let inner_param_num = LLVMCountParams(fnc);
     let (outer_fnc, outer_bb, mut outer_args, _inner_args, c_inner_fnc_name) =
@@ -697,17 +686,9 @@ pub(crate) unsafe fn extract_return_type<'a>(
     let struct_ret = LLVMBuildExtractValue(builder, struct_ret, 0, c_inner_grad_name.as_ptr());
     let _ret = LLVMBuildRet(builder, struct_ret);
     let _terminator = LLVMGetBasicBlockTerminator(outer_bb);
-    //assert!(LLVMIsNull(terminator)!=0, "no terminator");
     LLVMDisposeBuilder(builder);
-
     let _fnc_ok =
         LLVMVerifyFunction(outer_fnc, llvm::LLVMVerifierFailureAction::LLVMAbortProcessAction);
-    //dbg!(outer_fnc);
-    //assert!(fnc_ok);
-    //if let Err(e) = verify_function(outer_fnc) {
-    //    panic!("Creating a wrapper function failed! {}", e);
-    //}
-
     outer_fnc
 }
 
@@ -792,16 +773,12 @@ pub(crate) unsafe fn enzyme_ad(
 
     let void_type = LLVMVoidTypeInContext(llcx);
     if item.attrs.mode == DiffMode::Reverse && f_return_type != void_type {
-        //dbg!("Reverse Mode sanitizer");
-        //dbg!(f_type);
-        //dbg!(f_return_type);
         let num_elem_in_ret_struct = LLVMCountStructElementTypes(f_return_type);
         if num_elem_in_ret_struct == 1 {
             let u_type = LLVMTypeOf(target_fnc);
             res = extract_return_type(llmod, res, u_type, rust_name2.clone()); // TODO: check if name or name2
         }
     }
-    //dbg!(&target_fnc);
     LLVMSetValueName2(res, name2.as_ptr(), rust_name2.len());
     LLVMReplaceAllUsesWith(target_fnc, res);
     LLVMDeleteFunction(target_fnc);

compiler/rustc_codegen_ssa/src/back/lto.rs

@@ -88,7 +88,6 @@ impl<B: WriteBackendMethods> LtoModuleCodegen<B> {
     ) -> Result<LtoModuleCodegen<B>, FatalError> {
         match &self {
             LtoModuleCodegen::Fat { ref module, .. } => {
-                //let module = module.take().unwrap();
                 {
                     B::autodiff(cgcx, &module, diff_fncs, typetrees, config)?;
                 }

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -118,7 +118,6 @@ pub struct ModuleConfig {
     pub inline_threshold: Option<u32>,
     pub emit_lifetime_markers: bool,
     pub llvm_plugins: Vec<String>,
-    pub enzyme_print_activity: bool,
 }
 
 impl ModuleConfig {
@@ -196,7 +195,6 @@ impl ModuleConfig {
                 false
             ),
 
-            enzyme_print_activity: sess.opts.unstable_opts.enzyme_print_activity,
             sanitizer: if_regular!(sess.opts.unstable_opts.sanitizer, SanitizerSet::empty()),
             sanitizer_recover: if_regular!(
                 sess.opts.unstable_opts.sanitizer_recover,
@@ -398,19 +396,19 @@ fn generate_lto_work<B: ExtraBackendMethods>(
 
     if !needs_fat_lto.is_empty() {
         assert!(needs_thin_lto.is_empty());
-        let mut lto_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);
-            lto_module = unsafe { lto_module.autodiff(cgcx, autodiff, typetrees, config).unwrap() };
+            module = unsafe { module.autodiff(cgcx, autodiff, typetrees, config).unwrap() };
         }
         // We are adding a single work item, so the cost doesn't matter.
-        vec![(WorkItem::LTO(lto_module), 0)]
+        vec![(WorkItem::LTO(module), 0)]
     } else {
         assert!(needs_fat_lto.is_empty());
-        let (lto_modules, copy_jobs) = B::run_thin_lto(cgcx, needs_thin_lto, import_only_modules)
+        let (modules, copy_jobs) = B::run_thin_lto(cgcx, needs_thin_lto, import_only_modules)
             .unwrap_or_else(|e| e.raise());
-        lto_modules
+        modules
             .into_iter()
             .map(|module| {
                 let cost = module.cost();

compiler/rustc_interface/src/tests.rs

@@ -767,7 +767,6 @@ fn test_unstable_options_tracking_hash() {
     tracked!(debug_macros, true);
     tracked!(dep_info_omit_d_target, true);
     tracked!(dual_proc_macros, true);
-    tracked!(enzyme_print_activity, false);
     tracked!(dwarf_version, Some(5));
     tracked!(emit_thin_lto, false);
     tracked!(export_executable_symbols, true);

compiler/rustc_monomorphize/src/partitioning.rs

@@ -92,7 +92,6 @@
 //! source-level module, functions from the same module will be available for
 //! inlining, even when they are not marked `#[inline]`.
 
-// Manuel, fixing rebase
 use rustc_symbol_mangling::symbol_name_for_instance_in_crate;
 use rustc_middle::middle::typetree::{Kind, Type, TypeTree};
 use rustc_target::abi::FieldsShape;
@@ -1143,7 +1142,6 @@ fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> (&DefIdSet, &[Au
         })
         .collect();
 
-
     let autodiff_items = items
         .iter()
         .filter_map(|item| match *item {
@@ -1156,6 +1154,7 @@ fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> (&DefIdSet, &[Au
             if !target_attrs.apply_autodiff() {
                 return None;
             }
+            println!("target_id: {:?}", target_id);
 
             let target_symbol =
                 symbol_name_for_instance_in_crate(tcx, instance.clone(), LOCAL_CRATE);
@@ -1250,9 +1249,6 @@ fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> (&DefIdSet, &[Au
 
     (tcx.arena.alloc(mono_items), autodiff_items, codegen_units)
 }
-//use rustc_middle::ty::{self, Adt, ParamEnvAnd, Ty};
-//use rustc_target::abi::FieldsShape;
-//use std::iter;
 
 pub fn typetree_empty() -> TypeTree {
     TypeTree(vec![])
@@ -1263,19 +1259,14 @@ pub fn typetree_from_ty<'a>(ty: Ty<'a>, tcx: TyCtxt<'a>, depth: usize) -> TypeTr
         if ty.is_fn_ptr() {
             unimplemented!("what to do whith fn ptr?");
         }
-
         let inner_ty = ty.builtin_deref(true).unwrap().ty;
         let child = typetree_from_ty(inner_ty, tcx, depth + 1);
-
         let tt = Type { offset: -1, kind: Kind::Pointer, size: 8, child };
-        //println!("{:depth$} add indirection {:?}", "", tt);
-
         return TypeTree(vec![tt]);
     }
 
     if ty.is_scalar() {
         assert!(!ty.is_any_ptr());
-
         let (kind, size) = if ty.is_integral() {
             (Kind::Integer, 8)
         } else {
@@ -1286,7 +1277,6 @@ pub fn typetree_from_ty<'a>(ty: Ty<'a>, tcx: TyCtxt<'a>, depth: usize) -> TypeTr
                 _ => panic!("floatTy scalar that is neither f32 nor f64"),
             }
         };
-
         return TypeTree(vec![Type { offset: -1, child: typetree_empty(), kind, size }]);
     }
 
@@ -1311,7 +1301,6 @@ pub fn typetree_from_ty<'a>(ty: Ty<'a>, tcx: TyCtxt<'a>, depth: usize) -> TypeTr
                 FieldsShape::Arbitrary { offsets: o, memory_index: m } => (o, m),
                 _ => panic!(""),
             };
-            //println!("{:depth$} combine fields", "");
 
             let fields = adt_def.all_fields();
             let fields = fields
@@ -1336,17 +1325,12 @@ pub fn typetree_from_ty<'a>(ty: Ty<'a>, tcx: TyCtxt<'a>, depth: usize) -> TypeTr
                         }
                     }
 
-                    //inner_tt.offset = offset;
-
-                    //println!("{:depth$} -> {:?}", "", child);
-
                     Some(child)
                 })
                 .flatten()
                 .collect::<Vec<Type>>();
 
             let ret_tt = TypeTree(fields);
-            //println!("{:depth$} into {:?}", "", ret_tt);
             return ret_tt;
         } else {
             unimplemented!("adt that isn't a struct");
@@ -1378,8 +1362,6 @@ pub fn typetree_from_ty<'a>(ty: Ty<'a>, tcx: TyCtxt<'a>, depth: usize) -> TypeTr
                 .collect(),
         );
 
-        //println!("{:depth$} repeated array into {:?}", "", tt);
-
         return tt;
     }
 
@@ -1390,7 +1372,6 @@ pub fn typetree_from_ty<'a>(ty: Ty<'a>, tcx: TyCtxt<'a>, depth: usize) -> TypeTr
         return subtt;
     }
 
-    //println!("Warning: create empty typetree for {}", ty);
     typetree_empty()
 }
 

compiler/rustc_session/src/options.rs

@@ -1537,8 +1537,6 @@ options! {
         "enables LTO for dylib crate type"),
     emit_stack_sizes: bool = (false, parse_bool, [UNTRACKED],
         "emit a section containing stack size metadata (default: no)"),
-    enzyme_print_activity: bool = (false, parse_bool, [TRACKED],
-        "print type trees for functions passed to enzyme"),
     emit_thin_lto: bool = (true, parse_bool, [TRACKED],
         "emit the bc module with thin LTO info (default: yes)"),
     export_executable_symbols: bool = (false, parse_bool, [TRACKED],