Auto merge of #131345 - Zalathar:rollup-scdxuou, r=Zalathar

Rollup of 3 pull requests
Successful merges:
- #128399 (liballoc: introduce String, Vec const-slicing)
- #131308 (enable f16 and f128 on windows-gnullvm targets)
- #131325 (coverage: Multiple small tweaks to counter creation)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_mir_transform/src/coverage/counters.rs

@@ -4,6 +4,7 @@ use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::graph::DirectedGraph;
 use rustc_index::IndexVec;
+use rustc_index::bit_set::BitSet;
 use rustc_middle::bug;
 use rustc_middle::mir::coverage::{CounterId,CovTerm,Expression,ExpressionId,Op};
 use tracing::{debug, debug_span, instrument};
@@ -13,13 +14,13 @@ use crate::coverage::graph::{BasicCoverageBlock, CoverageGraph, TraverseCoverage
 /// The coverage counter or counter expression associated with a particular
 /// BCB node or BCB edge.
 #[derive(Clone,Copy,PartialEq,Eq,Hash)]
-pub(super)enumBcbCounter{
+enumBcbCounter{
 Counter{id:CounterId},
 Expression{id:ExpressionId},
 }
 
 implBcbCounter{
-pub(super)fnas_term(&self) -> CovTerm{
+fnas_term(&self) -> CovTerm{
 match*self{
 BcbCounter::Counter{ id, .. } => CovTerm::Counter(id),
 BcbCounter::Expression{ id, .. } => CovTerm::Expression(id),
@@ -78,21 +79,22 @@ impl CoverageCounters {
 /// counters or counter expressions for nodes and edges as required.
 pub(super)fnmake_bcb_counters(
 basic_coverage_blocks:&CoverageGraph,
-bcb_needs_counter:implFn(BasicCoverageBlock) -> bool,
+bcb_needs_counter:&BitSet<BasicCoverageBlock>,
 ) -> Self{
-let num_bcbs = basic_coverage_blocks.num_nodes();
+letmut counters = MakeBcbCounters::new(basic_coverage_blocks, bcb_needs_counter);
+ counters.make_bcb_counters();
 
-letmut this = Self{
+ counters.coverage_counters
+}
+
+fnwith_num_bcbs(num_bcbs:usize) -> Self{
+Self{
 counter_increment_sites:IndexVec::new(),
 bcb_counters:IndexVec::from_elem_n(None, num_bcbs),
 bcb_edge_counters:FxHashMap::default(),
 expressions:IndexVec::new(),
 expressions_memo:FxHashMap::default(),
-};
-
-MakeBcbCounters::new(&mut this, basic_coverage_blocks).make_bcb_counters(bcb_needs_counter);
-
- this
+}
 }
 
 /// Shared helper used by [`Self::make_phys_node_counter`] and
@@ -218,8 +220,8 @@ impl CoverageCounters {
 }
 }
 
-pub(super)fnbcb_counter(&self,bcb:BasicCoverageBlock) -> Option<BcbCounter>{
-self.bcb_counters[bcb]
+pub(super)fnterm_for_bcb(&self,bcb:BasicCoverageBlock) -> Option<CovTerm>{
+self.bcb_counters[bcb].map(|counter| counter.as_term())
 }
 
 /// Returns an iterator over all the nodes/edges in the coverage graph that
@@ -265,19 +267,25 @@ impl CoverageCounters {
 
 /// Helper struct that allows counter creation to inspect the BCB graph.
 structMakeBcbCounters<'a>{
-coverage_counters:&'amutCoverageCounters,
+coverage_counters:CoverageCounters,
 basic_coverage_blocks:&'aCoverageGraph,
+bcb_needs_counter:&'aBitSet<BasicCoverageBlock>,
 }
 
 impl<'a>MakeBcbCounters<'a>{
 fnnew(
-coverage_counters:&'amutCoverageCounters,
 basic_coverage_blocks:&'aCoverageGraph,
+bcb_needs_counter:&'aBitSet<BasicCoverageBlock>,
 ) -> Self{
-Self{ coverage_counters, basic_coverage_blocks }
+assert_eq!(basic_coverage_blocks.num_nodes(), bcb_needs_counter.domain_size());
+Self{
+coverage_counters:CoverageCounters::with_num_bcbs(basic_coverage_blocks.num_nodes()),
+ basic_coverage_blocks,
+ bcb_needs_counter,
+}
 }
 
-fnmake_bcb_counters(&mutself,bcb_needs_counter:implFn(BasicCoverageBlock) -> bool){
+fnmake_bcb_counters(&mutself){
 debug!("make_bcb_counters(): adding a counter or expression to each BasicCoverageBlock");
 
 // Traverse the coverage graph, ensuring that every node that needs a
@@ -290,7 +298,7 @@ impl<'a> MakeBcbCounters<'a> {
 letmut traversal = TraverseCoverageGraphWithLoops::new(self.basic_coverage_blocks);
 whileletSome(bcb) = traversal.next(){
 let _span = debug_span!("traversal", ?bcb).entered();
-ifbcb_needs_counter(bcb){
+ifself.bcb_needs_counter.contains(bcb){
 self.make_node_counter_and_out_edge_counters(&traversal, bcb);
 }
 }

compiler/rustc_mir_transform/src/coverage/mod.rs

@@ -94,9 +94,8 @@ fn instrument_function_for_coverage<'tcx>(tcx: TyCtxt<'tcx>, mir_body: &mut mir:
 return;
 }
 
-let bcb_has_counter_mappings = |bcb| bcbs_with_counter_mappings.contains(bcb);
 let coverage_counters =
-CoverageCounters::make_bcb_counters(&basic_coverage_blocks,bcb_has_counter_mappings);
+CoverageCounters::make_bcb_counters(&basic_coverage_blocks,&bcbs_with_counter_mappings);
 
 let mappings = create_mappings(tcx,&hir_info,&extracted_mappings,&coverage_counters);
 if mappings.is_empty(){
@@ -153,12 +152,8 @@ fn create_mappings<'tcx>(
 &source_file.name.for_scope(tcx.sess,RemapPathScopeComponents::MACRO).to_string_lossy(),
 );
 
-let term_for_bcb = |bcb| {
- coverage_counters
-.bcb_counter(bcb)
-.expect("all BCBs with spans were given counters")
-.as_term()
-};
+let term_for_bcb =
+ |bcb| coverage_counters.term_for_bcb(bcb).expect("all BCBs with spans were given counters");
 let region_for_span = |span:Span| make_source_region(source_map, file_name, span, body_span);
 
 // Fully destructure the mappings struct to make sure we don't miss any kinds.

library/alloc/src/lib.rs

@@ -115,6 +115,7 @@
 #![feature(const_option)]
 #![feature(const_pin)]
 #![feature(const_size_of_val)]
+#![feature(const_vec_string_slice)]
 #![feature(core_intrinsics)]
 #![feature(deprecated_suggestion)]
 #![feature(deref_pure_trait)]

library/alloc/src/raw_vec.rs

@@ -280,7 +280,7 @@ impl<T, A: Allocator> RawVec<T, A> {
 /// `Unique::dangling()` if `capacity == 0` or `T` is zero-sized. In the former case, you must
 /// be careful.
 #[inline]
-pubfnptr(&self) -> *mutT{
+pubconstfnptr(&self) -> *mutT{
 self.inner.ptr()
 }
 
@@ -293,7 +293,7 @@ impl<T, A: Allocator> RawVec<T, A> {
 ///
 /// This will always be `usize::MAX` if `T` is zero-sized.
 #[inline]
-pubfncapacity(&self) -> usize{
+pubconstfncapacity(&self) -> usize{
 self.inner.capacity(size_of::<T>())
 }
 
@@ -488,17 +488,17 @@ impl<A: Allocator> RawVecInner<A> {
 }
 
 #[inline]
-fnptr<T>(&self) -> *mutT{
+constfnptr<T>(&self) -> *mutT{
 self.non_null::<T>().as_ptr()
 }
 
 #[inline]
-fnnon_null<T>(&self) -> NonNull<T>{
-self.ptr.cast().into()
+constfnnon_null<T>(&self) -> NonNull<T>{
+self.ptr.cast().as_non_null_ptr()
 }
 
 #[inline]
-fncapacity(&self,elem_size:usize) -> usize{
+constfncapacity(&self,elem_size:usize) -> usize{
 if elem_size == 0{ usize::MAX}else{self.cap.0}
 }
 

library/alloc/src/string.rs

@@ -1059,7 +1059,8 @@ impl String {
 #[inline]
 #[must_use = "`self` will be dropped if the result is not used"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pubfninto_bytes(self) -> Vec<u8>{
+#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
+pubconstfninto_bytes(self) -> Vec<u8>{
 self.vec
 }
 
@@ -1076,8 +1077,11 @@ impl String {
 #[must_use]
 #[stable(feature = "string_as_str", since = "1.7.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "string_as_str")]
-pubfnas_str(&self) -> &str{
-self
+#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
+pubconstfnas_str(&self) -> &str{
+// SAFETY: String contents are stipulated to be valid UTF-8, invalid contents are an error
+// at construction.
+unsafe{ str::from_utf8_unchecked(self.vec.as_slice())}
 }
 
 /// Converts a `String` into a mutable string slice.
@@ -1096,8 +1100,11 @@ impl String {
 #[must_use]
 #[stable(feature = "string_as_str", since = "1.7.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "string_as_mut_str")]
-pubfnas_mut_str(&mutself) -> &mutstr{
-self
+#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
+pubconstfnas_mut_str(&mutself) -> &mutstr{
+// SAFETY: String contents are stipulated to be valid UTF-8, invalid contents are an error
+// at construction.
+unsafe{ str::from_utf8_unchecked_mut(self.vec.as_mut_slice())}
 }
 
 /// Appends a given string slice onto the end of this `String`.
@@ -1168,7 +1175,8 @@ impl String {
 #[inline]
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
-pubfncapacity(&self) -> usize{
+#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
+pubconstfncapacity(&self) -> usize{
 self.vec.capacity()
 }
 
@@ -1431,8 +1439,9 @@ impl String {
 #[inline]
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
-pubfnas_bytes(&self) -> &[u8]{
-&self.vec
+#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
+pubconstfnas_bytes(&self) -> &[u8]{
+self.vec.as_slice()
 }
 
 /// Shortens this `String` to the specified length.
@@ -1784,7 +1793,8 @@ impl String {
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-pubunsafefnas_mut_vec(&mutself) -> &mutVec<u8>{
+#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
+pubconstunsafefnas_mut_vec(&mutself) -> &mutVec<u8>{
 &mutself.vec
 }
 
@@ -1805,8 +1815,9 @@ impl String {
 #[inline]
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
 #[rustc_confusables("length","size")]
-pubfnlen(&self) -> usize{
+pubconstfnlen(&self) -> usize{
 self.vec.len()
 }
 
@@ -1824,7 +1835,8 @@ impl String {
 #[inline]
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
-pubfnis_empty(&self) -> bool{
+#[rustc_const_unstable(feature = "const_vec_string_slice", issue = "129041")]
+pubconstfnis_empty(&self) -> bool{
 self.len() == 0
 }
 
@@ -2589,7 +2601,7 @@ impl ops::Deref for String {
 
 #[inline]
 fnderef(&self) -> &str{
-unsafe{ str::from_utf8_unchecked(&self.vec)}
+self.as_str()
 }
 }
 
@@ -2600,7 +2612,7 @@ unsafe impl ops::DerefPure for String {}
 impl ops::DerefMutforString{
 #[inline]
 fnderef_mut(&mutself) -> &mutstr{
-unsafe{ str::from_utf8_unchecked_mut(&mut*self.vec)}
+self.as_mut_str()
 }
 }