Merge commit 'e228f0c16ea8c34794a6285bf57aab627c26b147' into libgccjit-codegen

[rust.git] / compiler / rustc_codegen_gcc / src / coverageinfo.rs

diff --git a/compiler/rustc_codegen_gcc/src/coverageinfo.rs b/compiler/rustc_codegen_gcc/src/coverageinfo.rs
index f966f6e75336f7bcbe1db89a37c0c1c48e92994d..872fc2472e223d68f6deccd853e37e653cd60dc4 100644 (file)
--- a/compiler/rustc_codegen_gcc/src/coverageinfo.rs
+++ b/compiler/rustc_codegen_gcc/src/coverageinfo.rs
@@ -20,99 +20,31 @@ fn set_function_source_hash(
         _function_source_hash: u64,
     ) -> bool {
         unimplemented!();
-        /*if let Some(coverage_context) = self.coverage_context() {
-            debug!(
-                "ensuring function source hash is set for instance={:?}; function_source_hash={}",
-                instance, function_source_hash,
-            );
-            let mut coverage_map = coverage_context.function_coverage_map.borrow_mut();
-            coverage_map
-                .entry(instance)
-                .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
-                .set_function_source_hash(function_source_hash);
-            true
-        } else {
-            false
-        }*/
     }
 
     fn add_coverage_counter(&mut self, _instance: Instance<'tcx>, _id: CounterValueReference, _region: CodeRegion) -> bool {
-        /*if let Some(coverage_context) = self.coverage_context() {
-            debug!(
-                "adding counter to coverage_regions: instance={:?}, function_source_hash={}, id={:?}, \
-                at {:?}",
-                instance, function_source_hash, id, region,
-            );
-            let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut();
-            coverage_regions
-                .entry(instance)
-                .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
-                .add_counter(function_source_hash, id, region);
-            true
-        } else {
-            false
-        }*/
-        // TODO
+        // TODO(antoyo)
         false
     }
 
     fn add_coverage_counter_expression(&mut self, _instance: Instance<'tcx>, _id: InjectedExpressionId, _lhs: ExpressionOperandId, _op: Op, _rhs: ExpressionOperandId, _region: Option<CodeRegion>) -> bool {
-        /*if let Some(coverage_context) = self.coverage_context() {
-            debug!(
-                "adding counter expression to coverage_regions: instance={:?}, id={:?}, {:?} {:?} {:?}, \
-                at {:?}",
-                instance, id, lhs, op, rhs, region,
-            );
-            let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut();
-            coverage_regions
-                .entry(instance)
-                .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
-                .add_counter_expression(id, lhs, op, rhs, region);
-            true
-        } else {
-            false
-        }*/
-        // TODO
+        // TODO(antoyo)
         false
     }
 
     fn add_coverage_unreachable(&mut self, _instance: Instance<'tcx>, _region: CodeRegion) -> bool {
-        /*if let Some(coverage_context) = self.coverage_context() {
-            debug!(
-                "adding unreachable code to coverage_regions: instance={:?}, at {:?}",
-                instance, region,
-            );
-            let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut();
-            coverage_regions
-                .entry(instance)
-                .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
-                .add_unreachable_region(region);
-            true
-        } else {
-            false
-        }*/
-        // TODO
+        // TODO(antoyo)
         false
     }
 }
 
 impl<'gcc, 'tcx> CoverageInfoMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
     fn coverageinfo_finalize(&self) {
-        // TODO
-        //mapgen::finalize(self)
+        // TODO(antoyo)
     }
 
     fn get_pgo_func_name_var(&self, _instance: Instance<'tcx>) -> RValue<'gcc> {
         unimplemented!();
-        /*if let Some(coverage_context) = self.coverage_context() {
-            debug!("getting pgo_func_name_var for instance={:?}", instance);
-            let mut pgo_func_name_var_map = coverage_context.pgo_func_name_var_map.borrow_mut();
-            pgo_func_name_var_map
-                .entry(instance)
-                .or_insert_with(|| create_pgo_func_name_var(self, instance))
-        } else {
-            bug!("Could not get the `coverage_context`");
-        }*/
     }
 
     /// Functions with MIR-based coverage are normally codegenned _only_ if
@@ -133,8 +65,5 @@ fn get_pgo_func_name_var(&self, _instance: Instance<'tcx>) -> RValue<'gcc> {
     /// added as `unreachable_region`s.
     fn define_unused_fn(&self, _def_id: DefId) {
         unimplemented!();
-        /*let instance = declare_unused_fn(self, &def_id);
-        codegen_unused_fn_and_counter(self, instance);
-        add_unused_function_coverage(self, instance, def_id);*/
     }
 }