Skip to content

Commit 89fdb30

Browse files
borsbors
committed
Auto merge of rust-lang#78319 - jonas-schievink:rollup-vzj8a6l, r=jonas-schievink
Rollup of 15 pull requests Successful merges: - rust-lang#76649 (Add a spin loop hint for Arc::downgrade) - rust-lang#77392 (add `insert` to `Option`) - rust-lang#77716 (Revert "Allow dynamic linking for iOS/tvOS targets.") - rust-lang#78109 (Check for exhaustion in RangeInclusive::contains and slicing) - rust-lang#78198 (Simplify assert terminator only if condition evaluates to expected value) - rust-lang#78243 (--test-args flag description) - rust-lang#78249 (improve const infer error) - rust-lang#78250 (Document inline-const) - rust-lang#78264 (Add regression test for issue-77475) - rust-lang#78274 (Update description of Empty Enum for accuracy) - rust-lang#78278 (move `visit_predicate` into `TypeVisitor`) - rust-lang#78292 (Loop instead of recursion) - rust-lang#78293 (Always store Rustdoc theme when it's changed) - rust-lang#78300 (Make codegen coverage_context optional, and check) - rust-lang#78307 (Revert "Set .llvmbc and .llvmcmd sections as allocatable") Failed merges: r? `@ghost`
2 parents 2e8a54a + 1ac137b commit 89fdb30

File tree

26 files changed

+386
-195
lines changed

26 files changed

+386
-195
lines changed

‎compiler/rustc_ast_lowering/src/pat.rs

+79-71
Original file line numberDiff line numberDiff line change
@@ -10,82 +10,90 @@ use rustc_span::symbol::Ident;
1010
use rustc_span::{source_map::Spanned, Span};
1111

