Skip to content

Commit 6295686

Browse files
borsbors
committed
Auto merge of #132762 - Zalathar:rollup-qfgz165, r=Zalathar
Rollup of 5 pull requests Successful merges: - #132161 ([StableMIR] A few fixes to pretty printing) - #132389 (coverage: Simplify parts of coverage graph creation) - #132452 (coverage: Extract safe FFI wrapper functions to `llvm_cov`) - #132590 (Simplify FFI calls for `-Ztime-llvm-passes` and `-Zprint-codegen-stats`) - #132738 (Initialize channel `Block`s directly on the heap) r? `@ghost` `@rustbot` modify labels: rollup
2 parents 78bb5ee + 4b904ce commit 6295686

File tree

14 files changed

+695
-338
lines changed

14 files changed

+695
-338
lines changed

‎compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs

+100
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,100 @@
1+
//! Safe wrappers for coverage-specific FFI functions.
2+
3+
use std::ffi::CString;
4+
5+
use crate::common::AsCCharPtr;
6+
use crate::coverageinfo::ffi;
7+
use crate::llvm;
8+
9+
pub(crate) fn covmap_var_name() -> CString {
10+
CString::new(llvm::build_byte_buffer(|s| unsafe {
11+
llvm::LLVMRustCoverageWriteCovmapVarNameToString(s);
12+
}))
13+
.expect("covmap variable name should not contain NUL")
14+
}
15+
16+
pub(crate) fn covmap_section_name(llmod: &llvm::Module) -> CString {
17+
CString::new(llvm::build_byte_buffer(|s| unsafe {
18+
llvm::LLVMRustCoverageWriteCovmapSectionNameToString(llmod, s);
19+
}))
20+
.expect("covmap section name should not contain NUL")
21+
}
22+
23+
pub(crate) fn covfun_section_name(llmod: &llvm::Module) -> CString {
24+
CString::new(llvm::build_byte_buffer(|s| unsafe {
25+
llvm::LLVMRustCoverageWriteCovfunSectionNameToString(llmod, s);
26+
}))
27+
.expect("covfun section name should not contain NUL")
28+
}
29+
30+
pub(crate) fn create_pgo_func_name_var<'ll>(
31+
llfn: &'ll llvm::Value,
32+
mangled_fn_name: &str,
33+
) -> &'ll llvm::Value {
34+
unsafe {
35+
llvm::LLVMRustCoverageCreatePGOFuncNameVar(
36+
llfn,
37+
mangled_fn_name.as_c_char_ptr(),
38+
mangled_fn_name.len(),
39+
)
40+
}
41+
}
42+
43+
pub(crate) fn write_filenames_to_buffer<'a>(
44+
filenames: impl IntoIterator<Item = &'a str>,
45+
) -> Vec<u8> {
46+
let (pointers, lengths) = filenames
47+
.into_iter()
48+
.map(|s: &str| (s.as_c_char_ptr(), s.len()))
49+
.unzip::<_, _, Vec<_>, Vec<_>>();
50+
51+
llvm::build_byte_buffer(|buffer| unsafe {
52+
llvm::LLVMRustCoverageWriteFilenamesToBuffer(
53+
pointers.as_ptr(),
54+
pointers.len(),
55+
lengths.as_ptr(),
56+
lengths.len(),
57+
buffer,
58+
);
59+
})
60+
}
61+
62+
pub(crate) fn write_function_mappings_to_buffer(
63+
virtual_file_mapping: &[u32],
64+
expressions: &[ffi::CounterExpression],
65+
code_regions: &[ffi::CodeRegion],
66+
branch_regions: &[ffi::BranchRegion],
67+
mcdc_branch_regions: &[ffi::MCDCBranchRegion],
68+
mcdc_decision_regions: &[ffi::MCDCDecisionRegion],
69+
) -> Vec<u8> {
70+
llvm::build_byte_buffer(|buffer| unsafe {
71+
llvm::LLVMRustCoverageWriteFunctionMappingsToBuffer(
72+
virtual_file_mapping.as_ptr(),
73+
virtual_file_mapping.len(),
74+
expressions.as_ptr(),
75+
expressions.len(),
76+
code_regions.as_ptr(),
77+
code_regions.len(),
78+
branch_regions.as_ptr(),
79+
branch_regions.len(),
80+
mcdc_branch_regions.as_ptr(),
81+
mcdc_branch_regions.len(),
82+
mcdc_decision_regions.as_ptr(),
83+
mcdc_decision_regions.len(),
84+
buffer,
85+
)
86+
})
87+
}
88+
89+
/// Hashes some bytes into a 64-bit hash, via LLVM's `IndexedInstrProf::ComputeHash`,
90+
/// as required for parts of the LLVM coverage mapping format.
91+
pub(crate) fn hash_bytes(bytes: &[u8]) -> u64 {
92+
unsafe { llvm::LLVMRustCoverageHashBytes(bytes.as_c_char_ptr(), bytes.len()) }
93+
}
94+
95+
/// Returns LLVM's `coverage::CovMapVersion::CurrentVersion` (CoverageMapping.h)
96+
/// as a raw numeric value. For historical reasons, the numeric value is 1 less
97+
/// than the number in the version's name, so `Version7` is actually `6u32`.
98+
pub(crate) fn mapping_version() -> u32 {
99+
unsafe { llvm::LLVMRustCoverageMappingVersion() }
100+
}

