2023-04-19 06:49:47 -05:00
|
|
|
// FIXME #110395
|
|
|
|
|
// ignore-llvm-cov-show-diffs
|
|
|
|
|
|
2020-12-02 01:01:26 -06:00
|
|
|
#![allow(unused_assignments, unused_variables)]
|
coverage bug fixes and optimization support
Adjusted LLVM codegen for code compiled with `-Zinstrument-coverage` to
address multiple, somewhat related issues.
Fixed a significant flaw in prior coverage solution: Every counter
generated a new counter variable, but there should have only been one
counter variable per function. This appears to have bloated .profraw
files significantly. (For a small program, it increased the size by
about 40%. I have not tested large programs, but there is anecdotal
evidence that profraw files were way too large. This is a good fix,
regardless, but hopefully it also addresses related issues.
Fixes: #82144
Invalid LLVM coverage data produced when compiled with -C opt-level=1
Existing tests now work up to at least `opt-level=3`. This required a
detailed analysis of the LLVM IR, comparisons with Clang C++ LLVM IR
when compiled with coverage, and a lot of trial and error with codegen
adjustments.
The biggest hurdle was figuring out how to continue to support coverage
results for unused functions and generics. Rust's coverage results have
three advantages over Clang's coverage results:
1. Rust's coverage map does not include any overlapping code regions,
making coverage counting unambiguous.
2. Rust generates coverage results (showing zero counts) for all unused
functions, including generics. (Clang does not generate coverage for
uninstantiated template functions.)
3. Rust's unused functions produce minimal stubbed functions in LLVM IR,
sufficient for including in the coverage results; while Clang must
generate the complete LLVM IR for each unused function, even though
it will never be called.
This PR removes the previous hack of attempting to inject coverage into
some other existing function instance, and generates dedicated instances
for each unused function. This change, and a few other adjustments
(similar to what is required for `-C link-dead-code`, but with lower
impact), makes it possible to support LLVM optimizations.
Fixes: #79651
Coverage report: "Unexecuted instantiation:..." for a generic function
from multiple crates
Fixed by removing the aforementioned hack. Some "Unexecuted
instantiation" notices are unavoidable, as explained in the
`used_crate.rs` test, but `-Zinstrument-coverage` has new options to
back off support for either unused generics, or all unused functions,
which avoids the notice, at the cost of less coverage of unused
functions.
Fixes: #82875
Invalid LLVM coverage data produced with crate brotli_decompressor
Fixed by disabling the LLVM function attribute that forces inlining, if
`-Z instrument-coverage` is enabled. This attribute is applied to
Rust functions with `#[inline(always)], and in some cases, the forced
inlining breaks coverage instrumentation and reports.
2021-03-15 18:32:45 -05:00
|
|
|
// compile-flags: -C opt-level=3 # validates coverage now works with optimizations
|
2020-12-02 17:39:40 -06:00
|
|
|
extern crate used_crate;
|
2020-12-02 01:01:26 -06:00
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
|
used_crate::used_function();
|
|
|
|
|
let some_vec = vec![1, 2, 3, 4];
|
2020-12-02 17:39:40 -06:00
|
|
|
used_crate::used_only_from_bin_crate_generic_function(&some_vec);
|
|
|
|
|
used_crate::used_only_from_bin_crate_generic_function("used from bin uses_crate.rs");
|
|
|
|
|
used_crate::used_from_bin_crate_and_lib_crate_generic_function(some_vec);
|
|
|
|
|
used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function("interesting?");
|
2020-12-02 01:01:26 -06:00
|
|
|
}
|