1212
impl<'a, 'hir> LoweringContext<'a, 'hir> {
13-
crate fn lower_pat(&mut self, p: &Pat) -> &'hir hir::Pat<'hir> {
13+
crate fn lower_pat(&mut self, mut pattern: &Pat) -> &'hir hir::Pat<'hir> {
1414
ensure_sufficient_stack(|| {
15-
let node = match p.kind {
16-
PatKind::Wild => hir::PatKind::Wild,
17-
PatKind::Ident(ref binding_mode, ident, ref sub) => {
18-
let lower_sub = |this: &mut Self| sub.as_ref().map(|s| this.lower_pat(&*s));
19-
let node = self.lower_pat_ident(p, binding_mode, ident, lower_sub);
20-
node
21-
}
22-
PatKind::Lit(ref e) => hir::PatKind::Lit(self.lower_expr(e)),
23-
PatKind::TupleStruct(ref path, ref pats) => {
24-
let qpath = self.lower_qpath(
25-
p.id,
26-
&None,
27-
path,
28-
ParamMode::Optional,
29-
ImplTraitContext::disallowed(),
30-
);
31-
let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple struct");
32-
hir::PatKind::TupleStruct(qpath, pats, ddpos)
33-
}
34-
PatKind::Or(ref pats) => hir::PatKind::Or(
35-
self.arena.alloc_from_iter(pats.iter().map(|x| self.lower_pat(x))),
36-
),
37-
PatKind::Path(ref qself, ref path) => {
38-
let qpath = self.lower_qpath(
39-
p.id,
40-
qself,
41-
path,
42-
ParamMode::Optional,
43-
ImplTraitContext::disallowed(),
44-
);
45-
hir::PatKind::Path(qpath)
46-
}
47-
PatKind::Struct(ref path, ref fields, etc) => {
48-
let qpath = self.lower_qpath(
49-
p.id,
50-
&None,
51-
path,
52-
ParamMode::Optional,
53-
ImplTraitContext::disallowed(),
54-
);
15+
// loop here to avoid recursion
16+
let node = loop {
17+
match pattern.kind {
18+
PatKind::Wild => break hir::PatKind::Wild,
19+
PatKind::Ident(ref binding_mode, ident, ref sub) => {
20+
let lower_sub = |this: &mut Self| sub.as_ref().map(|s| this.lower_pat(&*s));
21+
break self.lower_pat_ident(pattern, binding_mode, ident, lower_sub);
22+
}
23+
PatKind::Lit(ref e) => break hir::PatKind::Lit(self.lower_expr(e)),
24+
PatKind::TupleStruct(ref path, ref pats) => {
25+
let qpath = self.lower_qpath(
26+
pattern.id,
27+
&None,
28+
path,
29+
ParamMode::Optional,
30+
ImplTraitContext::disallowed(),
31+
);
32+
let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple struct");
33+
break hir::PatKind::TupleStruct(qpath, pats, ddpos);
34+
}
35+
PatKind::Or(ref pats) => {
36+
break hir::PatKind::Or(
37+
self.arena.alloc_from_iter(pats.iter().map(|x| self.lower_pat(x))),
38+
);
39+
}
40+
PatKind::Path(ref qself, ref path) => {
41+
let qpath = self.lower_qpath(
42+
pattern.id,
43+
qself,
44+
path,
45+
ParamMode::Optional,
46+
ImplTraitContext::disallowed(),
47+
);
48+
break hir::PatKind::Path(qpath);
49+
}
50+
PatKind::Struct(ref path, ref fields, etc) => {
51+
let qpath = self.lower_qpath(
52+
pattern.id,
53+
&None,
54+
path,
55+
ParamMode::Optional,
56+
ImplTraitContext::disallowed(),
57+
);
5558

56-
let fs = self.arena.alloc_from_iter(fields.iter().map(|f| hir::FieldPat {
57-
hir_id: self.next_id(),
58-
ident: f.ident,
59-
pat: self.lower_pat(&f.pat),
60-
is_shorthand: f.is_shorthand,
61-
span: f.span,
62-
}));
63-
hir::PatKind::Struct(qpath, fs, etc)
64-
}
65-
PatKind::Tuple(ref pats) => {
66-
let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple");
67-
hir::PatKind::Tuple(pats, ddpos)
68-
}
69-
PatKind::Box(ref inner) => hir::PatKind::Box(self.lower_pat(inner)),
70-
PatKind::Ref(ref inner, mutbl) => hir::PatKind::Ref(self.lower_pat(inner), mutbl),
71-
PatKind::Range(ref e1, ref e2, Spanned { node: ref end, .. }) => {
72-
hir::PatKind::Range(
73-
e1.as_deref().map(|e| self.lower_expr(e)),
74-
e2.as_deref().map(|e| self.lower_expr(e)),
75-
self.lower_range_end(end, e2.is_some()),
76-
)
77-
}
78-
PatKind::Slice(ref pats) => self.lower_pat_slice(pats),
79-
PatKind::Rest => {
80-
// If we reach here the `..` pattern is not semantically allowed.
81-
self.ban_illegal_rest_pat(p.span)
59+
let fs = self.arena.alloc_from_iter(fields.iter().map(|f| hir::FieldPat {
60+
hir_id: self.next_id(),
61+
ident: f.ident,
62+
pat: self.lower_pat(&f.pat),
63+
is_shorthand: f.is_shorthand,
64+
span: f.span,
65+
}));
66+
break hir::PatKind::Struct(qpath, fs, etc);
67+
}
68+
PatKind::Tuple(ref pats) => {
69+
let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple");
70+
break hir::PatKind::Tuple(pats, ddpos);
71+
}
72+
PatKind::Box(ref inner) => {
73+
break hir::PatKind::Box(self.lower_pat(inner));
74+
}
75+
PatKind::Ref(ref inner, mutbl) => {
76+
break hir::PatKind::Ref(self.lower_pat(inner), mutbl);
77+
}
78+
PatKind::Range(ref e1, ref e2, Spanned { node: ref end, .. }) => {
79+
break hir::PatKind::Range(
80+
e1.as_deref().map(|e| self.lower_expr(e)),
81+
e2.as_deref().map(|e| self.lower_expr(e)),
82+
self.lower_range_end(end, e2.is_some()),
83+
);
84+
}
85+
PatKind::Slice(ref pats) => break self.lower_pat_slice(pats),
86+
PatKind::Rest => {
87+
// If we reach here the `..` pattern is not semantically allowed.
88+
break self.ban_illegal_rest_pat(pattern.span);
89+
}
90+
// return inner to be processed in next loop
91+
PatKind::Paren(ref inner) => pattern = inner,
92+
PatKind::MacCall(_) => panic!("{:?} shouldn't exist here", pattern.span),
8293
}
83-
// FIXME: consider not using recursion to lower this.
84-
PatKind::Paren(ref inner) => return self.lower_pat(inner),
85-
PatKind::MacCall(_) => panic!("{:?} shouldn't exist here", p.span),
8694
};
8795

88-
self.pat_with_node_id_of(p, node)
96+
self.pat_with_node_id_of(pattern, node)
8997
})
9098
}
9199

‎compiler/rustc_codegen_llvm/src/back/write.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -936,8 +936,8 @@ unsafe fn embed_bitcode(
936936
llvm::LLVMRustAppendModuleInlineAsm(llmod, asm.as_ptr().cast(), asm.len());
937937
} else {
938938
let asm = "
939-
.section .llvmbc,\"a\"
940-
.section .llvmcmd,\"a\"
939+
.section .llvmbc,\"e\"
940+
.section .llvmcmd,\"e\"
941941
";
942942
llvm::LLVMRustAppendModuleInlineAsm(llmod, asm.as_ptr().cast(), asm.len());
943943
}

‎compiler/rustc_codegen_llvm/src/context.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -324,8 +324,8 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
324324
}
325325

326326
#[inline]
327-
pub fn coverage_context(&'a self) -> &'a coverageinfo::CrateCoverageContext<'tcx> {
328-
self.coverage_cx.as_ref().unwrap()
327+
pub fn coverage_context(&'a self) -> Option<&'a coverageinfo::CrateCoverageContext<'tcx>> {
328+
self.coverage_cx.as_ref()
329329
}
330330
}
331331

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

+4-1
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,10 @@ use tracing::debug;
2626
/// undocumented details in Clang's implementation (that may or may not be important) were also
2727
/// replicated for Rust's Coverage Map.
2828
pub fn finalize<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>) {
29-
let function_coverage_map = cx.coverage_context().take_function_coverage_map();
29+
let function_coverage_map = match cx.coverage_context() {
30+
Some(ctx) => ctx.take_function_coverage_map(),
31+
None => return,
32+
};
3033
if function_coverage_map.is_empty() {
3134
// This module has no functions with coverage instrumentation
3235
return;

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

+47-32
Original file line numberDiff line numberDiff line change
@@ -64,17 +64,22 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
6464
function_source_hash: u64,
6565
id: CounterValueReference,
6666
region: CodeRegion,
67-
) {
68-
debug!(
69-
"adding counter to coverage_regions: instance={:?}, function_source_hash={}, id={:?}, \
70-
at {:?}",
71-
instance, function_source_hash, id, region,
72-
);
73-
let mut coverage_regions = self.coverage_context().function_coverage_map.borrow_mut();
74-
coverage_regions
75-
.entry(instance)
76-
.or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
77-
.add_counter(function_source_hash, id, region);
67+
) -> bool {
68+
if let Some(coverage_context) = self.coverage_context() {
69+
debug!(
70+
"adding counter to coverage_regions: instance={:?}, function_source_hash={}, id={:?}, \
71+
at {:?}",
72+
instance, function_source_hash, id, region,
73+
);
74+
let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut();
75+
coverage_regions
76+
.entry(instance)
77+
.or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
78+
.add_counter(function_source_hash, id, region);
79+
true
80+
} else {
81+
false
82+
}
7883
}
7984

8085
fn add_counter_expression_region(
@@ -85,29 +90,39 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
8590
op: Op,
8691
rhs: ExpressionOperandId,
8792
region: CodeRegion,
88-
) {
89-
debug!(
90-
"adding counter expression to coverage_regions: instance={:?}, id={:?}, {:?} {:?} {:?}, \
91-
at {:?}",
92-
instance, id, lhs, op, rhs, region,
93-
);
94-
let mut coverage_regions = self.coverage_context().function_coverage_map.borrow_mut();
95-
coverage_regions
96-
.entry(instance)
97-
.or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
98-
.add_counter_expression(id, lhs, op, rhs, region);
93+
) -> bool {
94+
if let Some(coverage_context) = self.coverage_context() {
95+
debug!(
96+
"adding counter expression to coverage_regions: instance={:?}, id={:?}, {:?} {:?} {:?}, \
97+
at {:?}",
98+
instance, id, lhs, op, rhs, region,
99+
);
100+
let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut();
101+
coverage_regions
102+
.entry(instance)
103+
.or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
104+
.add_counter_expression(id, lhs, op, rhs, region);
105+
true
106+
} else {
107+
false
108+
}
99109
}
100110

101-
fn add_unreachable_region(&mut self, instance: Instance<'tcx>, region: CodeRegion) {
102-
debug!(
103-
"adding unreachable code to coverage_regions: instance={:?}, at {:?}",
104-
instance, region,
105-
);
106-
let mut coverage_regions = self.coverage_context().function_coverage_map.borrow_mut();
107-
coverage_regions
108-
.entry(instance)
109-
.or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
110-
.add_unreachable_region(region);
111+
fn add_unreachable_region(&mut self, instance: Instance<'tcx>, region: CodeRegion) -> bool {
112+
if let Some(coverage_context) = self.coverage_context() {
113+
debug!(
114+
"adding unreachable code to coverage_regions: instance={:?}, at {:?}",
115+
instance, region,
116+
);
117+
let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut();
118+
coverage_regions
119+
.entry(instance)
120+
.or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
121+
.add_unreachable_region(region);
122+
true
123+
} else {
124+
false
125+
}
111126
}
112127
}
113128

‎compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs

+12-12
Original file line numberDiff line numberDiff line change
@@ -10,19 +10,19 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
1010
let Coverage { kind, code_region } = coverage;
1111
match kind {
1212
CoverageKind::Counter { function_source_hash, id } => {
13-
bx.add_counter_region(self.instance, function_source_hash, id, code_region);
13+
if bx.add_counter_region(self.instance, function_source_hash, id, code_region) {
14+
let coverageinfo = bx.tcx().coverageinfo(self.instance.def_id());
1415

15-
let coverageinfo = bx.tcx().coverageinfo(self.instance.def_id());
16-
17-
let fn_name = bx.create_pgo_func_name_var(self.instance);
18-
let hash = bx.const_u64(function_source_hash);
19-
let num_counters = bx.const_u32(coverageinfo.num_counters);
20-
let id = bx.const_u32(u32::from(id));
21-
debug!(
22-
"codegen intrinsic instrprof.increment(fn_name={:?}, hash={:?}, num_counters={:?}, index={:?})",
23-
fn_name, hash, num_counters, id,
24-
);
25-
bx.instrprof_increment(fn_name, hash, num_counters, id);
16+
let fn_name = bx.create_pgo_func_name_var(self.instance);
17+
let hash = bx.const_u64(function_source_hash);
18+
let num_counters = bx.const_u32(coverageinfo.num_counters);
19+
let id = bx.const_u32(u32::from(id));
20+
debug!(
21+
"codegen intrinsic instrprof.increment(fn_name={:?}, hash={:?}, num_counters={:?}, index={:?})",
22+
fn_name, hash, num_counters, id,
23+
);
24+
bx.instrprof_increment(fn_name, hash, num_counters, id);
25+
}
2626
}
2727
CoverageKind::Expression { id, lhs, op, rhs } => {
2828
bx.add_counter_expression_region(self.instance, id, lhs, op, rhs, code_region);

‎compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs

+9-3
Original file line numberDiff line numberDiff line change
@@ -9,14 +9,18 @@ pub trait CoverageInfoMethods: BackendTypes {
99
pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes {
1010
fn create_pgo_func_name_var(&self, instance: Instance<'tcx>) -> Self::Value;
1111

12+
/// Returns true if the counter was added to the coverage map; false if `-Z instrument-coverage`
13+
/// is not enabled (a coverage map is not being generated).
1214
fn add_counter_region(
1315
&mut self,
1416
instance: Instance<'tcx>,
1517
function_source_hash: u64,
1618
id: CounterValueReference,
1719
region: CodeRegion,
18-
);
20+
) -> bool;
1921

22+
/// Returns true if the expression was added to the coverage map; false if
23+
/// `-Z instrument-coverage` is not enabled (a coverage map is not being generated).
2024
fn add_counter_expression_region(
2125
&mut self,
2226
instance: Instance<'tcx>,
@@ -25,7 +29,9 @@ pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes {
2529
op: Op,
2630
rhs: ExpressionOperandId,
2731
region: CodeRegion,
28-
);
32+
) -> bool;
2933

30-
fn add_unreachable_region(&mut self, instance: Instance<'tcx>, region: CodeRegion);
34+
/// Returns true if the region was added to the coverage map; false if `-Z instrument-coverage`
35+
/// is not enabled (a coverage map is not being generated).
36+
fn add_unreachable_region(&mut self, instance: Instance<'tcx>, region: CodeRegion) -> bool;
3137
}

‎compiler/rustc_middle/src/infer/unify_key.rs

+8-17
Original file line numberDiff line numberDiff line change
@@ -175,19 +175,15 @@ impl<'tcx> UnifyKey for ty::ConstVid<'tcx> {
175175
impl<'tcx> UnifyValue for ConstVarValue<'tcx> {
176176
type Error = (&'tcx ty::Const<'tcx>, &'tcx ty::Const<'tcx>);
177177

178-
fn unify_values(value1: &Self, value2: &Self) -> Result<Self, Self::Error> {
179-
let (val, span) = match (value1.val, value2.val) {
178+
fn unify_values(&value1: &Self, &value2: &Self) -> Result<Self, Self::Error> {
179+
Ok(match (value1.val, value2.val) {
180180
(ConstVariableValue::Known { .. }, ConstVariableValue::Known { .. }) => {
181181
bug!("equating two const variables, both of which have known values")
182182
}
183183

184184
// If one side is known, prefer that one.
185-
(ConstVariableValue::Known { .. }, ConstVariableValue::Unknown { .. }) => {
186-
(value1.val, value1.origin.span)
187-
}
188-
(ConstVariableValue::Unknown { .. }, ConstVariableValue::Known { .. }) => {
189-
(value2.val, value2.origin.span)
190-
}
185+
(ConstVariableValue::Known { .. }, ConstVariableValue::Unknown { .. }) => value1,
186+
(ConstVariableValue::Unknown { .. }, ConstVariableValue::Known { .. }) => value2,
191187

192188
// If both sides are *unknown*, it hardly matters, does it?
193189
(
@@ -200,16 +196,11 @@ impl<'tcx> UnifyValue for ConstVarValue<'tcx> {
200196
// universe is the minimum of the two universes, because that is
201197
// the one which contains the fewest names in scope.
202198
let universe = cmp::min(universe1, universe2);
203-
(ConstVariableValue::Unknown { universe }, value1.origin.span)
199+
ConstVarValue {
200+
val: ConstVariableValue::Unknown { universe },
201+
origin: value1.origin,
202+
}
204203
}
205-
};
206-
207-
Ok(ConstVarValue {
208-
origin: ConstVariableOrigin {
209-
kind: ConstVariableOriginKind::ConstInference,
210-
span: span,
211-
},
212-
val,
213204
})
214205
}
215206
}

0 commit comments

Comments
 (0)