Skip to content

Commit ea1350e

Browse files
azhoginazhogin
committed
Improved support of collapse_debuginfo attribute for macros.
1 parent ca9ff83 commit ea1350e

File tree

8 files changed

+521
-39
lines changed

8 files changed

+521
-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
@@ -50,7 +50,7 @@ use rustc_session::lint::LintBuffer;
5050
pub use rustc_session::lint::RegisteredTools;
5151
use rustc_span::hygiene::MacroKind;
5252
use rustc_span::symbol::{kw, sym, Ident, Symbol};
53-
use rustc_span::{ExpnId, ExpnKind, Span};
53+
use rustc_span::{hygiene, ExpnId, ExpnKind, Span};
5454
use rustc_target::abi::{Align, FieldIdx, Integer, IntegerType, VariantIdx};
5555
pub use rustc_target::abi::{ReprFlags, ReprOptions};
5656
pub use rustc_type_ir::{DebugWithInfcx, InferCtxtLike, WithInfcx};
@@ -2515,21 +2515,21 @@ impl<'tcx> TyCtxt<'tcx> {
25152515
(ident, scope)
25162516
}
25172517

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

25352535
#[inline]

‎compiler/rustc_span/src/hygiene.rs

+28-1
Original file line numberDiff line numberDiff line change
@@ -443,18 +443,41 @@ impl HygieneData {
443443
}
444444

445445
fn walk_chain(&self, mut span: Span, to: SyntaxContext) -> Span {
446+
let orig_span = span;
446447
debug!("walk_chain({:?}, {:?})", span, to);
447448
debug!("walk_chain: span ctxt = {:?}", span.ctxt());
448-
while span.from_expansion() && span.ctxt() != to {
449+
while span.ctxt() != to && span.from_expansion() {
449450
let outer_expn = self.outer_expn(span.ctxt());
450451
debug!("walk_chain({:?}): outer_expn={:?}", span, outer_expn);
451452
let expn_data = self.expn_data(outer_expn);
452453
debug!("walk_chain({:?}): expn_data={:?}", span, expn_data);
453454
span = expn_data.call_site;
454455
}
456+
debug!("walk_chain: for span {:?} >>> return span = {:?}", orig_span, span);
455457
span
456458
}
457459

460+
// We need to walk up and update return span if we meet macro instantiation to be collapsed
461+
fn walk_chain_collapsed(&self, mut span: Span, to: Span, attr_enabled: bool) -> Span {
462+
let orig_span = span;
463+
let mut ret_span = span;
464+
465+
debug!("walk_chain_collapsed({:?}, {:?})", span, to);
466+
debug!("walk_chain_collapsed: span ctxt = {:?}", span.ctxt());
467+
while !span.eq_ctxt(to) && span.from_expansion() {
468+
let outer_expn = self.outer_expn(span.ctxt());
469+
debug!("walk_chain_collapsed({:?}): outer_expn={:?}", span, outer_expn);
470+
let expn_data = self.expn_data(outer_expn);
471+
debug!("walk_chain_collapsed({:?}): expn_data={:?}", span, expn_data);
472+
span = expn_data.call_site;
473+
if !attr_enabled || expn_data.collapse_debuginfo {
474+
ret_span = span;
475+
}
476+
}
477+
debug!("walk_chain_collapsed: for span {:?} >>> return span = {:?}", orig_span, ret_span);
478+
ret_span
479+
}
480+
458481
fn adjust(&self, ctxt: &mut SyntaxContext, expn_id: ExpnId) -> Option<ExpnId> {
459482
let mut scope = None;
460483
while !self.is_descendant_of(expn_id, self.outer_expn(*ctxt)) {
@@ -571,6 +594,10 @@ pub fn walk_chain(span: Span, to: SyntaxContext) -> Span {
571594
HygieneData::with(|data| data.walk_chain(span, to))
572595
}
573596

597+
pub fn walk_chain_collapsed(span: Span, to: Span, attr_enabled: bool) -> Span {
598+
HygieneData::with(|hdata| hdata.walk_chain_collapsed(span, to, attr_enabled))
599+
}
600+
574601
pub fn update_dollar_crate_names(mut get_name: impl FnMut(SyntaxContext) -> Symbol) {
575602
// The new contexts that need updating are at the end of the list and have `$crate` as a name.
576603
let (len, to_update) = HygieneData::with(|data| {

‎compiler/rustc_span/src/lib.rs

-7
Original file line numberDiff line numberDiff line change
@@ -568,13 +568,6 @@ impl Span {
568568
self.ctxt() != SyntaxContext::root()
569569
}
570570

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

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

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

0 commit comments

Comments
 (0)