Skip to content

Commit ee7d4c1

Browse files
matthiaskrgrmatthiaskrgr
authored
Rollup merge of #118903 - azhogin:azhogin/skip_second_stmt_debuginfo.rs, r=petrochenkov
Improved support of collapse_debuginfo attribute for macros. Added walk_chain_collapsed function to consider collapse_debuginfo attribute in parent macros in call chain. Fixed collapse_debuginfo attribute processing for cranelift (there was if/else branches error swap). cc #100758
2 parents ca663b0 + f2dbeba commit ee7d4c1

File tree

8 files changed

+513
-39
lines changed

8 files changed

+513
-39
lines changed

‎compiler/rustc_codegen_cranelift/src/debuginfo/line_info.rs

+1-9
Original file line numberDiff line numberDiff line change
@@ -68,15 +68,7 @@ impl DebugContext {
6868
// In order to have a good line stepping behavior in debugger, we overwrite debug
6969
// locations of macro expansions with that of the outermost expansion site (when the macro is
7070
// annotated with `#[collapse_debuginfo]` or when `-Zdebug-macros` is provided).
71-
let span = if tcx.should_collapse_debuginfo(span) {
72-
span
73-
} else {
74-
// Walk up the macro expansion chain until we reach a non-expanded span.
75-
// We also stop at the function body level because no line stepping can occur
76-
// at the level above that.
77-
rustc_span::hygiene::walk_chain(span, function_span.ctxt())
78-
};
79-
71+
let span = tcx.collapsed_debuginfo(span, function_span);
8072
match tcx.sess.source_map().lookup_line(span.lo()) {
8173
Ok(SourceFileAndLine { sf: file, line }) => {
8274
let line_pos = file.lines()[line];

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

+6-11
Original file line numberDiff line numberDiff line change
@@ -228,21 +228,16 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
228228
/// In order to have a good line stepping behavior in debugger, we overwrite debug
229229
/// locations of macro expansions with that of the outermost expansion site (when the macro is
230230
/// annotated with `#[collapse_debuginfo]` or when `-Zdebug-macros` is provided).
231-
fn adjust_span_for_debugging(&self, mut span: Span) -> Span {
231+
fn adjust_span_for_debugging(&self, span: Span) -> Span {
232232
// Bail out if debug info emission is not enabled.
233233
if self.debug_context.is_none() {
234234
return span;
235235
}
236-
237-
if self.cx.tcx().should_collapse_debuginfo(span) {
238-
// Walk up the macro expansion chain until we reach a non-expanded span.
239-
// We also stop at the function body level because no line stepping can occur
240-
// at the level above that.
241-
// Use span of the outermost expansion site, while keeping the original lexical scope.
242-
span = rustc_span::hygiene::walk_chain(span, self.mir.span.ctxt());
243-
}
244-
245-
span
236+
// Walk up the macro expansion chain until we reach a non-expanded span.
237+
// We also stop at the function body level because no line stepping can occur
238+
// at the level above that.
239+
// Use span of the outermost expansion site, while keeping the original lexical scope.
240+
self.cx.tcx().collapsed_debuginfo(span, self.mir.span)
246241
}
247242

248243
fn spill_operand_to_stack(

‎compiler/rustc_middle/src/ty/mod.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ use rustc_session::lint::LintBuffer;
5151
pub use rustc_session::lint::RegisteredTools;
5252
use rustc_span::hygiene::MacroKind;
5353
use rustc_span::symbol::{kw, sym, Ident, Symbol};
54-
use rustc_span::{ExpnId, ExpnKind, Span};
54+
use rustc_span::{hygiene, ExpnId, ExpnKind, Span};
5555
use rustc_target::abi::{Align, FieldIdx, Integer, IntegerType, VariantIdx};
5656
pub use rustc_target::abi::{ReprFlags, ReprOptions};
5757
pub use rustc_type_ir::{DebugWithInfcx, InferCtxtLike, WithInfcx};
@@ -2518,21 +2518,21 @@ impl<'tcx> TyCtxt<'tcx> {
25182518
(ident, scope)
25192519
}
25202520

2521-
/// Returns `true` if the debuginfo for `span` should be collapsed to the outermost expansion
2522-
/// site. Only applies when `Span` is the result of macro expansion.
2521+
/// Returns corrected span if the debuginfo for `span` should be collapsed to the outermost
2522+
/// expansion site (with collapse_debuginfo attribute if the corresponding feature enabled).
2523+
/// Only applies when `Span` is the result of macro expansion.
25232524
///
25242525
/// - If the `collapse_debuginfo` feature is enabled then debuginfo is not collapsed by default
2525-
/// and only when a macro definition is annotated with `#[collapse_debuginfo]`.
2526+
/// and only when a (some enclosing) macro definition is annotated with `#[collapse_debuginfo]`.
25262527
/// - If `collapse_debuginfo` is not enabled, then debuginfo is collapsed by default.
25272528
///
25282529
/// When `-Zdebug-macros` is provided then debuginfo will never be collapsed.
2529-
pub fn should_collapse_debuginfo(self, span: Span) -> bool {
2530-
!self.sess.opts.unstable_opts.debug_macros
2531-
&& if self.features().collapse_debuginfo {
2532-
span.in_macro_expansion_with_collapse_debuginfo()
2533-
} else {
2534-
span.from_expansion()
2535-
}
2530+
pub fn collapsed_debuginfo(self, span: Span, upto: Span) -> Span {
2531+
if self.sess.opts.unstable_opts.debug_macros || !span.from_expansion() {
2532+
return span;
2533+
}
2534+
let collapse_debuginfo_enabled = self.features().collapse_debuginfo;
2535+
hygiene::walk_chain_collapsed(span, upto, collapse_debuginfo_enabled)
25362536
}
25372537

25382538
#[inline]

‎compiler/rustc_span/src/hygiene.rs

+33-1
Original file line numberDiff line numberDiff line change
@@ -445,18 +445,46 @@ impl HygieneData {
445445
}
446446

447447
fn walk_chain(&self, mut span: Span, to: SyntaxContext) -> Span {
448+
let orig_span = span;
448449
debug!("walk_chain({:?}, {:?})", span, to);
449450
debug!("walk_chain: span ctxt = {:?}", span.ctxt());
450-
while span.from_expansion() && span.ctxt() != to {
451+
while span.ctxt() != to && span.from_expansion() {
451452
let outer_expn = self.outer_expn(span.ctxt());
452453
debug!("walk_chain({:?}): outer_expn={:?}", span, outer_expn);
453454
let expn_data = self.expn_data(outer_expn);
454455
debug!("walk_chain({:?}): expn_data={:?}", span, expn_data);
455456
span = expn_data.call_site;
456457
}
458+
debug!("walk_chain: for span {:?} >>> return span = {:?}", orig_span, span);
457459
span
458460
}
459461

462+
// We need to walk up and update return span if we meet macro instantiation to be collapsed
463+
fn walk_chain_collapsed(
464+
&self,
465+
mut span: Span,
466+
to: Span,
467+
collapse_debuginfo_enabled: bool,
468+
) -> Span {
469+
let orig_span = span;
470+
let mut ret_span = span;
471+
472+
debug!("walk_chain_collapsed({:?}, {:?})", span, to);
473+
debug!("walk_chain_collapsed: span ctxt = {:?}", span.ctxt());
474+
while !span.eq_ctxt(to) && span.from_expansion() {
475+
let outer_expn = self.outer_expn(span.ctxt());
476+
debug!("walk_chain_collapsed({:?}): outer_expn={:?}", span, outer_expn);
477+
let expn_data = self.expn_data(outer_expn);
478+
debug!("walk_chain_collapsed({:?}): expn_data={:?}", span, expn_data);
479+
span = expn_data.call_site;
480+
if !collapse_debuginfo_enabled || expn_data.collapse_debuginfo {
481+
ret_span = span;
482+
}
483+
}
484+
debug!("walk_chain_collapsed: for span {:?} >>> return span = {:?}", orig_span, ret_span);
485+
ret_span
486+
}
487+
460488
fn adjust(&self, ctxt: &mut SyntaxContext, expn_id: ExpnId) -> Option<ExpnId> {
461489
let mut scope = None;
462490
while !self.is_descendant_of(expn_id, self.outer_expn(*ctxt)) {
@@ -573,6 +601,10 @@ pub fn walk_chain(span: Span, to: SyntaxContext) -> Span {
573601
HygieneData::with(|data| data.walk_chain(span, to))
574602
}
575603

604+
pub fn walk_chain_collapsed(span: Span, to: Span, collapse_debuginfo_enabled: bool) -> Span {
605+
HygieneData::with(|hdata| hdata.walk_chain_collapsed(span, to, collapse_debuginfo_enabled))
606+
}
607+
576608
pub fn update_dollar_crate_names(mut get_name: impl FnMut(SyntaxContext) -> Symbol) {
577609
// The new contexts that need updating are at the end of the list and have `$crate` as a name.
578610
let (len, to_update) = HygieneData::with(|data| {

‎compiler/rustc_span/src/lib.rs

-7
Original file line numberDiff line numberDiff line change
@@ -567,13 +567,6 @@ impl Span {
567567
!self.ctxt().is_root()
568568
}
569569

570-
/// Returns `true` if `span` originates in a macro's expansion where debuginfo should be
571-
/// collapsed.
572-
pub fn in_macro_expansion_with_collapse_debuginfo(self) -> bool {
573-
let outer_expn = self.ctxt().outer_expn_data();
574-
matches!(outer_expn.kind, ExpnKind::Macro(..)) && outer_expn.collapse_debuginfo
575-
}
576-
577570
/// Returns `true` if `span` originates in a derive-macro's expansion.
578571
pub fn in_derive_expansion(self) -> bool {
579572
matches!(self.ctxt().outer_expn_data().kind, ExpnKind::Macro(MacroKind::Derive, _))

‎tests/debuginfo/collapse-debuginfo-in-non-collapse-macro.rs

+124
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,124 @@
1+
// ignore-lldb
2+
#![feature(collapse_debuginfo)]
3+
4+
// Test that statement, skipped/added/reordered by macros, is correctly processed in debuginfo.
5+
// When nested macros instantiations are tagged with collapse_debuginfo attribute,
6+
// debug info should be corrected to the first outer macro instantiation
7+
// without collapse_debuginfo attribute.
8+
// collapse_debuginfo feature enabled.
9+
10+
// compile-flags:-g
11+
12+
// === GDB TESTS ===================================================================================
13+
14+
// gdb-command:run
15+
// gdb-command:next
16+
// gdb-command:frame
17+
// gdb-check:[...]#loc_rem_call1[...]
18+
// gdb-command:step
19+
// gdb-command:frame
20+
// gdb-check:[...]#loc_call1_pre[...]
21+
// gdb-command:next
22+
// gdb-command:frame
23+
// gdb-check:[...]#loc_in_proxy[...]
24+
// gdb-command:next 2
25+
// gdb-check:[...]#loc_rem_call3[...]
26+
// gdb-command:next
27+
// gdb-command:frame
28+
// gdb-check:[...]#loc_add_call1[...]
29+
// gdb-command:step
30+
// gdb-command:frame
31+
// gdb-check:[...]#loc_call1_pre[...]
32+
// gdb-command:next
33+
// gdb-command:frame
34+
// gdb-check:[...]#loc_in_proxy[...]
35+
// gdb-command:next 2
36+
// gdb-check:[...]#loc_add_macro[...]
37+
// gdb-command:next
38+
// gdb-command:frame
39+
// gdb-check:[...]#loc_add_call3[...]
40+
// gdb-command:next
41+
// gdb-command:frame
42+
// gdb-check:[...]#loc_reorder_call2[...]
43+
// gdb-command:next
44+
// gdb-command:frame
45+
// gdb-check:[...]#loc_reorder_call3[...]
46+
// gdb-command:next
47+
// gdb-command:frame
48+
// gdb-check:[...]#loc_reorder_call1[...]
49+
// gdb-command:step
50+
// gdb-command:frame
51+
// gdb-check:[...]#loc_call1_pre[...]
52+
// gdb-command:next
53+
// gdb-command:frame
54+
// gdb-check:[...]#loc_in_proxy[...]
55+
// gdb-command:next 2
56+
// gdb-command:frame
57+
// gdb-command:continue
58+
59+
#[inline(never)]
60+
fn myprintln_impl(text: &str) {
61+
println!("{}", text)
62+
}
63+
64+
#[collapse_debuginfo]
65+
macro_rules! myprintln {
66+
($($arg:tt)*) => {{
67+
myprintln_impl($($arg)*);
68+
}};
69+
}
70+
71+
macro_rules! proxy_println {
72+
($($arg:tt)*) => {{
73+
myprintln!($($arg)*); // #loc_in_proxy
74+
}};
75+
}
76+
77+
// Macro accepts 3 statements and removes the 2nd statement
78+
macro_rules! remove_second_statement {
79+
($s1:stmt; $s2:stmt; $s3:stmt;) => { $s1 $s3 }
80+
}
81+
82+
macro_rules! add_second_statement {
83+
($s1:stmt; $s3:stmt;) => {
84+
$s1
85+
call2(); // #loc_add_macro
86+
$s3
87+
}
88+
}
89+
90+
macro_rules! reorder_statements {
91+
($s1:stmt; $s2:stmt; $s3:stmt;) => { $s2 $s3 $s1 }
92+
}
93+
94+
fn call1() {
95+
let rv = 0; // #loc_call1_pre
96+
proxy_println!("one"); // #loc_call1
97+
}
98+
99+
fn call2() {
100+
proxy_println!("two"); // #loc_call2
101+
}
102+
103+
fn call3() {
104+
proxy_println!("three"); // #loc_call3
105+
}
106+
107+
fn main() {
108+
let ret = 0; // #break, step should go to call1
109+
remove_second_statement! { // #loc_rem_hdr
110+
call1(); // #loc_rem_call1
111+
call2(); // #loc_rem_call2
112+
call3(); // #loc_rem_call3
113+
}
114+
add_second_statement! { // #loc_add_hdr
115+
call1(); // #loc_add_call1
116+
call3(); // #loc_add_call3
117+
}
118+
reorder_statements! { // #loc_reorder_hdr
119+
call1(); // #loc_reorder_call1
120+
call2(); // #loc_reorder_call2
121+
call3(); // #loc_reorder_call3
122+
}
123+
std::process::exit(ret); // #loc_exit
124+
}

0 commit comments

Comments
 (0)