Re: [PATCH v3 1/6] ctf, btf: restructure CTF/BTF emission

[Indu Bhagat <indu.bhagat@oracle.com>]

On 5/30/24 14:32, 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),
>      for all targets in non-LTO builds, rather than being emitted at
>      early_finish for targets other than BPF CO-RE.  In LTO builds,
>      BTF is emitted at early_finish as before.
> 
>      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, because the calculation of the BTF to be
>      emitted is not moved by this patch, only the write-out.
> 
> The changes are transparent to both CTF and BTF emission.
> 

OK.

This will work to keep supporting -flto with BTF (for non-BPF targets) 
and of course -flto with CTF.

One question/nit below.

> 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.  Emit BTF
> 	here for LTO builds.
> 	(ctf_debug_finish): Always call btf_finish here if generating
> 	BTF info in non-LTO builds.
> 	(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 | 65 +++++++++++++++---------------------------------
>   gcc/dwarf2out.cc |  2 --
>   4 files changed, 50 insertions(+), 49 deletions(-)
> 
> diff --git a/gcc/btfout.cc b/gcc/btfout.cc
> index 07f066a47068..1b6a9ed811f0 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.

I am wondering if it is more precise to say that "until after contents 
for the .BTF.ext section are finalized" ? We have already called the 
btf_output () above, which means _some_ CO-RE information is already 
created (like the accessor strings for CO-RE relocs that go in the .BTF 
section).

> +     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 fa188bf2f5a4..e7bd93901cfa 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 dc59569fe560..8f9e2fada9e3 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,27 @@ 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 emitting BTF, start translation to BTF.  */
> +  if (btf_debuginfo_p ())
> +    {
> +      btf_early_finish ();
> +
> +      /* For LTO builds, also emit BTF now.  */
> +      if (flag_lto && !in_lto_p)
> +	btf_finish (filename);
> +    }
> +  else
> +    /* Otherwise, done with the CTF container.  */
> +    ctf_finalize ();
>   }
>   
>   /* Finish CTF/BTF debug info emission.  */
> @@ -1024,11 +1000,10 @@ ctf_debug_early_finish (const char * filename)
>   void
>   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 ());
> +  /* Emit BTF late, unless this is an LTO build in which case it was
> +     already done early.  */
> +  if (btf_debuginfo_p () && !flag_lto)
> +    btf_finish (filename);
>   }
>   
>   #include "gt-dwarf2ctf.h"
> diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc
> index 5b064ffd78ad..e406df8673ce 100644
> --- a/gcc/dwarf2out.cc
> +++ b/gcc/dwarf2out.cc
> @@ -33202,8 +33202,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);
>       }