Remove verbose_generic_activity_with_arg

compiler/rustc_codegen_cranelift/src/driver/aot.rs

@@ -269,7 +269,7 @@ fn module_codegen(
     ),
 ) -> OngoingModuleCodegen {
     let (cgu_name, mut cx, mut module, codegened_functions) =
-        tcx.prof.verbose_generic_activity_with_arg("codegen cgu", cgu_name.as_str()).run(|| {
+        tcx.prof.generic_activity_with_arg("codegen cgu", cgu_name.as_str()).run(|| {
             let cgu = tcx.codegen_unit(cgu_name);
             let mono_items = cgu.items_in_deterministic_order(tcx);
 
@@ -322,35 +322,24 @@ fn module_codegen(
         });
 
     OngoingModuleCodegen::Async(std::thread::spawn(move || {
-        cx.profiler.clone().verbose_generic_activity_with_arg("compile functions", &*cgu_name).run(
+        cx.profiler.clone().generic_activity_with_arg("compile functions", &*cgu_name).run(|| {
-            || {
             cranelift_codegen::timing::set_thread_profiler(Box::new(super::MeasuremeProfiler(
                 cx.profiler.clone(),
             )));
 
             let mut cached_context = Context::new();
             for codegened_func in codegened_functions {
-                    crate::base::compile_fn(
+                crate::base::compile_fn(&mut cx, &mut cached_context, &mut module, codegened_func);
-                        &mut cx,
-                        &mut cached_context,
-                        &mut module,
-                        codegened_func,
-                    );
             }
-            },
+        });
-        );
 
-        let global_asm_object_file = cx
+        let global_asm_object_file =
-            .profiler
+            cx.profiler.generic_activity_with_arg("compile assembly", &*cgu_name).run(|| {
-            .verbose_generic_activity_with_arg("compile assembly", &*cgu_name)
-            .run(|| {
                 crate::global_asm::compile_global_asm(&global_asm_config, &cgu_name, &cx.global_asm)
             })?;
 
-        let codegen_result = cx
+        let codegen_result =
-            .profiler
+            cx.profiler.generic_activity_with_arg("write object file", &*cgu_name).run(|| {
-            .verbose_generic_activity_with_arg("write object file", &*cgu_name)
-            .run(|| {
                 emit_cgu(
                     &global_asm_config.output_filenames,
                     &cx.profiler,

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -605,7 +605,7 @@ pub(crate) fn run_pass_manager(
     module: &mut ModuleCodegen<ModuleLlvm>,
     thin: bool,
 ) -> Result<(), FatalError> {
-    let _timer = cgcx.prof.verbose_generic_activity_with_arg("LLVM_lto_optimize", &*module.name);
+    let _timer = cgcx.prof.generic_activity_with_arg("LLVM_lto_optimize", &*module.name);
     let config = cgcx.config(module.kind);
 
     // Now we have one massive module inside of llmod. Time to run the

compiler/rustc_data_structures/src/profiling.rs

@@ -223,25 +223,6 @@ impl SelfProfilerRef {
         VerboseTimingGuard::start(message_and_format, self.generic_activity(event_label))
     }
 
-    /// Like `verbose_generic_activity`, but with an extra arg.
-    pub fn verbose_generic_activity_with_arg<A>(
-        &self,
-        event_label: &'static str,
-        event_arg: A,
-    ) -> VerboseTimingGuard<'_>
-    where
-        A: Borrow<str> + Into<String>,
-    {
-        let message_and_format = self
-            .print_verbose_generic_activities
-            .map(|format| (format!("{}({})", event_label, event_arg.borrow()), format));
-
-        VerboseTimingGuard::start(
-            message_and_format,
-            self.generic_activity_with_arg(event_label, event_arg),
-        )
-    }
-
     /// Start profiling a generic activity. Profiling continues until the
     /// TimingGuard returned from this call is dropped.
     #[inline(always)]

compiler/rustc_mir_transform/src/pass_manager.rs

@@ -121,7 +121,10 @@ fn run_passes_inner<'tcx>(
                 validate_body(tcx, body, format!("before pass {name}"));
             }
 
-            tcx.sess.time(name, || pass.run_pass(tcx, body));
+            tcx.sess
+                .prof
+                .generic_activity_with_arg("mir_pass", name)
+                .run(|| pass.run_pass(tcx, body));
 
             if dump_enabled {
                 dump_mir_for_pass(tcx, body, &name, true);

compiler/rustc_query_impl/src/plumbing.rs

@@ -348,8 +348,7 @@ pub(crate) fn encode_query_results<'a, 'tcx, Q>(
     Q: super::QueryConfigRestored<'tcx>,
     Q::RestoredValue: Encodable<CacheEncoder<'a, 'tcx>>,
 {
-    let _timer =
+    let _timer = qcx.profiler().generic_activity_with_arg("encode_query_results_for", query.name());
-        qcx.profiler().verbose_generic_activity_with_arg("encode_query_results_for", query.name());
 
     assert!(query.query_state(qcx).all_inactive());
     let cache = query.query_cache(qcx);