mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

coverage: Tidy up coverage-specific FFI functions

Browse Source
This commit is contained in:
Zalathar 2024-11-01 21:29:09 +11:00
parent b790e4473c
commit 19d5dc0ed1
3 changed files with 52 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
View File

@ -2,29 +2,27 @@
use std::ffi::CString; use std::ffi::CString;
use libc::c_uint;
use crate::common::AsCCharPtr; use crate::common::AsCCharPtr;
use crate::coverageinfo::ffi; use crate::coverageinfo::ffi;
use crate::llvm; use crate::llvm;
pub(crate) fn covmap_var_name() -> CString { pub(crate) fn covmap_var_name() -> CString {
CString::new(llvm::build_byte_buffer(|s| unsafe { CString::new(llvm::build_byte_buffer(|s| unsafe {
llvm::LLVMRustCoverageWriteMappingVarNameToString(s); llvm::LLVMRustCoverageWriteCovmapVarNameToString(s);
})) }))
.expect("covmap variable name should not contain NUL") .expect("covmap variable name should not contain NUL")
} }
pub(crate) fn covmap_section_name(llmod: &llvm::Module) -> CString { pub(crate) fn covmap_section_name(llmod: &llvm::Module) -> CString {
CString::new(llvm::build_byte_buffer(|s| unsafe { CString::new(llvm::build_byte_buffer(|s| unsafe {
llvm::LLVMRustCoverageWriteMapSectionNameToString(llmod, s); llvm::LLVMRustCoverageWriteCovmapSectionNameToString(llmod, s);
})) }))
.expect("covmap section name should not contain NUL") .expect("covmap section name should not contain NUL")
} }
pub(crate) fn covfun_section_name(llmod: &llvm::Module) -> CString { pub(crate) fn covfun_section_name(llmod: &llvm::Module) -> CString {
CString::new(llvm::build_byte_buffer(|s| unsafe { CString::new(llvm::build_byte_buffer(|s| unsafe {
llvm::LLVMRustCoverageWriteFuncSectionNameToString(llmod, s); llvm::LLVMRustCoverageWriteCovfunSectionNameToString(llmod, s);
})) }))
.expect("covfun section name should not contain NUL") .expect("covfun section name should not contain NUL")
} }
@ -51,7 +49,7 @@ pub(crate) fn write_filenames_to_buffer<'a>(
.unzip::<_, _, Vec<_>, Vec<_>>(); .unzip::<_, _, Vec<_>, Vec<_>>();
llvm::build_byte_buffer(|buffer| unsafe { llvm::build_byte_buffer(|buffer| unsafe {
llvm::LLVMRustCoverageWriteFilenamesSectionToBuffer( llvm::LLVMRustCoverageWriteFilenamesToBuffer(
pointers.as_ptr(), pointers.as_ptr(),
pointers.len(), pointers.len(),
lengths.as_ptr(), lengths.as_ptr(),
@ -70,19 +68,19 @@ pub(crate) fn write_function_mappings_to_buffer(
mcdc_decision_regions: &[ffi::MCDCDecisionRegion], mcdc_decision_regions: &[ffi::MCDCDecisionRegion],
) -> Vec<u8> { ) -> Vec<u8> {
llvm::build_byte_buffer(|buffer| unsafe { llvm::build_byte_buffer(|buffer| unsafe {
llvm::LLVMRustCoverageWriteMappingToBuffer( llvm::LLVMRustCoverageWriteFunctionMappingsToBuffer(
virtual_file_mapping.as_ptr(), virtual_file_mapping.as_ptr(),
virtual_file_mapping.len() as c_uint, virtual_file_mapping.len(),
expressions.as_ptr(), expressions.as_ptr(),
expressions.len() as c_uint, expressions.len(),
code_regions.as_ptr(), code_regions.as_ptr(),
code_regions.len() as c_uint, code_regions.len(),
branch_regions.as_ptr(), branch_regions.as_ptr(),
branch_regions.len() as c_uint, branch_regions.len(),
mcdc_branch_regions.as_ptr(), mcdc_branch_regions.as_ptr(),
mcdc_branch_regions.len() as c_uint, mcdc_branch_regions.len(),
mcdc_decision_regions.as_ptr(), mcdc_decision_regions.as_ptr(),
mcdc_decision_regions.len() as c_uint, mcdc_decision_regions.len(),
buffer, buffer,
) )
}) })
@ -91,7 +89,7 @@ pub(crate) fn write_function_mappings_to_buffer(
/// Hashes some bytes into a 64-bit hash, via LLVM's `IndexedInstrProf::ComputeHash`, /// Hashes some bytes into a 64-bit hash, via LLVM's `IndexedInstrProf::ComputeHash`,
/// as required for parts of the LLVM coverage mapping format. /// as required for parts of the LLVM coverage mapping format.
pub(crate) fn hash_bytes(bytes: &[u8]) -> u64 { pub(crate) fn hash_bytes(bytes: &[u8]) -> u64 {
unsafe { llvm::LLVMRustCoverageHashByteArray(bytes.as_c_char_ptr(), bytes.len()) } unsafe { llvm::LLVMRustCoverageHashBytes(bytes.as_c_char_ptr(), bytes.len()) }
} }
/// Returns LLVM's `coverage::CovMapVersion::CurrentVersion` (CoverageMapping.h) /// Returns LLVM's `coverage::CovMapVersion::CurrentVersion` (CoverageMapping.h)

24
compiler/rustc_codegen_llvm/src/llvm/ffi.rs
View File

@ -1790,7 +1790,7 @@ unsafe extern "C" {
) -> bool; ) -> bool;
#[allow(improper_ctypes)] #[allow(improper_ctypes)]
pub(crate) fn LLVMRustCoverageWriteFilenamesSectionToBuffer( pub(crate) fn LLVMRustCoverageWriteFilenamesToBuffer(
Filenames: *const *const c_char, Filenames: *const *const c_char,
FilenamesLen: size_t, FilenamesLen: size_t,
Lengths: *const size_t, Lengths: *const size_t,
@ -1799,19 +1799,19 @@ unsafe extern "C" {
); );
#[allow(improper_ctypes)] #[allow(improper_ctypes)]
pub(crate) fn LLVMRustCoverageWriteMappingToBuffer( pub(crate) fn LLVMRustCoverageWriteFunctionMappingsToBuffer(
VirtualFileMappingIDs: *const c_uint, VirtualFileMappingIDs: *const c_uint,
NumVirtualFileMappingIDs: c_uint, NumVirtualFileMappingIDs: size_t,
Expressions: *const crate::coverageinfo::ffi::CounterExpression, Expressions: *const crate::coverageinfo::ffi::CounterExpression,
NumExpressions: c_uint, NumExpressions: size_t,
CodeRegions: *const crate::coverageinfo::ffi::CodeRegion, CodeRegions: *const crate::coverageinfo::ffi::CodeRegion,
NumCodeRegions: c_uint, NumCodeRegions: size_t,
BranchRegions: *const crate::coverageinfo::ffi::BranchRegion, BranchRegions: *const crate::coverageinfo::ffi::BranchRegion,
NumBranchRegions: c_uint, NumBranchRegions: size_t,
MCDCBranchRegions: *const crate::coverageinfo::ffi::MCDCBranchRegion, MCDCBranchRegions: *const crate::coverageinfo::ffi::MCDCBranchRegion,
NumMCDCBranchRegions: c_uint, NumMCDCBranchRegions: size_t,
MCDCDecisionRegions: *const crate::coverageinfo::ffi::MCDCDecisionRegion, MCDCDecisionRegions: *const crate::coverageinfo::ffi::MCDCDecisionRegion,
NumMCDCDecisionRegions: c_uint, NumMCDCDecisionRegions: size_t,
BufferOut: &RustString, BufferOut: &RustString,
); );
@ -1820,16 +1820,16 @@ unsafe extern "C" {
FuncName: *const c_char, FuncName: *const c_char,
FuncNameLen: size_t, FuncNameLen: size_t,
) -> &Value; ) -> &Value;
pub(crate) fn LLVMRustCoverageHashByteArray(Bytes: *const c_char, NumBytes: size_t) -> u64; pub(crate) fn LLVMRustCoverageHashBytes(Bytes: *const c_char, NumBytes: size_t) -> u64;
#[allow(improper_ctypes)] #[allow(improper_ctypes)]
pub(crate) fn LLVMRustCoverageWriteMapSectionNameToString(M: &Module, Str: &RustString); pub(crate) fn LLVMRustCoverageWriteCovmapSectionNameToString(M: &Module, OutStr: &RustString);
#[allow(improper_ctypes)] #[allow(improper_ctypes)]
pub(crate) fn LLVMRustCoverageWriteFuncSectionNameToString(M: &Module, Str: &RustString); pub(crate) fn LLVMRustCoverageWriteCovfunSectionNameToString(M: &Module, OutStr: &RustString);
#[allow(improper_ctypes)] #[allow(improper_ctypes)]
pub(crate) fn LLVMRustCoverageWriteMappingVarNameToString(Str: &RustString); pub(crate) fn LLVMRustCoverageWriteCovmapVarNameToString(OutStr: &RustString);
pub(crate) fn LLVMRustCoverageMappingVersion() -> u32; pub(crate) fn LLVMRustCoverageMappingVersion() -> u32;
pub fn LLVMRustDebugMetadataVersion() -> u32; pub fn LLVMRustDebugMetadataVersion() -> u32;

54
compiler/rustc_llvm/llvm-wrapper/CoverageMappingWrapper.cpp
View File

@ -123,13 +123,13 @@ fromRust(LLVMRustCounterExprKind Kind) {
report_fatal_error("Bad LLVMRustCounterExprKind!"); report_fatal_error("Bad LLVMRustCounterExprKind!");
} }
extern "C" void LLVMRustCoverageWriteFilenamesSectionToBuffer( extern "C" void LLVMRustCoverageWriteFilenamesToBuffer(
const char *const Filenames[], size_t FilenamesLen, // String start pointers const char *const Filenames[], size_t FilenamesLen, // String start pointers
const size_t *const Lengths, size_t LengthsLen, // Corresponding lengths const size_t *const Lengths, size_t LengthsLen, // Corresponding lengths
RustStringRef BufferOut) { RustStringRef BufferOut) {
if (FilenamesLen != LengthsLen) { if (FilenamesLen != LengthsLen) {
report_fatal_error( report_fatal_error(
"Mismatched lengths in LLVMRustCoverageWriteFilenamesSectionToBuffer"); "Mismatched lengths in LLVMRustCoverageWriteFilenamesToBuffer");
} }
SmallVector<std::string, 32> FilenameRefs; SmallVector<std::string, 32> FilenameRefs;
@ -143,16 +143,15 @@ extern "C" void LLVMRustCoverageWriteFilenamesSectionToBuffer(
FilenamesWriter.write(OS); FilenamesWriter.write(OS);
} }
extern "C" void LLVMRustCoverageWriteMappingToBuffer( extern "C" void LLVMRustCoverageWriteFunctionMappingsToBuffer(
const unsigned *VirtualFileMappingIDs, unsigned NumVirtualFileMappingIDs, const unsigned *VirtualFileMappingIDs, size_t NumVirtualFileMappingIDs,
const LLVMRustCounterExpression *RustExpressions, unsigned NumExpressions, const LLVMRustCounterExpression *RustExpressions, size_t NumExpressions,
const LLVMRustCoverageCodeRegion *CodeRegions, unsigned NumCodeRegions, const LLVMRustCoverageCodeRegion *CodeRegions, size_t NumCodeRegions,
const LLVMRustCoverageBranchRegion *BranchRegions, const LLVMRustCoverageBranchRegion *BranchRegions, size_t NumBranchRegions,
unsigned NumBranchRegions,
const LLVMRustCoverageMCDCBranchRegion *MCDCBranchRegions, const LLVMRustCoverageMCDCBranchRegion *MCDCBranchRegions,
unsigned NumMCDCBranchRegions, size_t NumMCDCBranchRegions,
const LLVMRustCoverageMCDCDecisionRegion *MCDCDecisionRegions, const LLVMRustCoverageMCDCDecisionRegion *MCDCDecisionRegions,
unsigned NumMCDCDecisionRegions, RustStringRef BufferOut) { size_t NumMCDCDecisionRegions, RustStringRef BufferOut) {
// Convert from FFI representation to LLVM representation. // Convert from FFI representation to LLVM representation.
// Expressions: // Expressions:
@ -219,34 +218,37 @@ LLVMRustCoverageCreatePGOFuncNameVar(LLVMValueRef F, const char *FuncName,
return wrap(createPGOFuncNameVar(*cast<Function>(unwrap(F)), FuncNameRef)); return wrap(createPGOFuncNameVar(*cast<Function>(unwrap(F)), FuncNameRef));
} }
extern "C" uint64_t LLVMRustCoverageHashByteArray(const char *Bytes, extern "C" uint64_t LLVMRustCoverageHashBytes(const char *Bytes,
size_t NumBytes) { size_t NumBytes) {
auto StrRef = StringRef(Bytes, NumBytes); return IndexedInstrProf::ComputeHash(StringRef(Bytes, NumBytes));
return IndexedInstrProf::ComputeHash(StrRef);
} }
static void WriteSectionNameToString(LLVMModuleRef M, InstrProfSectKind SK, // Private helper function for getting the covmap and covfun section names.
RustStringRef Str) { static void writeInstrProfSectionNameToString(LLVMModuleRef M,
InstrProfSectKind SectKind,
RustStringRef OutStr) {
auto TargetTriple = Triple(unwrap(M)->getTargetTriple()); auto TargetTriple = Triple(unwrap(M)->getTargetTriple());
auto name = getInstrProfSectionName(SK, TargetTriple.getObjectFormat()); auto name = getInstrProfSectionName(SectKind, TargetTriple.getObjectFormat());
auto OS = RawRustStringOstream(Str); auto OS = RawRustStringOstream(OutStr);
OS << name; OS << name;
} }
extern "C" void LLVMRustCoverageWriteMapSectionNameToString(LLVMModuleRef M, extern "C" void
RustStringRef Str) { LLVMRustCoverageWriteCovmapSectionNameToString(LLVMModuleRef M,
WriteSectionNameToString(M, IPSK_covmap, Str); RustStringRef OutStr) {
writeInstrProfSectionNameToString(M, IPSK_covmap, OutStr);
} }
extern "C" void extern "C" void
LLVMRustCoverageWriteFuncSectionNameToString(LLVMModuleRef M, LLVMRustCoverageWriteCovfunSectionNameToString(LLVMModuleRef M,
RustStringRef Str) { RustStringRef OutStr) {
WriteSectionNameToString(M, IPSK_covfun, Str); writeInstrProfSectionNameToString(M, IPSK_covfun, OutStr);
} }
extern "C" void LLVMRustCoverageWriteMappingVarNameToString(RustStringRef Str) { extern "C" void
LLVMRustCoverageWriteCovmapVarNameToString(RustStringRef OutStr) {
auto name = getCoverageMappingVarName(); auto name = getCoverageMappingVarName();
auto OS = RawRustStringOstream(Str); auto OS = RawRustStringOstream(OutStr);
OS << name; OS << name;
} }