Rollup merge of #79365 - richkadel:llvm-cov-map-version-4, r=wesleywiser
Upgrades the coverage map to Version 4 Changes the coverage map injected into binaries compiled with `-Zinstrument-coverage` to LLVM Coverage Mapping Format, Version 4 (from Version 3). Note, binaries compiled with this version will require LLVM tools from at least LLVM Version 11. r? ``@wesleywiser``
This commit is contained in:
Jonas Schievink
GitHub
commit
0ae653a531
@ -4,7 +4,7 @@ use crate::llvm;
|
||||
|
||||
use llvm::coverageinfo::CounterMappingRegion;
|
||||
use rustc_codegen_ssa::coverageinfo::map::{Counter, CounterExpression};
|
||||
use rustc_codegen_ssa::traits::{BaseTypeMethods, ConstMethods};
|
||||
use rustc_codegen_ssa::traits::ConstMethods;
|
||||
use rustc_data_structures::fx::FxIndexSet;
|
||||
use rustc_llvm::RustString;
|
||||
use rustc_middle::mir::coverage::CodeRegion;
|
||||
@ -15,9 +15,9 @@ use tracing::debug;
|
||||
|
||||
/// Generates and exports the Coverage Map.
|
||||
///
|
||||
/// This Coverage Map complies with Coverage Mapping Format version 3 (zero-based encoded as 2),
|
||||
/// as defined at [LLVM Code Coverage Mapping Format](https://github.com/rust-lang/llvm-project/blob/llvmorg-8.0.0/llvm/docs/CoverageMappingFormat.rst#llvm-code-coverage-mapping-format)
|
||||
/// and published in Rust's current (July 2020) fork of LLVM. This version is supported by the
|
||||
/// This Coverage Map complies with Coverage Mapping Format version 4 (zero-based encoded as 3),
|
||||
/// as defined at [LLVM Code Coverage Mapping Format](https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/docs/CoverageMappingFormat.rst#llvm-code-coverage-mapping-format)
|
||||
/// and published in Rust's current (November 2020) fork of LLVM. This version is supported by the
|
||||
/// LLVM coverage tools (`llvm-profdata` and `llvm-cov`) bundled with Rust's fork of LLVM.
|
||||
///
|
||||
/// Consequently, Rust's bundled version of Clang also generates Coverage Maps compliant with
|
||||
@ -26,6 +26,13 @@ use tracing::debug;
|
||||
/// undocumented details in Clang's implementation (that may or may not be important) were also
|
||||
/// replicated for Rust's Coverage Map.
|
||||
pub fn finalize<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>) {
|
||||
// Ensure LLVM supports Coverage Map Version 4 (encoded as a zero-based value: 3).
|
||||
// If not, the LLVM Version must be less than 11.
|
||||
let version = coverageinfo::mapping_version();
|
||||
if version != 3 {
|
||||
cx.tcx.sess.fatal("rustc option `-Z instrument-coverage` requires LLVM 11 or higher.");
|
||||
}
|
||||
|
||||
let function_coverage_map = match cx.coverage_context() {
|
||||
Some(ctx) => ctx.take_function_coverage_map(),
|
||||
None => return,
|
||||
@ -38,46 +45,50 @@ pub fn finalize<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>) {
|
||||
let mut mapgen = CoverageMapGenerator::new();
|
||||
|
||||
// Encode coverage mappings and generate function records
|
||||
let mut function_records = Vec::<&'ll llvm::Value>::new();
|
||||
let coverage_mappings_buffer = llvm::build_byte_buffer(|coverage_mappings_buffer| {
|
||||
for (instance, function_coverage) in function_coverage_map.into_iter() {
|
||||
debug!("Generate coverage map for: {:?}", instance);
|
||||
let mut function_data = Vec::new();
|
||||
for (instance, function_coverage) in function_coverage_map {
|
||||
debug!("Generate coverage map for: {:?}", instance);
|
||||
|
||||
let mangled_function_name = cx.tcx.symbol_name(instance).to_string();
|
||||
let function_source_hash = function_coverage.source_hash();
|
||||
let (expressions, counter_regions) =
|
||||
function_coverage.get_expressions_and_counter_regions();
|
||||
let mangled_function_name = cx.tcx.symbol_name(instance).to_string();
|
||||
let function_source_hash = function_coverage.source_hash();
|
||||
let (expressions, counter_regions) =
|
||||
function_coverage.get_expressions_and_counter_regions();
|
||||
|
||||
let old_len = coverage_mappings_buffer.len();
|
||||
mapgen.write_coverage_mappings(expressions, counter_regions, coverage_mappings_buffer);
|
||||
let mapping_data_size = coverage_mappings_buffer.len() - old_len;
|
||||
debug_assert!(
|
||||
mapping_data_size > 0,
|
||||
"Every `FunctionCoverage` should have at least one counter"
|
||||
);
|
||||
let coverage_mapping_buffer = llvm::build_byte_buffer(|coverage_mapping_buffer| {
|
||||
mapgen.write_coverage_mapping(expressions, counter_regions, coverage_mapping_buffer);
|
||||
});
|
||||
debug_assert!(
|
||||
coverage_mapping_buffer.len() > 0,
|
||||
"Every `FunctionCoverage` should have at least one counter"
|
||||
);
|
||||
|
||||
let function_record = mapgen.make_function_record(
|
||||
cx,
|
||||
mangled_function_name,
|
||||
function_source_hash,
|
||||
mapping_data_size,
|
||||
);
|
||||
function_records.push(function_record);
|
||||
}
|
||||
});
|
||||
function_data.push((mangled_function_name, function_source_hash, coverage_mapping_buffer));
|
||||
}
|
||||
|
||||
// Encode all filenames referenced by counters/expressions in this module
|
||||
let filenames_buffer = llvm::build_byte_buffer(|filenames_buffer| {
|
||||
coverageinfo::write_filenames_section_to_buffer(&mapgen.filenames, filenames_buffer);
|
||||
});
|
||||
|
||||
let filenames_size = filenames_buffer.len();
|
||||
let filenames_val = cx.const_bytes(&filenames_buffer[..]);
|
||||
let filenames_ref = coverageinfo::hash_bytes(filenames_buffer);
|
||||
|
||||
// Generate the LLVM IR representation of the coverage map and store it in a well-known global
|
||||
mapgen.save_generated_coverage_map(
|
||||
cx,
|
||||
function_records,
|
||||
filenames_buffer,
|
||||
coverage_mappings_buffer,
|
||||
);
|
||||
let cov_data_val = mapgen.generate_coverage_map(cx, version, filenames_size, filenames_val);
|
||||
|
||||
for (mangled_function_name, function_source_hash, coverage_mapping_buffer) in function_data {
|
||||
save_function_record(
|
||||
cx,
|
||||
mangled_function_name,
|
||||
function_source_hash,
|
||||
filenames_ref,
|
||||
coverage_mapping_buffer,
|
||||
);
|
||||
}
|
||||
|
||||
// Save the coverage data value to LLVM IR
|
||||
coverageinfo::save_cov_data_to_mod(cx, cov_data_val);
|
||||
}
|
||||
|
||||
struct CoverageMapGenerator {
|
||||
@ -92,12 +103,12 @@ impl CoverageMapGenerator {
|
||||
/// Using the `expressions` and `counter_regions` collected for the current function, generate
|
||||
/// the `mapping_regions` and `virtual_file_mapping`, and capture any new filenames. Then use
|
||||
/// LLVM APIs to encode the `virtual_file_mapping`, `expressions`, and `mapping_regions` into
|
||||
/// the given `coverage_mappings` byte buffer, compliant with the LLVM Coverage Mapping format.
|
||||
fn write_coverage_mappings(
|
||||
/// the given `coverage_mapping` byte buffer, compliant with the LLVM Coverage Mapping format.
|
||||
fn write_coverage_mapping(
|
||||
&mut self,
|
||||
expressions: Vec<CounterExpression>,
|
||||
counter_regions: impl Iterator<Item = (Counter, &'a CodeRegion)>,
|
||||
coverage_mappings_buffer: &RustString,
|
||||
coverage_mapping_buffer: &RustString,
|
||||
) {
|
||||
let mut counter_regions = counter_regions.collect::<Vec<_>>();
|
||||
if counter_regions.is_empty() {
|
||||
@ -145,89 +156,75 @@ impl CoverageMapGenerator {
|
||||
virtual_file_mapping,
|
||||
expressions,
|
||||
mapping_regions,
|
||||
coverage_mappings_buffer,
|
||||
coverage_mapping_buffer,
|
||||
);
|
||||
}
|
||||
|
||||
/// Generate and return the function record `Value`
|
||||
fn make_function_record(
|
||||
&mut self,
|
||||
cx: &CodegenCx<'ll, 'tcx>,
|
||||
mangled_function_name: String,
|
||||
function_source_hash: u64,
|
||||
mapping_data_size: usize,
|
||||
) -> &'ll llvm::Value {
|
||||
let name_ref = coverageinfo::compute_hash(&mangled_function_name);
|
||||
let name_ref_val = cx.const_u64(name_ref);
|
||||
let mapping_data_size_val = cx.const_u32(mapping_data_size as u32);
|
||||
let func_hash_val = cx.const_u64(function_source_hash);
|
||||
cx.const_struct(
|
||||
&[name_ref_val, mapping_data_size_val, func_hash_val],
|
||||
/*packed=*/ true,
|
||||
)
|
||||
}
|
||||
|
||||
/// Combine the filenames and coverage mappings buffers, construct coverage map header and the
|
||||
/// array of function records, and combine everything into the complete coverage map. Save the
|
||||
/// coverage map data into the LLVM IR as a static global using a specific, well-known section
|
||||
/// and name.
|
||||
fn save_generated_coverage_map(
|
||||
/// Construct coverage map header and the array of function records, and combine them into the
|
||||
/// coverage map. Save the coverage map data into the LLVM IR as a static global using a
|
||||
/// specific, well-known section and name.
|
||||
fn generate_coverage_map(
|
||||
self,
|
||||
cx: &CodegenCx<'ll, 'tcx>,
|
||||
function_records: Vec<&'ll llvm::Value>,
|
||||
filenames_buffer: Vec<u8>,
|
||||
mut coverage_mappings_buffer: Vec<u8>,
|
||||
) {
|
||||
// Concatenate the encoded filenames and encoded coverage mappings, and add additional zero
|
||||
// bytes as-needed to ensure 8-byte alignment.
|
||||
let mut coverage_size = coverage_mappings_buffer.len();
|
||||
let filenames_size = filenames_buffer.len();
|
||||
let remaining_bytes =
|
||||
(filenames_size + coverage_size) % coverageinfo::COVMAP_VAR_ALIGN_BYTES;
|
||||
if remaining_bytes > 0 {
|
||||
let pad = coverageinfo::COVMAP_VAR_ALIGN_BYTES - remaining_bytes;
|
||||
coverage_mappings_buffer.append(&mut [0].repeat(pad));
|
||||
coverage_size += pad;
|
||||
}
|
||||
let filenames_and_coverage_mappings = [filenames_buffer, coverage_mappings_buffer].concat();
|
||||
let filenames_and_coverage_mappings_val =
|
||||
cx.const_bytes(&filenames_and_coverage_mappings[..]);
|
||||
version: u32,
|
||||
filenames_size: usize,
|
||||
filenames_val: &'ll llvm::Value,
|
||||
) -> &'ll llvm::Value {
|
||||
debug!("cov map: filenames_size = {}, 0-based version = {}", filenames_size, version);
|
||||
|
||||
debug!(
|
||||
"cov map: n_records = {}, filenames_size = {}, coverage_size = {}, 0-based version = {}",
|
||||
function_records.len(),
|
||||
filenames_size,
|
||||
coverage_size,
|
||||
coverageinfo::mapping_version()
|
||||
);
|
||||
|
||||
// Create the coverage data header
|
||||
let n_records_val = cx.const_u32(function_records.len() as u32);
|
||||
// Create the coverage data header (Note, fields 0 and 2 are now always zero,
|
||||
// as of `llvm::coverage::CovMapVersion::Version4`.)
|
||||
let zero_was_n_records_val = cx.const_u32(0);
|
||||
let filenames_size_val = cx.const_u32(filenames_size as u32);
|
||||
let coverage_size_val = cx.const_u32(coverage_size as u32);
|
||||
let version_val = cx.const_u32(coverageinfo::mapping_version());
|
||||
let zero_was_coverage_size_val = cx.const_u32(0);
|
||||
let version_val = cx.const_u32(version);
|
||||
let cov_data_header_val = cx.const_struct(
|
||||
&[n_records_val, filenames_size_val, coverage_size_val, version_val],
|
||||
&[zero_was_n_records_val, filenames_size_val, zero_was_coverage_size_val, version_val],
|
||||
/*packed=*/ false,
|
||||
);
|
||||
|
||||
// Create the function records array
|
||||
let name_ref_from_u64 = cx.type_i64();
|
||||
let mapping_data_size_from_u32 = cx.type_i32();
|
||||
let func_hash_from_u64 = cx.type_i64();
|
||||
let function_record_ty = cx.type_struct(
|
||||
&[name_ref_from_u64, mapping_data_size_from_u32, func_hash_from_u64],
|
||||
/*packed=*/ true,
|
||||
);
|
||||
let function_records_val = cx.const_array(function_record_ty, &function_records[..]);
|
||||
|
||||
// Create the complete LLVM coverage data value to add to the LLVM IR
|
||||
let cov_data_val = cx.const_struct(
|
||||
&[cov_data_header_val, function_records_val, filenames_and_coverage_mappings_val],
|
||||
/*packed=*/ false,
|
||||
);
|
||||
|
||||
// Save the coverage data value to LLVM IR
|
||||
coverageinfo::save_map_to_mod(cx, cov_data_val);
|
||||
cx.const_struct(&[cov_data_header_val, filenames_val], /*packed=*/ false)
|
||||
}
|
||||
}
|
||||
|
||||
/// Construct a function record and combine it with the function's coverage mapping data.
|
||||
/// Save the function record into the LLVM IR as a static global using a
|
||||
/// specific, well-known section and name.
|
||||
fn save_function_record(
|
||||
cx: &CodegenCx<'ll, 'tcx>,
|
||||
mangled_function_name: String,
|
||||
function_source_hash: u64,
|
||||
filenames_ref: u64,
|
||||
coverage_mapping_buffer: Vec<u8>,
|
||||
) {
|
||||
// Concatenate the encoded coverage mappings
|
||||
let coverage_mapping_size = coverage_mapping_buffer.len();
|
||||
let coverage_mapping_val = cx.const_bytes(&coverage_mapping_buffer[..]);
|
||||
|
||||
let func_name_hash = coverageinfo::hash_str(&mangled_function_name);
|
||||
let func_name_hash_val = cx.const_u64(func_name_hash);
|
||||
let coverage_mapping_size_val = cx.const_u32(coverage_mapping_size as u32);
|
||||
let func_hash_val = cx.const_u64(function_source_hash);
|
||||
let filenames_ref_val = cx.const_u64(filenames_ref);
|
||||
let func_record_val = cx.const_struct(
|
||||
&[
|
||||
func_name_hash_val,
|
||||
coverage_mapping_size_val,
|
||||
func_hash_val,
|
||||
filenames_ref_val,
|
||||
coverage_mapping_val,
|
||||
],
|
||||
/*packed=*/ true,
|
||||
);
|
||||
|
||||
// At the present time, the coverage map for Rust assumes every instrumented function `is_used`.
|
||||
// Note that Clang marks functions as "unused" in `CodeGenPGO::emitEmptyCounterMapping`. (See:
|
||||
// https://github.com/rust-lang/llvm-project/blob/de02a75e398415bad4df27b4547c25b896c8bf3b/clang%2Flib%2FCodeGen%2FCodeGenPGO.cpp#L877-L878
|
||||
// for example.)
|
||||
//
|
||||
// It's not yet clear if or how this may be applied to Rust in the future, but the `is_used`
|
||||
// argument is available and handled similarly.
|
||||
let is_used = true;
|
||||
coverageinfo::save_func_record_to_mod(cx, func_name_hash, func_record_val, is_used);
|
||||
}
|
||||
|
||||
@ -23,7 +23,7 @@ use tracing::debug;
|
||||
|
||||
pub mod mapgen;
|
||||
|
||||
const COVMAP_VAR_ALIGN_BYTES: usize = 8;
|
||||
const VAR_ALIGN_BYTES: usize = 8;
|
||||
|
||||
/// A context object for maintaining all state needed by the coverageinfo module.
|
||||
pub struct CrateCoverageContext<'tcx> {
|
||||
@ -177,17 +177,20 @@ pub(crate) fn write_mapping_to_buffer(
|
||||
);
|
||||
}
|
||||
}
|
||||
pub(crate) fn hash_str(strval: &str) -> u64 {
|
||||
let strval = CString::new(strval).expect("null error converting hashable str to C string");
|
||||
unsafe { llvm::LLVMRustCoverageHashCString(strval.as_ptr()) }
|
||||
}
|
||||
|
||||
pub(crate) fn compute_hash(name: &str) -> u64 {
|
||||
let name = CString::new(name).expect("null error converting hashable name to C string");
|
||||
unsafe { llvm::LLVMRustCoverageComputeHash(name.as_ptr()) }
|
||||
pub(crate) fn hash_bytes(bytes: Vec<u8>) -> u64 {
|
||||
unsafe { llvm::LLVMRustCoverageHashByteArray(bytes.as_ptr().cast(), bytes.len()) }
|
||||
}
|
||||
|
||||
pub(crate) fn mapping_version() -> u32 {
|
||||
unsafe { llvm::LLVMRustCoverageMappingVersion() }
|
||||
}
|
||||
|
||||
pub(crate) fn save_map_to_mod<'ll, 'tcx>(
|
||||
pub(crate) fn save_cov_data_to_mod<'ll, 'tcx>(
|
||||
cx: &CodegenCx<'ll, 'tcx>,
|
||||
cov_data_val: &'ll llvm::Value,
|
||||
) {
|
||||
@ -198,7 +201,7 @@ pub(crate) fn save_map_to_mod<'ll, 'tcx>(
|
||||
debug!("covmap var name: {:?}", covmap_var_name);
|
||||
|
||||
let covmap_section_name = llvm::build_string(|s| unsafe {
|
||||
llvm::LLVMRustCoverageWriteSectionNameToString(cx.llmod, s);
|
||||
llvm::LLVMRustCoverageWriteMapSectionNameToString(cx.llmod, s);
|
||||
})
|
||||
.expect("Rust Coverage section name failed UTF-8 conversion");
|
||||
debug!("covmap section name: {:?}", covmap_section_name);
|
||||
@ -206,8 +209,43 @@ pub(crate) fn save_map_to_mod<'ll, 'tcx>(
|
||||
let llglobal = llvm::add_global(cx.llmod, cx.val_ty(cov_data_val), &covmap_var_name);
|
||||
llvm::set_initializer(llglobal, cov_data_val);
|
||||
llvm::set_global_constant(llglobal, true);
|
||||
llvm::set_linkage(llglobal, llvm::Linkage::InternalLinkage);
|
||||
llvm::set_linkage(llglobal, llvm::Linkage::PrivateLinkage);
|
||||
llvm::set_section(llglobal, &covmap_section_name);
|
||||
llvm::set_alignment(llglobal, COVMAP_VAR_ALIGN_BYTES);
|
||||
llvm::set_alignment(llglobal, VAR_ALIGN_BYTES);
|
||||
cx.add_used_global(llglobal);
|
||||
}
|
||||
|
||||
pub(crate) fn save_func_record_to_mod<'ll, 'tcx>(
|
||||
cx: &CodegenCx<'ll, 'tcx>,
|
||||
func_name_hash: u64,
|
||||
func_record_val: &'ll llvm::Value,
|
||||
is_used: bool,
|
||||
) {
|
||||
// Assign a name to the function record. This is used to merge duplicates.
|
||||
//
|
||||
// In LLVM, a "translation unit" (effectively, a `Crate` in Rust) can describe functions that
|
||||
// are included-but-not-used. If (or when) Rust generates functions that are
|
||||
// included-but-not-used, note that a dummy description for a function included-but-not-used
|
||||
// in a Crate can be replaced by full description provided by a different Crate. The two kinds
|
||||
// of descriptions play distinct roles in LLVM IR; therefore, assign them different names (by
|
||||
// appending "u" to the end of the function record var name, to prevent `linkonce_odr` merging.
|
||||
let func_record_var_name =
|
||||
format!("__covrec_{:X}{}", func_name_hash, if is_used { "u" } else { "" });
|
||||
debug!("function record var name: {:?}", func_record_var_name);
|
||||
|
||||
let func_record_section_name = llvm::build_string(|s| unsafe {
|
||||
llvm::LLVMRustCoverageWriteFuncSectionNameToString(cx.llmod, s);
|
||||
})
|
||||
.expect("Rust Coverage function record section name failed UTF-8 conversion");
|
||||
debug!("function record section name: {:?}", func_record_section_name);
|
||||
|
||||
let llglobal = llvm::add_global(cx.llmod, cx.val_ty(func_record_val), &func_record_var_name);
|
||||
llvm::set_initializer(llglobal, func_record_val);
|
||||
llvm::set_global_constant(llglobal, true);
|
||||
llvm::set_linkage(llglobal, llvm::Linkage::LinkOnceODRLinkage);
|
||||
llvm::set_visibility(llglobal, llvm::Visibility::Hidden);
|
||||
llvm::set_section(llglobal, &func_record_section_name);
|
||||
llvm::set_alignment(llglobal, VAR_ALIGN_BYTES);
|
||||
llvm::set_comdat(cx.llmod, llglobal, &func_record_var_name);
|
||||
cx.add_used_global(llglobal);
|
||||
}
|
||||
|
||||
@ -642,7 +642,7 @@ pub type InlineAsmDiagHandler = unsafe extern "C" fn(&SMDiagnostic, *const c_voi
|
||||
pub mod coverageinfo {
|
||||
use super::coverage_map;
|
||||
|
||||
/// Aligns with [llvm::coverage::CounterMappingRegion::RegionKind](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L205-L221)
|
||||
/// Aligns with [llvm::coverage::CounterMappingRegion::RegionKind](https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L206-L222)
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
#[repr(C)]
|
||||
pub enum RegionKind {
|
||||
@ -665,13 +665,13 @@ pub mod coverageinfo {
|
||||
|
||||
/// This struct provides LLVM's representation of a "CoverageMappingRegion", encoded into the
|
||||
/// coverage map, in accordance with the
|
||||
/// [LLVM Code Coverage Mapping Format](https://github.com/rust-lang/llvm-project/blob/llvmorg-8.0.0/llvm/docs/CoverageMappingFormat.rst#llvm-code-coverage-mapping-format).
|
||||
/// [LLVM Code Coverage Mapping Format](https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/docs/CoverageMappingFormat.rst#llvm-code-coverage-mapping-format).
|
||||
/// The struct composes fields representing the `Counter` type and value(s) (injected counter
|
||||
/// ID, or expression type and operands), the source file (an indirect index into a "filenames
|
||||
/// array", encoded separately), and source location (start and end positions of the represented
|
||||
/// code region).
|
||||
///
|
||||
/// Aligns with [llvm::coverage::CounterMappingRegion](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L223-L226)
|
||||
/// Aligns with [llvm::coverage::CounterMappingRegion](https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L224-L227)
|
||||
/// Important: The Rust struct layout (order and types of fields) must match its C++
|
||||
/// counterpart.
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
@ -1791,10 +1791,14 @@ extern "C" {
|
||||
|
||||
pub fn LLVMRustCoverageCreatePGOFuncNameVar(F: &'a Value, FuncName: *const c_char)
|
||||
-> &'a Value;
|
||||
pub fn LLVMRustCoverageComputeHash(Name: *const c_char) -> u64;
|
||||
pub fn LLVMRustCoverageHashCString(StrVal: *const c_char) -> u64;
|
||||
pub fn LLVMRustCoverageHashByteArray(Bytes: *const c_char, NumBytes: size_t) -> u64;
|
||||
|
||||
#[allow(improper_ctypes)]
|
||||
pub fn LLVMRustCoverageWriteSectionNameToString(M: &Module, Str: &RustString);
|
||||
pub fn LLVMRustCoverageWriteMapSectionNameToString(M: &Module, Str: &RustString);
|
||||
|
||||
#[allow(improper_ctypes)]
|
||||
pub fn LLVMRustCoverageWriteFuncSectionNameToString(M: &Module, Str: &RustString);
|
||||
|
||||
#[allow(improper_ctypes)]
|
||||
pub fn LLVMRustCoverageWriteMappingVarNameToString(Str: &RustString);
|
||||
|
||||
@ -220,12 +220,24 @@ pub fn set_linkage(llglobal: &Value, linkage: Linkage) {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_visibility(llglobal: &Value, visibility: Visibility) {
|
||||
unsafe {
|
||||
LLVMRustSetVisibility(llglobal, visibility);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_alignment(llglobal: &Value, bytes: usize) {
|
||||
unsafe {
|
||||
ffi::LLVMSetAlignment(llglobal, bytes as c_uint);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_comdat(llmod: &Module, llglobal: &Value, name: &str) {
|
||||
unsafe {
|
||||
LLVMRustSetComdat(llmod, llglobal, name.as_ptr().cast(), name.len());
|
||||
}
|
||||
}
|
||||
|
||||
/// Safe wrapper around `LLVMGetParam`, because segfaults are no fun.
|
||||
pub fn get_param(llfn: &Value, index: c_uint) -> &Value {
|
||||
unsafe {
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
use rustc_middle::mir::coverage::{CounterValueReference, MappedExpressionIndex};
|
||||
|
||||
/// Aligns with [llvm::coverage::Counter::CounterKind](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L91)
|
||||
/// Aligns with [llvm::coverage::Counter::CounterKind](https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L206-L222)
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
#[repr(C)]
|
||||
pub enum CounterKind {
|
||||
@ -17,7 +17,7 @@ pub enum CounterKind {
|
||||
/// `instrprof.increment()`)
|
||||
/// * For `CounterKind::Expression`, `id` is the index into the coverage map's array of
|
||||
/// counter expressions.
|
||||
/// Aligns with [llvm::coverage::Counter](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L98-L99)
|
||||
/// Aligns with [llvm::coverage::Counter](https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L99-L100)
|
||||
/// Important: The Rust struct layout (order and types of fields) must match its C++ counterpart.
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
#[repr(C)]
|
||||
@ -41,7 +41,7 @@ impl Counter {
|
||||
}
|
||||
}
|
||||
|
||||
/// Aligns with [llvm::coverage::CounterExpression::ExprKind](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L146)
|
||||
/// Aligns with [llvm::coverage::CounterExpression::ExprKind](https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L147)
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
#[repr(C)]
|
||||
pub enum ExprKind {
|
||||
@ -49,7 +49,7 @@ pub enum ExprKind {
|
||||
Add = 1,
|
||||
}
|
||||
|
||||
/// Aligns with [llvm::coverage::CounterExpression](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L147-L148)
|
||||
/// Aligns with [llvm::coverage::CounterExpression](https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L148-L149)
|
||||
/// Important: The Rust struct layout (order and types of fields) must match its C++
|
||||
/// counterpart.
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
|
||||
@ -3,7 +3,6 @@
|
||||
#include "llvm/ProfileData/Coverage/CoverageMappingWriter.h"
|
||||
#include "llvm/ProfileData/InstrProf.h"
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/Support/LEB128.h"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
@ -13,15 +12,14 @@ extern "C" void LLVMRustCoverageWriteFilenamesSectionToBuffer(
|
||||
const char* const Filenames[],
|
||||
size_t FilenamesLen,
|
||||
RustStringRef BufferOut) {
|
||||
// LLVM 11's CoverageFilenamesSectionWriter uses its new `Version4` format,
|
||||
// so we're manually writing the `Version3` format ourselves.
|
||||
RawRustStringOstream OS(BufferOut);
|
||||
encodeULEB128(FilenamesLen, OS);
|
||||
SmallVector<StringRef,32> FilenameRefs;
|
||||
for (size_t i = 0; i < FilenamesLen; i++) {
|
||||
StringRef Filename(Filenames[i]);
|
||||
encodeULEB128(Filename.size(), OS);
|
||||
OS << Filename;
|
||||
FilenameRefs.push_back(StringRef(Filenames[i]));
|
||||
}
|
||||
auto FilenamesWriter = coverage::CoverageFilenamesSectionWriter(
|
||||
makeArrayRef(FilenameRefs));
|
||||
RawRustStringOstream OS(BufferOut);
|
||||
FilenamesWriter.write(OS);
|
||||
}
|
||||
|
||||
extern "C" void LLVMRustCoverageWriteMappingToBuffer(
|
||||
@ -45,20 +43,40 @@ extern "C" LLVMValueRef LLVMRustCoverageCreatePGOFuncNameVar(LLVMValueRef F, con
|
||||
return wrap(createPGOFuncNameVar(*cast<Function>(unwrap(F)), FuncNameRef));
|
||||
}
|
||||
|
||||
extern "C" uint64_t LLVMRustCoverageComputeHash(const char *Name) {
|
||||
StringRef NameRef(Name);
|
||||
return IndexedInstrProf::ComputeHash(NameRef);
|
||||
extern "C" uint64_t LLVMRustCoverageHashCString(const char *StrVal) {
|
||||
StringRef StrRef(StrVal);
|
||||
return IndexedInstrProf::ComputeHash(StrRef);
|
||||
}
|
||||
|
||||
extern "C" void LLVMRustCoverageWriteSectionNameToString(LLVMModuleRef M,
|
||||
RustStringRef Str) {
|
||||
extern "C" uint64_t LLVMRustCoverageHashByteArray(
|
||||
const char *Bytes,
|
||||
unsigned NumBytes) {
|
||||
StringRef StrRef(Bytes, NumBytes);
|
||||
return IndexedInstrProf::ComputeHash(StrRef);
|
||||
}
|
||||
|
||||
static void WriteSectionNameToString(LLVMModuleRef M,
|
||||
InstrProfSectKind SK,
|
||||
RustStringRef Str) {
|
||||
Triple TargetTriple(unwrap(M)->getTargetTriple());
|
||||
auto name = getInstrProfSectionName(IPSK_covmap,
|
||||
TargetTriple.getObjectFormat());
|
||||
auto name = getInstrProfSectionName(SK, TargetTriple.getObjectFormat());
|
||||
RawRustStringOstream OS(Str);
|
||||
OS << name;
|
||||
}
|
||||
|
||||
extern "C" void LLVMRustCoverageWriteMapSectionNameToString(LLVMModuleRef M,
|
||||
RustStringRef Str) {
|
||||
WriteSectionNameToString(M, IPSK_covmap, Str);
|
||||
}
|
||||
|
||||
extern "C" void LLVMRustCoverageWriteFuncSectionNameToString(LLVMModuleRef M,
|
||||
RustStringRef Str) {
|
||||
#if LLVM_VERSION_GE(11, 0)
|
||||
WriteSectionNameToString(M, IPSK_covfun, Str);
|
||||
// else do nothing; the `Version` check will abort codegen on the Rust side
|
||||
#endif
|
||||
}
|
||||
|
||||
extern "C" void LLVMRustCoverageWriteMappingVarNameToString(RustStringRef Str) {
|
||||
auto name = getCoverageMappingVarName();
|
||||
RawRustStringOstream OS(Str);
|
||||
@ -66,5 +84,9 @@ extern "C" void LLVMRustCoverageWriteMappingVarNameToString(RustStringRef Str) {
|
||||
}
|
||||
|
||||
extern "C" uint32_t LLVMRustCoverageMappingVersion() {
|
||||
#if LLVM_VERSION_GE(11, 0)
|
||||
return coverage::CovMapVersion::Version4;
|
||||
#else
|
||||
return coverage::CovMapVersion::Version3;
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -1462,7 +1462,7 @@ extern "C" void LLVMRustSetComdat(LLVMModuleRef M, LLVMValueRef V,
|
||||
const char *Name, size_t NameLen) {
|
||||
Triple TargetTriple(unwrap(M)->getTargetTriple());
|
||||
GlobalObject *GV = unwrap<GlobalObject>(V);
|
||||
if (!TargetTriple.isOSBinFormatMachO()) {
|
||||
if (TargetTriple.supportsCOMDAT()) {
|
||||
StringRef NameRef(Name, NameLen);
|
||||
GV->setComdat(unwrap(M)->getOrInsertComdat(NameRef));
|
||||
}
|
||||
|
||||
@ -21,9 +21,9 @@ rustc_index::newtype_index! {
|
||||
impl ExpressionOperandId {
|
||||
/// An expression operand for a "zero counter", as described in the following references:
|
||||
///
|
||||
/// * <https://github.com/rust-lang/llvm-project/blob/llvmorg-8.0.0/llvm/docs/CoverageMappingFormat.rst#counter>
|
||||
/// * <https://github.com/rust-lang/llvm-project/blob/llvmorg-8.0.0/llvm/docs/CoverageMappingFormat.rst#tag>
|
||||
/// * <https://github.com/rust-lang/llvm-project/blob/llvmorg-8.0.0/llvm/docs/CoverageMappingFormat.rst#counter-expressions>
|
||||
/// * <https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/docs/CoverageMappingFormat.rst#counter>
|
||||
/// * <https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/docs/CoverageMappingFormat.rst#tag>
|
||||
/// * <https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/docs/CoverageMappingFormat.rst#counter-expressions>
|
||||
///
|
||||
/// This operand can be used to count two or more separate code regions with a single counter,
|
||||
/// if they run sequentially with no branches, by injecting the `Counter` in a `BasicBlock` for
|
||||
|
||||
@ -12,10 +12,12 @@ ifeq ($(UNAME),Darwin)
|
||||
INSTR_PROF_DATA_SUFFIX=,regular,live_support
|
||||
DATA_SECTION_PREFIX=__DATA,
|
||||
LLVM_COV_SECTION_PREFIX=__LLVM_COV,
|
||||
COMDAT_IF_SUPPORTED=
|
||||
else
|
||||
INSTR_PROF_DATA_SUFFIX=
|
||||
DATA_SECTION_PREFIX=
|
||||
LLVM_COV_SECTION_PREFIX=
|
||||
COMDAT_IF_SUPPORTED=, comdat
|
||||
endif
|
||||
|
||||
ifeq ($(LINK_DEAD_CODE),yes)
|
||||
@ -29,28 +31,39 @@ ifdef IS_WINDOWS
|
||||
-check-prefixes=CHECK,WINDOWS \
|
||||
-DPRIVATE_GLOBAL='internal global' \
|
||||
-DDEFINE_INTERNAL='$(DEFINE_INTERNAL)' \
|
||||
-DCOMDAT_IF_SUPPORTED='$(COMDAT_IF_SUPPORTED)' \
|
||||
-DINSTR_PROF_DATA='.lprfd$$M' \
|
||||
-DINSTR_PROF_NAME='.lprfn$$M' \
|
||||
-DINSTR_PROF_CNTS='.lprfc$$M' \
|
||||
-DINSTR_PROF_VALS='.lprfv$$M' \
|
||||
-DINSTR_PROF_VNODES='.lprfnd$$M' \
|
||||
-DINSTR_PROF_COVMAP='.lcovmap$$M' \
|
||||
-DINSTR_PROF_COVFUN='.lcovfun$$M' \
|
||||
-DINSTR_PROF_ORDERFILE='.lorderfile$$M'
|
||||
else
|
||||
LLVM_FILECHECK_OPTIONS=\
|
||||
-check-prefixes=CHECK \
|
||||
-DPRIVATE_GLOBAL='private global' \
|
||||
-DDEFINE_INTERNAL='$(DEFINE_INTERNAL)' \
|
||||
-DCOMDAT_IF_SUPPORTED='$(COMDAT_IF_SUPPORTED)' \
|
||||
-DINSTR_PROF_DATA='$(DATA_SECTION_PREFIX)__llvm_prf_data$(INSTR_PROF_DATA_SUFFIX)' \
|
||||
-DINSTR_PROF_NAME='$(DATA_SECTION_PREFIX)__llvm_prf_names' \
|
||||
-DINSTR_PROF_CNTS='$(DATA_SECTION_PREFIX)__llvm_prf_cnts' \
|
||||
-DINSTR_PROF_VALS='$(DATA_SECTION_PREFIX)__llvm_prf_vals' \
|
||||
-DINSTR_PROF_VNODES='$(DATA_SECTION_PREFIX)__llvm_prf_vnds' \
|
||||
-DINSTR_PROF_COVMAP='$(LLVM_COV_SECTION_PREFIX)__llvm_covmap' \
|
||||
-DINSTR_PROF_COVFUN='$(LLVM_COV_SECTION_PREFIX)__llvm_covfun' \
|
||||
-DINSTR_PROF_ORDERFILE='$(DATA_SECTION_PREFIX)__llvm_orderfile'
|
||||
endif
|
||||
|
||||
ifeq ($(LLVM_VERSION_11_PLUS),true)
|
||||
all: test_llvm_ir
|
||||
else
|
||||
$(info Rust option `-Z instrument-coverage` requires LLVM 11 or higher. Test skipped.)
|
||||
all:
|
||||
endif
|
||||
|
||||
test_llvm_ir:
|
||||
# Compile the test program with non-experimental coverage instrumentation, and generate LLVM IR
|
||||
#
|
||||
# Note: `-Clink-dead-code=no` disables the option, needed because the option is automatically
|
||||
@ -62,4 +75,5 @@ all:
|
||||
-Clink-dead-code=$(LINK_DEAD_CODE) \
|
||||
--emit=llvm-ir
|
||||
|
||||
cat "$(TMPDIR)"/testprog.ll | "$(LLVM_FILECHECK)" $(BASEDIR)/filecheck.testprog.txt $(LLVM_FILECHECK_OPTIONS)
|
||||
cat "$(TMPDIR)"/testprog.ll | \
|
||||
"$(LLVM_FILECHECK)" $(BASEDIR)/filecheck.testprog.txt $(LLVM_FILECHECK_OPTIONS)
|
||||
|
||||
@ -3,7 +3,10 @@
|
||||
|
||||
WINDOWS: $__llvm_profile_runtime_user = comdat any
|
||||
|
||||
CHECK: @__llvm_coverage_mapping = internal constant
|
||||
CHECK: @__covrec_{{[A-F0-9]+}}u = linkonce_odr hidden constant
|
||||
CHECK-SAME: section "[[INSTR_PROF_COVFUN]]"[[COMDAT_IF_SUPPORTED]], align 8
|
||||
|
||||
CHECK: @__llvm_coverage_mapping = private constant
|
||||
CHECK-SAME: section "[[INSTR_PROF_COVMAP]]", align 8
|
||||
|
||||
WINDOWS: @__llvm_profile_runtime = external global i32
|
||||
|
||||
@ -18,7 +18,10 @@ SOURCEDIR=../coverage
|
||||
# `llvm/release_debuginfo`. Note that some CI builds disable debug assertions (by setting
|
||||
# `NO_LLVM_ASSERTIONS=1`), so it is not OK to fail the test, but `bless`ed test results cannot be
|
||||
# generated without debug assertions.
|
||||
LLVM_COV_DEBUG := $(shell "$(LLVM_BIN_DIR)"/llvm-cov show --debug 2>&1 | grep -q "Unknown command line argument '--debug'"; echo $$?)
|
||||
LLVM_COV_DEBUG := $(shell \
|
||||
"$(LLVM_BIN_DIR)"/llvm-cov show --debug 2>&1 | \
|
||||
grep -q "Unknown command line argument '--debug'"; \
|
||||
echo $$?)
|
||||
ifeq ($(LLVM_COV_DEBUG), 1)
|
||||
DEBUG_FLAG=--debug
|
||||
endif
|
||||
@ -30,7 +33,12 @@ ifdef RUSTC_BLESS_TEST
|
||||
DEBUG_FLAG=--debug
|
||||
endif
|
||||
|
||||
ifeq ($(LLVM_VERSION_11_PLUS),true)
|
||||
all: $(patsubst $(SOURCEDIR)/%.rs,%,$(wildcard $(SOURCEDIR)/*.rs))
|
||||
else
|
||||
$(info Rust option `-Z instrument-coverage` requires LLVM 11 or higher. Test skipped.)
|
||||
all:
|
||||
endif
|
||||
|
||||
# Ensure there are no `expected` results for tests that may have been removed or renamed
|
||||
.PHONY: clear_expected_if_blessed
|
||||
|
||||
@ -24,7 +24,12 @@ For revisions in Pull Requests (PR):
|
||||
endef
|
||||
export SPANVIEW_HEADER
|
||||
|
||||
ifeq ($(LLVM_VERSION_11_PLUS),true)
|
||||
all: $(patsubst $(SOURCEDIR)/%.rs,%,$(wildcard $(SOURCEDIR)/*.rs))
|
||||
else
|
||||
$(info Rust option `-Z instrument-coverage` requires LLVM 11 or higher. Test skipped.)
|
||||
all:
|
||||
endif
|
||||
|
||||
# Ensure there are no `expected` results for tests that may have been removed or renamed
|
||||
.PHONY: clear_expected_if_blessed
|
||||
|
||||
@ -38,6 +38,13 @@ endif
|
||||
|
||||
UNAME = $(shell uname)
|
||||
|
||||
# Rust option `-Z instrument-coverage` uses LLVM Coverage Mapping Format version 4,
|
||||
# which requires LLVM 11 or greater.
|
||||
LLVM_VERSION_11_PLUS := $(shell \
|
||||
LLVM_VERSION=$$("$(LLVM_BIN_DIR)"/llvm-config --version) && \
|
||||
LLVM_VERSION_MAJOR=$${LLVM_VERSION/.*/} && \
|
||||
[ $$LLVM_VERSION_MAJOR -ge 11 ] && echo true || echo false)
|
||||
|
||||
# FIXME(richkadel): Can any of the features tested by `run-make-fulldeps/coverage-*` tests be tested
|
||||
# just as completely by more focused unit tests of the code logic itself, to reduce the number of
|
||||
# test result files generated and maintained, and to help identify specific test failures and root
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user