| Message ID | 20240502171132.95601-2-david.faust@oracle.com |
|---|---|
| State | New |
| Headers | show |
| Series | btf: refactor and add pruning option | expand |
On 5/2/24 10:11, David Faust wrote: > This commit makes some structural changes to the CTF/BTF debug info > emission. In particular: > > a) CTF is new always fully generated and emitted before any > BTF-related procedures are run. This means that BTF-related > functions can change, even irreversibly, the shared in-memory > representation used by the two formats without issue. > > b) BTF generation has fewer entry points, and is cleanly divided > into early_finish and finish. > > c) BTF is now always emitted at finish (called from dwarf2out_finish), > rather than being emitted at early_finish for targets other than > BPF CO-RE. Note that this change alone does not alter the contents > of BTF at all, regardless of whether it would have previously been > emitted at early_finish or finish. > This will necessitate that we disallow -gbtf with -flto for non-BPF targets. Emitting BTF always at dwarf2out_finish will not work with LTO. > The changes are transparent to both CTF and BTF emission. > > gcc/ > * btfout.cc (btf_init_postprocess): Rename to... > (btf_early_finish): ...this. > (btf_output): Rename to... > (btf_finish): ...this. > * ctfc.h: Analogous changes. > * dwarf2ctf.cc (ctf_debug_early_finish): Conditionally call > btf_early_finish or ctf_finalize as appropriate. > (ctf_debug_finish): Always call btf_finish here if generating > BTF info. > (ctf_debug_finalize, ctf_debug_init_postprocess): Delete. > * dwarf2out.cc (dwarf2out_early_finish): Remove call to > ctf_debug_init_postprocess. > --- > gcc/btfout.cc | 28 +++++++++++++++++++++++++ > gcc/ctfc.h | 4 ++-- > gcc/dwarf2ctf.cc | 54 +++++++++++------------------------------------- > gcc/dwarf2out.cc | 2 -- > 4 files changed, 42 insertions(+), 46 deletions(-) > > diff --git a/gcc/btfout.cc b/gcc/btfout.cc > index 07f066a4706..1b6a9ed811f 100644 > --- a/gcc/btfout.cc > +++ b/gcc/btfout.cc > @@ -1491,6 +1491,34 @@ btf_finalize (void) > tu_ctfc = NULL; > } > > +/* Initial entry point of BTF generation, called at early_finish () after > + CTF information has possibly been output. Translate all CTF information > + to BTF, and do any processing that must be done early, such as creating > + BTF_KIND_FUNC records. */ > + > +void > +btf_early_finish (void) > +{ > + btf_init_postprocess (); > +} > + > +/* Late entry point for BTF generation, called from dwarf2out_finish (). > + Complete and emit BTF information. */ > + > +void > +btf_finish (const char * filename) > +{ > + btf_output (filename); > + > + /* If compiling for BPF with CO-RE info, we cannot deallocate until after > + CO-RE information is created, which happens very late in BPF backend. > + Therefore, the deallocation (i.e. btf_finalize ()) is delayed until > + TARGET_ASM_FILE_END for BPF CO-RE. */ > + if (!btf_with_core_debuginfo_p ()) > + btf_finalize (); > +} > + > + > /* Traversal function for all BTF_KIND_FUNC type records. */ > > bool > diff --git a/gcc/ctfc.h b/gcc/ctfc.h > index fa188bf2f5a..e7bd93901cf 100644 > --- a/gcc/ctfc.h > +++ b/gcc/ctfc.h > @@ -384,8 +384,8 @@ extern void ctf_init (void); > extern void ctf_output (const char * filename); > extern void ctf_finalize (void); > > -extern void btf_output (const char * filename); > -extern void btf_init_postprocess (void); > +extern void btf_early_finish (void); > +extern void btf_finish (const char * filename); > extern void btf_finalize (void); > > extern ctf_container_ref ctf_get_tu_ctfc (void); > diff --git a/gcc/dwarf2ctf.cc b/gcc/dwarf2ctf.cc > index dc59569fe56..ec94982e4b1 100644 > --- a/gcc/dwarf2ctf.cc > +++ b/gcc/dwarf2ctf.cc > @@ -933,30 +933,6 @@ gen_ctf_type (ctf_container_ref ctfc, dw_die_ref die) > return type_id; > } > > -/* Prepare for output and write out the CTF debug information. */ > - > -static void > -ctf_debug_finalize (const char *filename, bool btf) > -{ > - if (btf) > - { > - btf_output (filename); > - /* btf_finalize when compiling BPF applciations gets deallocated by the > - BPF target in bpf_file_end. */ > - if (btf_debuginfo_p () && !btf_with_core_debuginfo_p ()) > - btf_finalize (); > - } > - > - else > - { > - /* Emit the collected CTF information. */ > - ctf_output (filename); > - > - /* Reset the CTF state. */ > - ctf_finalize (); > - } > -} > - > bool > ctf_do_die (dw_die_ref die) > { > @@ -996,27 +972,21 @@ ctf_debug_init (void) > add_name_attribute (ctf_unknown_die, "unknown"); > } > > -/* Preprocess the CTF debug information after initialization. */ > - > -void > -ctf_debug_init_postprocess (bool btf) > -{ > - /* Only BTF requires postprocessing right after init. */ > - if (btf) > - btf_init_postprocess (); > -} > - > /* Early finish CTF/BTF debug info. */ > > void > ctf_debug_early_finish (const char * filename) > { > - /* Emit CTF debug info early always. */ > - if (ctf_debug_info_level > CTFINFO_LEVEL_NONE > - /* Emit BTF debug info early if CO-RE relocations are not > - required. */ > - || (btf_debuginfo_p () && !btf_with_core_debuginfo_p ())) > - ctf_debug_finalize (filename, btf_debuginfo_p ()); > + /* Emit the collected CTF information. */ > + if (ctf_debug_info_level > CTFINFO_LEVEL_NONE) > + ctf_output (filename); > + > + if (btf_debuginfo_p ()) > + /* If BTF will also be emitted, start translation to BTF. */ > + btf_early_finish (); > + else > + /* Otherwise, done with the CTF container. */ > + ctf_finalize (); > } > > /* Finish CTF/BTF debug info emission. */ > @@ -1027,8 +997,8 @@ ctf_debug_finish (const char * filename) > /* Emit BTF debug info here when CO-RE relocations need to be generated. > BTF with CO-RE relocations needs to be generated when CO-RE is in effect > for the BPF target. */ > - if (btf_debuginfo_p () && btf_with_core_debuginfo_p ()) > - ctf_debug_finalize (filename, btf_debuginfo_p ()); > + if (btf_debuginfo_p ()) > + btf_finish (filename); > } > > #include "gt-dwarf2ctf.h" > diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc > index 1b0e8b5a5b2..1664934ccc3 100644 > --- a/gcc/dwarf2out.cc > +++ b/gcc/dwarf2out.cc > @@ -33168,8 +33168,6 @@ dwarf2out_early_finish (const char *filename) > ctf_debug_do_cu (comp_unit_die ()); > for (limbo_die_node *node = limbo_die_list; node; node = node->next) > ctf_debug_do_cu (node->die); > - /* Post process the debug data in the CTF container if necessary. */ > - ctf_debug_init_postprocess (btf_debuginfo_p ()); > > ctf_debug_early_finish (filename); > }
On 5/3/24 2:02 PM, Indu Bhagat wrote: > On 5/2/24 10:11, David Faust wrote: >> This commit makes some structural changes to the CTF/BTF debug info >> emission. In particular: >> >> a) CTF is new always fully generated and emitted before any >> BTF-related procedures are run. This means that BTF-related >> functions can change, even irreversibly, the shared in-memory >> representation used by the two formats without issue. >> >> b) BTF generation has fewer entry points, and is cleanly divided >> into early_finish and finish. >> >> c) BTF is now always emitted at finish (called from dwarf2out_finish), >> rather than being emitted at early_finish for targets other than >> BPF CO-RE. Note that this change alone does not alter the contents >> of BTF at all, regardless of whether it would have previously been >> emitted at early_finish or finish. >> > > This will necessitate that we disallow -gbtf with -flto for non-BPF > targets. Emitting BTF always at dwarf2out_finish will not work with LTO. Yes, you're right. I was not thinking about LTO when I wrote this. I suppose the obvious fix is to undo "c)" above. That change is not really strictly necessary for the rest of the refactor in this series, though we would lose the fix for PR debug/113566 in patch 4, since fixing that requires us to generate some of the BTF at late finish time. Then BTF emission would be the same as it is currently: BTF for BPF target, non-LTO -> (late) finish BTF for BPF target, LTO -> forbidden by BPF back-end BTF for non-BPF target -> early_finish Alternatively, we could undo "c)" only for LTO builds, i.e.: BTF for BPF target non-LTO -> (late) finish BTF for BPF target, LTO -> forbidden by BPF back-end BTF for other targets, non-LTO -> (late) finish BTF for other targets, LTO -> early_finish which would allow fixing debug/113566 for non-LTO builds. Then the differences in BTF related to debug/113566 should only appear between LTO and non-LTO builds, rather than between BPF and non-BPF targets. IMO the latter (move emission back to early_finish for LTO builds) is a little better. Either way, I think the majority of code related to BTF generation from later in this series should not need to change much if at all - only whether those routines end up called at early or late finish. > >> The changes are transparent to both CTF and BTF emission. >> >> gcc/ >> * btfout.cc (btf_init_postprocess): Rename to... >> (btf_early_finish): ...this. >> (btf_output): Rename to... >> (btf_finish): ...this. >> * ctfc.h: Analogous changes. >> * dwarf2ctf.cc (ctf_debug_early_finish): Conditionally call >> btf_early_finish or ctf_finalize as appropriate. >> (ctf_debug_finish): Always call btf_finish here if generating >> BTF info. >> (ctf_debug_finalize, ctf_debug_init_postprocess): Delete. >> * dwarf2out.cc (dwarf2out_early_finish): Remove call to >> ctf_debug_init_postprocess. >> --- >> gcc/btfout.cc | 28 +++++++++++++++++++++++++ >> gcc/ctfc.h | 4 ++-- >> gcc/dwarf2ctf.cc | 54 +++++++++++------------------------------------- >> gcc/dwarf2out.cc | 2 -- >> 4 files changed, 42 insertions(+), 46 deletions(-) >> >> diff --git a/gcc/btfout.cc b/gcc/btfout.cc >> index 07f066a4706..1b6a9ed811f 100644 >> --- a/gcc/btfout.cc >> +++ b/gcc/btfout.cc >> @@ -1491,6 +1491,34 @@ btf_finalize (void) >> tu_ctfc = NULL; >> } >> >> +/* Initial entry point of BTF generation, called at early_finish () after >> + CTF information has possibly been output. Translate all CTF information >> + to BTF, and do any processing that must be done early, such as creating >> + BTF_KIND_FUNC records. */ >> + >> +void >> +btf_early_finish (void) >> +{ >> + btf_init_postprocess (); >> +} >> + >> +/* Late entry point for BTF generation, called from dwarf2out_finish (). >> + Complete and emit BTF information. */ >> + >> +void >> +btf_finish (const char * filename) >> +{ >> + btf_output (filename); >> + >> + /* If compiling for BPF with CO-RE info, we cannot deallocate until after >> + CO-RE information is created, which happens very late in BPF backend. >> + Therefore, the deallocation (i.e. btf_finalize ()) is delayed until >> + TARGET_ASM_FILE_END for BPF CO-RE. */ >> + if (!btf_with_core_debuginfo_p ()) >> + btf_finalize (); >> +} >> + >> + >> /* Traversal function for all BTF_KIND_FUNC type records. */ >> >> bool >> diff --git a/gcc/ctfc.h b/gcc/ctfc.h >> index fa188bf2f5a..e7bd93901cf 100644 >> --- a/gcc/ctfc.h >> +++ b/gcc/ctfc.h >> @@ -384,8 +384,8 @@ extern void ctf_init (void); >> extern void ctf_output (const char * filename); >> extern void ctf_finalize (void); >> >> -extern void btf_output (const char * filename); >> -extern void btf_init_postprocess (void); >> +extern void btf_early_finish (void); >> +extern void btf_finish (const char * filename); >> extern void btf_finalize (void); >> >> extern ctf_container_ref ctf_get_tu_ctfc (void); >> diff --git a/gcc/dwarf2ctf.cc b/gcc/dwarf2ctf.cc >> index dc59569fe56..ec94982e4b1 100644 >> --- a/gcc/dwarf2ctf.cc >> +++ b/gcc/dwarf2ctf.cc >> @@ -933,30 +933,6 @@ gen_ctf_type (ctf_container_ref ctfc, dw_die_ref die) >> return type_id; >> } >> >> -/* Prepare for output and write out the CTF debug information. */ >> - >> -static void >> -ctf_debug_finalize (const char *filename, bool btf) >> -{ >> - if (btf) >> - { >> - btf_output (filename); >> - /* btf_finalize when compiling BPF applciations gets deallocated by the >> - BPF target in bpf_file_end. */ >> - if (btf_debuginfo_p () && !btf_with_core_debuginfo_p ()) >> - btf_finalize (); >> - } >> - >> - else >> - { >> - /* Emit the collected CTF information. */ >> - ctf_output (filename); >> - >> - /* Reset the CTF state. */ >> - ctf_finalize (); >> - } >> -} >> - >> bool >> ctf_do_die (dw_die_ref die) >> { >> @@ -996,27 +972,21 @@ ctf_debug_init (void) >> add_name_attribute (ctf_unknown_die, "unknown"); >> } >> >> -/* Preprocess the CTF debug information after initialization. */ >> - >> -void >> -ctf_debug_init_postprocess (bool btf) >> -{ >> - /* Only BTF requires postprocessing right after init. */ >> - if (btf) >> - btf_init_postprocess (); >> -} >> - >> /* Early finish CTF/BTF debug info. */ >> >> void >> ctf_debug_early_finish (const char * filename) >> { >> - /* Emit CTF debug info early always. */ >> - if (ctf_debug_info_level > CTFINFO_LEVEL_NONE >> - /* Emit BTF debug info early if CO-RE relocations are not >> - required. */ >> - || (btf_debuginfo_p () && !btf_with_core_debuginfo_p ())) >> - ctf_debug_finalize (filename, btf_debuginfo_p ()); >> + /* Emit the collected CTF information. */ >> + if (ctf_debug_info_level > CTFINFO_LEVEL_NONE) >> + ctf_output (filename); >> + >> + if (btf_debuginfo_p ()) >> + /* If BTF will also be emitted, start translation to BTF. */ >> + btf_early_finish (); >> + else >> + /* Otherwise, done with the CTF container. */ >> + ctf_finalize (); >> } >> >> /* Finish CTF/BTF debug info emission. */ >> @@ -1027,8 +997,8 @@ ctf_debug_finish (const char * filename) >> /* Emit BTF debug info here when CO-RE relocations need to be generated. >> BTF with CO-RE relocations needs to be generated when CO-RE is in effect >> for the BPF target. */ >> - if (btf_debuginfo_p () && btf_with_core_debuginfo_p ()) >> - ctf_debug_finalize (filename, btf_debuginfo_p ()); >> + if (btf_debuginfo_p ()) >> + btf_finish (filename); >> } >> >> #include "gt-dwarf2ctf.h" >> diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc >> index 1b0e8b5a5b2..1664934ccc3 100644 >> --- a/gcc/dwarf2out.cc >> +++ b/gcc/dwarf2out.cc >> @@ -33168,8 +33168,6 @@ dwarf2out_early_finish (const char *filename) >> ctf_debug_do_cu (comp_unit_die ()); >> for (limbo_die_node *node = limbo_die_list; node; node = node->next) >> ctf_debug_do_cu (node->die); >> - /* Post process the debug data in the CTF container if necessary. */ >> - ctf_debug_init_postprocess (btf_debuginfo_p ()); >> >> ctf_debug_early_finish (filename); >> } >
diff --git a/gcc/btfout.cc b/gcc/btfout.cc index 07f066a4706..1b6a9ed811f 100644 --- a/gcc/btfout.cc +++ b/gcc/btfout.cc @@ -1491,6 +1491,34 @@ btf_finalize (void) tu_ctfc = NULL; } +/* Initial entry point of BTF generation, called at early_finish () after + CTF information has possibly been output. Translate all CTF information + to BTF, and do any processing that must be done early, such as creating + BTF_KIND_FUNC records. */ + +void +btf_early_finish (void) +{ + btf_init_postprocess (); +} + +/* Late entry point for BTF generation, called from dwarf2out_finish (). + Complete and emit BTF information. */ + +void +btf_finish (const char * filename) +{ + btf_output (filename); + + /* If compiling for BPF with CO-RE info, we cannot deallocate until after + CO-RE information is created, which happens very late in BPF backend. + Therefore, the deallocation (i.e. btf_finalize ()) is delayed until + TARGET_ASM_FILE_END for BPF CO-RE. */ + if (!btf_with_core_debuginfo_p ()) + btf_finalize (); +} + + /* Traversal function for all BTF_KIND_FUNC type records. */ bool diff --git a/gcc/ctfc.h b/gcc/ctfc.h index fa188bf2f5a..e7bd93901cf 100644 --- a/gcc/ctfc.h +++ b/gcc/ctfc.h @@ -384,8 +384,8 @@ extern void ctf_init (void); extern void ctf_output (const char * filename); extern void ctf_finalize (void); -extern void btf_output (const char * filename); -extern void btf_init_postprocess (void); +extern void btf_early_finish (void); +extern void btf_finish (const char * filename); extern void btf_finalize (void); extern ctf_container_ref ctf_get_tu_ctfc (void); diff --git a/gcc/dwarf2ctf.cc b/gcc/dwarf2ctf.cc index dc59569fe56..ec94982e4b1 100644 --- a/gcc/dwarf2ctf.cc +++ b/gcc/dwarf2ctf.cc @@ -933,30 +933,6 @@ gen_ctf_type (ctf_container_ref ctfc, dw_die_ref die) return type_id; } -/* Prepare for output and write out the CTF debug information. */ - -static void -ctf_debug_finalize (const char *filename, bool btf) -{ - if (btf) - { - btf_output (filename); - /* btf_finalize when compiling BPF applciations gets deallocated by the - BPF target in bpf_file_end. */ - if (btf_debuginfo_p () && !btf_with_core_debuginfo_p ()) - btf_finalize (); - } - - else - { - /* Emit the collected CTF information. */ - ctf_output (filename); - - /* Reset the CTF state. */ - ctf_finalize (); - } -} - bool ctf_do_die (dw_die_ref die) { @@ -996,27 +972,21 @@ ctf_debug_init (void) add_name_attribute (ctf_unknown_die, "unknown"); } -/* Preprocess the CTF debug information after initialization. */ - -void -ctf_debug_init_postprocess (bool btf) -{ - /* Only BTF requires postprocessing right after init. */ - if (btf) - btf_init_postprocess (); -} - /* Early finish CTF/BTF debug info. */ void ctf_debug_early_finish (const char * filename) { - /* Emit CTF debug info early always. */ - if (ctf_debug_info_level > CTFINFO_LEVEL_NONE - /* Emit BTF debug info early if CO-RE relocations are not - required. */ - || (btf_debuginfo_p () && !btf_with_core_debuginfo_p ())) - ctf_debug_finalize (filename, btf_debuginfo_p ()); + /* Emit the collected CTF information. */ + if (ctf_debug_info_level > CTFINFO_LEVEL_NONE) + ctf_output (filename); + + if (btf_debuginfo_p ()) + /* If BTF will also be emitted, start translation to BTF. */ + btf_early_finish (); + else + /* Otherwise, done with the CTF container. */ + ctf_finalize (); } /* Finish CTF/BTF debug info emission. */ @@ -1027,8 +997,8 @@ ctf_debug_finish (const char * filename) /* Emit BTF debug info here when CO-RE relocations need to be generated. BTF with CO-RE relocations needs to be generated when CO-RE is in effect for the BPF target. */ - if (btf_debuginfo_p () && btf_with_core_debuginfo_p ()) - ctf_debug_finalize (filename, btf_debuginfo_p ()); + if (btf_debuginfo_p ()) + btf_finish (filename); } #include "gt-dwarf2ctf.h" diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc index 1b0e8b5a5b2..1664934ccc3 100644 --- a/gcc/dwarf2out.cc +++ b/gcc/dwarf2out.cc @@ -33168,8 +33168,6 @@ dwarf2out_early_finish (const char *filename) ctf_debug_do_cu (comp_unit_die ()); for (limbo_die_node *node = limbo_die_list; node; node = node->next) ctf_debug_do_cu (node->die); - /* Post process the debug data in the CTF container if necessary. */ - ctf_debug_init_postprocess (btf_debuginfo_p ()); ctf_debug_early_finish (filename); }
This commit makes some structural changes to the CTF/BTF debug info emission. In particular: a) CTF is new always fully generated and emitted before any BTF-related procedures are run. This means that BTF-related functions can change, even irreversibly, the shared in-memory representation used by the two formats without issue. b) BTF generation has fewer entry points, and is cleanly divided into early_finish and finish. c) BTF is now always emitted at finish (called from dwarf2out_finish), rather than being emitted at early_finish for targets other than BPF CO-RE. Note that this change alone does not alter the contents of BTF at all, regardless of whether it would have previously been emitted at early_finish or finish. The changes are transparent to both CTF and BTF emission. gcc/ * btfout.cc (btf_init_postprocess): Rename to... (btf_early_finish): ...this. (btf_output): Rename to... (btf_finish): ...this. * ctfc.h: Analogous changes. * dwarf2ctf.cc (ctf_debug_early_finish): Conditionally call btf_early_finish or ctf_finalize as appropriate. (ctf_debug_finish): Always call btf_finish here if generating BTF info. (ctf_debug_finalize, ctf_debug_init_postprocess): Delete. * dwarf2out.cc (dwarf2out_early_finish): Remove call to ctf_debug_init_postprocess. --- gcc/btfout.cc | 28 +++++++++++++++++++++++++ gcc/ctfc.h | 4 ++-- gcc/dwarf2ctf.cc | 54 +++++++++++------------------------------------- gcc/dwarf2out.cc | 2 -- 4 files changed, 42 insertions(+), 46 deletions(-)