‎compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs

+20-37
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
use std::ffi::CString;
2+
use std::iter;
23

34
use itertools::Itertools as _;
45
use rustc_abi::Align;
@@ -17,9 +18,9 @@ use rustc_target::spec::HasTargetSpec;
1718
use tracing::debug;
1819

1920
use crate::common::CodegenCx;
20-
use crate::coverageinfo::ffi;
2121
use crate::coverageinfo::map_data::{FunctionCoverage, FunctionCoverageCollector};
22-
use crate::{coverageinfo, llvm};
22+
use crate::coverageinfo::{ffi, llvm_cov};
23+
use crate::llvm;
2324

2425
/// Generates and exports the coverage map, which is embedded in special
2526
/// linker sections in the final binary.
@@ -33,7 +34,7 @@ pub(crate) fn finalize(cx: &CodegenCx<'_, '_>) {
3334
// agrees with our Rust-side code. Expected versions (encoded as n-1) are:
3435
// - `CovMapVersion::Version7` (6) used by LLVM 18-19
3536
let covmap_version = {
36-
let llvm_covmap_version = coverageinfo::mapping_version();
37+
let llvm_covmap_version = llvm_cov::mapping_version();
3738
let expected_versions = 6..=6;
3839
assert!(
3940
expected_versions.contains(&llvm_covmap_version),
@@ -78,7 +79,7 @@ pub(crate) fn finalize(cx: &CodegenCx<'_, '_>) {
7879

7980
let filenames_size = filenames_buffer.len();
8081
let filenames_val = cx.const_bytes(&filenames_buffer);
81-
let filenames_ref = coverageinfo::hash_bytes(&filenames_buffer);
82+
let filenames_ref = llvm_cov::hash_bytes(&filenames_buffer);
8283

8384
// Generate the coverage map header, which contains the filenames used by
8485
// this CGU's coverage mappings, and store it in a well-known global.
@@ -187,13 +188,10 @@ impl GlobalFileTable {
187188
.for_scope(tcx.sess, RemapPathScopeComponents::MACRO)
188189
.to_string_lossy();
189190

190-
llvm::build_byte_buffer(|buffer| {
191-
coverageinfo::write_filenames_section_to_buffer(
192-
// Insert the working dir at index 0, before the other filenames.
193-
std::iter::once(working_dir).chain(self.raw_file_table.iter().map(Symbol::as_str)),
194-
buffer,
195-
);
196-
})
191+
// Insert the working dir at index 0, before the other filenames.
192+
let filenames =
193+
iter::once(working_dir).chain(self.raw_file_table.iter().map(Symbol::as_str));
194+
llvm_cov::write_filenames_to_buffer(filenames)
197195
}
198196
}
199197

@@ -296,17 +294,14 @@ fn encode_mappings_for_function(
296294
}
297295

298296
// Encode the function's coverage mappings into a buffer.
299-
llvm::build_byte_buffer(|buffer| {
300-
coverageinfo::write_mapping_to_buffer(
301-
virtual_file_mapping.into_vec(),
302-
expressions,
303-
&code_regions,
304-
&branch_regions,
305-
&mcdc_branch_regions,
306-
&mcdc_decision_regions,
307-
buffer,
308-
);
309-
})
297+
llvm_cov::write_function_mappings_to_buffer(
298+
&virtual_file_mapping.into_vec(),
299+
&expressions,
300+
&code_regions,
301+
&branch_regions,
302+
&mcdc_branch_regions,
303+
&mcdc_decision_regions,
304+
)
310305
}
311306

312307
/// Generates the contents of the covmap record for this CGU, which mostly
@@ -335,23 +330,11 @@ fn generate_covmap_record<'ll>(
335330
let covmap_data =
336331
cx.const_struct(&[cov_data_header_val, filenames_val], /*packed=*/ false);
337332

338-
let covmap_var_name = CString::new(llvm::build_byte_buffer(|s| unsafe {
339-
llvm::LLVMRustCoverageWriteMappingVarNameToString(s);
340-
}))
341-
.unwrap();
342-
debug!("covmap var name: {:?}", covmap_var_name);
343-
344-
let covmap_section_name = CString::new(llvm::build_byte_buffer(|s| unsafe {
345-
llvm::LLVMRustCoverageWriteMapSectionNameToString(cx.llmod, s);
346-
}))
347-
.expect("covmap section name should not contain NUL");
348-
debug!("covmap section name: {:?}", covmap_section_name);
349-
350-
let llglobal = llvm::add_global(cx.llmod, cx.val_ty(covmap_data), &covmap_var_name);
333+
let llglobal = llvm::add_global(cx.llmod, cx.val_ty(covmap_data), &llvm_cov::covmap_var_name());
351334
llvm::set_initializer(llglobal, covmap_data);
352335
llvm::set_global_constant(llglobal, true);
353336
llvm::set_linkage(llglobal, llvm::Linkage::PrivateLinkage);
354-
llvm::set_section(llglobal, &covmap_section_name);
337+
llvm::set_section(llglobal, &llvm_cov::covmap_section_name(cx.llmod));
355338
// LLVM's coverage mapping format specifies 8-byte alignment for items in this section.
356339
// <https://llvm.org/docs/CoverageMappingFormat.html>
357340
llvm::set_alignment(llglobal, Align::EIGHT);
@@ -373,7 +356,7 @@ fn generate_covfun_record(
373356
let coverage_mapping_size = coverage_mapping_buffer.len();
374357
let coverage_mapping_val = cx.const_bytes(&coverage_mapping_buffer);
375358

376-
let func_name_hash = coverageinfo::hash_bytes(mangled_function_name.as_bytes());
359+
let func_name_hash = llvm_cov::hash_bytes(mangled_function_name.as_bytes());
377360
let func_name_hash_val = cx.const_u64(func_name_hash);
378361
let coverage_mapping_size_val = cx.const_u32(coverage_mapping_size as u32);
379362
let source_hash_val = cx.const_u64(source_hash);

‎compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs

+10-89
Original file line numberDiff line numberDiff line change
@@ -1,24 +1,23 @@
11
use std::cell::{OnceCell, RefCell};
22
use std::ffi::{CStr, CString};
33

4-
use libc::c_uint;
54
use rustc_abi::Size;
65
use rustc_codegen_ssa::traits::{
76
BuilderMethods, ConstCodegenMethods, CoverageInfoBuilderMethods, MiscCodegenMethods,
87
};
98
use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
10-
use rustc_llvm::RustString;
119
use rustc_middle::mir::coverage::CoverageKind;
1210
use rustc_middle::ty::Instance;
1311
use rustc_middle::ty::layout::HasTyCtxt;
1412
use tracing::{debug, instrument};
1513

1614
use crate::builder::Builder;
17-
use crate::common::{AsCCharPtr, CodegenCx};
15+
use crate::common::CodegenCx;
1816
use crate::coverageinfo::map_data::FunctionCoverageCollector;
1917
use crate::llvm;
2018

2119
pub(crate) mod ffi;
20+
mod llvm_cov;
2221
pub(crate) mod map_data;
2322
mod mapgen;
2423

@@ -80,12 +79,9 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
8079
/// - `__LLVM_COV,__llvm_covfun` on macOS (includes `__LLVM_COV,` segment prefix)
8180
/// - `.lcovfun$M` on Windows (includes `$M` sorting suffix)
8281
fn covfun_section_name(&self) -> &CStr {
83-
self.coverage_cx().covfun_section_name.get_or_init(|| {
84-
CString::new(llvm::build_byte_buffer(|s| unsafe {
85-
llvm::LLVMRustCoverageWriteFuncSectionNameToString(self.llmod, s);
86-
}))
87-
.expect("covfun section name should not contain NUL")
88-
})
82+
self.coverage_cx()
83+
.covfun_section_name
84+
.get_or_init(|| llvm_cov::covfun_section_name(self.llmod))
8985
}
9086

9187
/// For LLVM codegen, returns a function-specific `Value` for a global
@@ -95,9 +91,11 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
9591
fn get_pgo_func_name_var(&self, instance: Instance<'tcx>) -> &'ll llvm::Value {
9692
debug!("getting pgo_func_name_var for instance={:?}", instance);
9793
let mut pgo_func_name_var_map = self.coverage_cx().pgo_func_name_var_map.borrow_mut();
98-
pgo_func_name_var_map
99-
.entry(instance)
100-
.or_insert_with(|| create_pgo_func_name_var(self, instance))
94+
pgo_func_name_var_map.entry(instance).or_insert_with(|| {
95+
let llfn = self.get_fn(instance);
96+
let mangled_fn_name: &str = self.tcx.symbol_name(instance).name;
97+
llvm_cov::create_pgo_func_name_var(llfn, mangled_fn_name)
98+
})
10199
}
102100
}
103101

@@ -225,80 +223,3 @@ impl<'tcx> CoverageInfoBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
225223
}
226224
}
227225
}
228-
229-
/// Calls llvm::createPGOFuncNameVar() with the given function instance's
230-
/// mangled function name. The LLVM API returns an llvm::GlobalVariable
231-
/// containing the function name, with the specific variable name and linkage
232-
/// required by LLVM InstrProf source-based coverage instrumentation. Use
233-
/// `bx.get_pgo_func_name_var()` to ensure the variable is only created once per
234-
/// `Instance`.
235-
fn create_pgo_func_name_var<'ll, 'tcx>(
236-
cx: &CodegenCx<'ll, 'tcx>,
237-
instance: Instance<'tcx>,
238-
) -> &'ll llvm::Value {
239-
let mangled_fn_name: &str = cx.tcx.symbol_name(instance).name;
240-
let llfn = cx.get_fn(instance);
241-
unsafe {
242-
llvm::LLVMRustCoverageCreatePGOFuncNameVar(
243-
llfn,
244-
mangled_fn_name.as_c_char_ptr(),
245-
mangled_fn_name.len(),
246-
)
247-
}
248-
}
249-
250-
pub(crate) fn write_filenames_section_to_buffer<'a>(
251-
filenames: impl IntoIterator<Item = &'a str>,
252-
buffer: &RustString,
253-
) {
254-
let (pointers, lengths) = filenames
255-
.into_iter()
256-
.map(|s: &str| (s.as_c_char_ptr(), s.len()))
257-
.unzip::<_, _, Vec<_>, Vec<_>>();
258-
259-
unsafe {
260-
llvm::LLVMRustCoverageWriteFilenamesSectionToBuffer(
261-
pointers.as_ptr(),
262-
pointers.len(),
263-
lengths.as_ptr(),
264-
lengths.len(),
265-
buffer,
266-
);
267-
}
268-
}
269-
270-
pub(crate) fn write_mapping_to_buffer(
271-
virtual_file_mapping: Vec<u32>,
272-
expressions: Vec<ffi::CounterExpression>,
273-
code_regions: &[ffi::CodeRegion],
274-
branch_regions: &[ffi::BranchRegion],
275-
mcdc_branch_regions: &[ffi::MCDCBranchRegion],
276-
mcdc_decision_regions: &[ffi::MCDCDecisionRegion],
277-
buffer: &RustString,
278-
) {
279-
unsafe {
280-
llvm::LLVMRustCoverageWriteMappingToBuffer(
281-
virtual_file_mapping.as_ptr(),
282-
virtual_file_mapping.len() as c_uint,
283-
expressions.as_ptr(),
284-
expressions.len() as c_uint,
285-
code_regions.as_ptr(),
286-
code_regions.len() as c_uint,
287-
branch_regions.as_ptr(),
288-
branch_regions.len() as c_uint,
289-
mcdc_branch_regions.as_ptr(),
290-
mcdc_branch_regions.len() as c_uint,
291-
mcdc_decision_regions.as_ptr(),
292-
mcdc_decision_regions.len() as c_uint,
293-
buffer,
294-
);
295-
}
296-
}
297-
298-
pub(crate) fn hash_bytes(bytes: &[u8]) -> u64 {
299-
unsafe { llvm::LLVMRustCoverageHashByteArray(bytes.as_c_char_ptr(), bytes.len()) }
300-
}
301-
302-
pub(crate) fn mapping_version() -> u32 {
303-
unsafe { llvm::LLVMRustCoverageMappingVersion() }
304-
}

