coverage: Tidy up coverage-specific FFI functions

Author: Zalathar

compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs

@@ -2,29 +2,27 @@
 
 use std::ffi::CString;
 
-use libc::c_uint;
-
 usecrate::common::AsCCharPtr;
 usecrate::coverageinfo::ffi;
 usecrate::llvm;
 
 pub(crate)fncovmap_var_name() -> CString{
 CString::new(llvm::build_byte_buffer(|s| unsafe{
- llvm::LLVMRustCoverageWriteMappingVarNameToString(s);
+ llvm::LLVMRustCoverageWriteCovmapVarNameToString(s);
 }))
 .expect("covmap variable name should not contain NUL")
 }
 
 pub(crate)fncovmap_section_name(llmod:&llvm::Module) -> CString{
 CString::new(llvm::build_byte_buffer(|s| unsafe{
- llvm::LLVMRustCoverageWriteMapSectionNameToString(llmod, s);
+ llvm::LLVMRustCoverageWriteCovmapSectionNameToString(llmod, s);
 }))
 .expect("covmap section name should not contain NUL")
 }
 
 pub(crate)fncovfun_section_name(llmod:&llvm::Module) -> CString{
 CString::new(llvm::build_byte_buffer(|s| unsafe{
- llvm::LLVMRustCoverageWriteFuncSectionNameToString(llmod, s);
+ llvm::LLVMRustCoverageWriteCovfunSectionNameToString(llmod, s);
 }))
 .expect("covfun section name should not contain NUL")
 }
@@ -51,7 +49,7 @@ pub(crate) fn write_filenames_to_buffer<'a>(
 .unzip::<_,_,Vec<_>,Vec<_>>();
 
  llvm::build_byte_buffer(|buffer| unsafe{
- llvm::LLVMRustCoverageWriteFilenamesSectionToBuffer(
+ llvm::LLVMRustCoverageWriteFilenamesToBuffer(
  pointers.as_ptr(),
  pointers.len(),
  lengths.as_ptr(),
@@ -70,19 +68,19 @@ pub(crate) fn write_function_mappings_to_buffer(
 mcdc_decision_regions:&[ffi::MCDCDecisionRegion],
 ) -> Vec<u8>{
  llvm::build_byte_buffer(|buffer| unsafe{
- llvm::LLVMRustCoverageWriteMappingToBuffer(
+ llvm::LLVMRustCoverageWriteFunctionMappingsToBuffer(
  virtual_file_mapping.as_ptr(),
- virtual_file_mapping.len()asc_uint,
+ virtual_file_mapping.len(),
  expressions.as_ptr(),
- expressions.len()asc_uint,
+ expressions.len(),
  code_regions.as_ptr(),
- code_regions.len()asc_uint,
+ code_regions.len(),
  branch_regions.as_ptr(),
- branch_regions.len()asc_uint,
+ branch_regions.len(),
  mcdc_branch_regions.as_ptr(),
- mcdc_branch_regions.len()asc_uint,
+ mcdc_branch_regions.len(),
  mcdc_decision_regions.as_ptr(),
- mcdc_decision_regions.len()asc_uint,
+ mcdc_decision_regions.len(),
  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`,
 /// as required for parts of the LLVM coverage mapping format.
 pub(crate)fnhash_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)

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1790,7 +1790,7 @@ unsafe extern "C" {
 ) -> bool;
 
 #[allow(improper_ctypes)]
-pub(crate)fnLLVMRustCoverageWriteFilenamesSectionToBuffer(
+pub(crate)fnLLVMRustCoverageWriteFilenamesToBuffer(
 Filenames:*const*constc_char,
 FilenamesLen:size_t,
 Lengths:*constsize_t,
@@ -1799,19 +1799,19 @@ unsafe extern "C" {
 );
 
 #[allow(improper_ctypes)]
-pub(crate)fnLLVMRustCoverageWriteMappingToBuffer(
+pub(crate)fnLLVMRustCoverageWriteFunctionMappingsToBuffer(
 VirtualFileMappingIDs:*constc_uint,
-NumVirtualFileMappingIDs:c_uint,
+NumVirtualFileMappingIDs:size_t,
 Expressions:*constcrate::coverageinfo::ffi::CounterExpression,
-NumExpressions:c_uint,
+NumExpressions:size_t,
 CodeRegions:*constcrate::coverageinfo::ffi::CodeRegion,
-NumCodeRegions:c_uint,
+NumCodeRegions:size_t,
 BranchRegions:*constcrate::coverageinfo::ffi::BranchRegion,
-NumBranchRegions:c_uint,
+NumBranchRegions:size_t,
 MCDCBranchRegions:*constcrate::coverageinfo::ffi::MCDCBranchRegion,
-NumMCDCBranchRegions:c_uint,
+NumMCDCBranchRegions:size_t,
 MCDCDecisionRegions:*constcrate::coverageinfo::ffi::MCDCDecisionRegion,
-NumMCDCDecisionRegions:c_uint,
+NumMCDCDecisionRegions:size_t,
 BufferOut:&RustString,
 );
 
@@ -1820,16 +1820,16 @@ unsafe extern "C" {
 FuncName:*constc_char,
 FuncNameLen:size_t,
 ) -> &Value;
-pub(crate)fnLLVMRustCoverageHashByteArray(Bytes:*constc_char,NumBytes:size_t) -> u64;
+pub(crate)fnLLVMRustCoverageHashBytes(Bytes:*constc_char,NumBytes:size_t) -> u64;
 
 #[allow(improper_ctypes)]
-pub(crate)fnLLVMRustCoverageWriteMapSectionNameToString(M:&Module,Str:&RustString);
+pub(crate)fnLLVMRustCoverageWriteCovmapSectionNameToString(M:&Module,OutStr:&RustString);
 
 #[allow(improper_ctypes)]
-pub(crate)fnLLVMRustCoverageWriteFuncSectionNameToString(M:&Module,Str:&RustString);
+pub(crate)fnLLVMRustCoverageWriteCovfunSectionNameToString(M:&Module,OutStr:&RustString);
 
 #[allow(improper_ctypes)]
-pub(crate)fnLLVMRustCoverageWriteMappingVarNameToString(Str:&RustString);
+pub(crate)fnLLVMRustCoverageWriteCovmapVarNameToString(OutStr:&RustString);
 
 pub(crate)fnLLVMRustCoverageMappingVersion() -> u32;
 pubfnLLVMRustDebugMetadataVersion() -> u32;

compiler/rustc_llvm/llvm-wrapper/CoverageMappingWrapper.cpp

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