‎compiler/rustc_codegen_llvm/src/lib.rs

+4-23
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,6 @@
2222

2323
use std::any::Any;
2424
use std::ffi::CStr;
25-
use std::io::Write;
2625
use std::mem::ManuallyDrop;
2726

2827
use back::owned_target_machine::OwnedTargetMachine;
@@ -165,30 +164,12 @@ impl WriteBackendMethods for LlvmCodegenBackend {
165164
type ThinData = back::lto::ThinData;
166165
type ThinBuffer = back::lto::ThinBuffer;
167166
fn print_pass_timings(&self) {
168-
unsafe {
169-
let mut size = 0;
170-
let cstr = llvm::LLVMRustPrintPassTimings(&raw mut size);
171-
if cstr.is_null() {
172-
println!("failed to get pass timings");
173-
} else {
174-
let timings = std::slice::from_raw_parts(cstr as *const u8, size);
175-
std::io::stdout().write_all(timings).unwrap();
176-
libc::free(cstr as *mut _);
177-
}
178-
}
167+
let timings = llvm::build_string(|s| unsafe { llvm::LLVMRustPrintPassTimings(s) }).unwrap();
168+
print!("{timings}");
179169
}
180170
fn print_statistics(&self) {
181-
unsafe {
182-
let mut size = 0;
183-
let cstr = llvm::LLVMRustPrintStatistics(&raw mut size);
184-
if cstr.is_null() {
185-
println!("failed to get pass stats");
186-
} else {
187-
let stats = std::slice::from_raw_parts(cstr as *const u8, size);
188-
std::io::stdout().write_all(stats).unwrap();
189-
libc::free(cstr as *mut _);
190-
}
191-
}
171+
let stats = llvm::build_string(|s| unsafe { llvm::LLVMRustPrintStatistics(s) }).unwrap();
172+
print!("{stats}");
192173
}
193174
fn run_link(
194175
cgcx: &CodegenContext<Self>,

0 commit comments

Comments
 (0)