DWARF: make it possible to emit debug info for declarations only

The DWARF back-end used to systematically ignore file-scope function and
variable declarations.  While this is justified in language like C/C++,
where such declarations can appear in several translation units and thus
bloat uselessly the debug info, this behavior is counter-productive in
languages with a well-defined module system.  Specifically, it prevents
the description of imported entities, that belong to foreign languages,
making them unavailable from debuggers.

Take for instance:

    package C_Binding is
        function My_C_Function (I : Integer) return Integer;
        pragma Import (C, My_C_Function, "my_c_function");
    end C_Binding;

This makes available for Ada programs the C function "my_c_function"
under the following name: C_Binding.My_C_Function.  When GCC compiles
it, though, it is represented as a FUNCTION_DECL node with DECL_EXTERNAL
set and a null DECL_INITIAL, which used to be discarded unconditionally
in the DWARF back-end.

This patch moves such filter from the DWARF back-end to the relevant
callers: passes.c:rest_of_decl_compilation and
godump.c:go_early_global_decl. It also This patch also updates the Ada
front-end to call debug hooks for functions such as in the above
example, so that we do generate debugging information for them.

gcc/
	* dwarf2out.c (gen_decl_die): Remove the guard to skip file-scope
	FUNCTION_DECL declarations.
	(dwarf2out_early_global_decl): Remove the guard to skip FUNCTION_DECL
	declarations.
	(dwaf2out_decl): Likewise.
	* godump.c (go_early_global_decl): Skip call to the real debug hook
	for FUNCTION_DECL declarations.
	* passes.c (rest_of_decl_compilation): Skip call to the
	early_global_decl debug hook for FUNCTION_DECL declarations, unless
	-fdump-go-spec is passed.

gcc/ada/
	* gcc-interface/ada-tree.h (DECL_FUNCTION_IS_DEF): Update copyright
	notice.  New macro.
	* gcc-interface/trans.c (Subprogram_Body_to_gnu): Tag the subprogram
	as a definition.
	(Compilation_Unit_to_gnu): Tag the elaboration procedure as a
	definition.
	* gcc-interface/decl.c (gnat_to_gnu_entity): Tag declarations of
	imported subprograms for the current compilation unit as
	definitions.  Disable debug info for references to variables.
	* gcc-interface/gigi.h (create_subprog_decl): Update declaration.
	* gcc-interface/utils.c (gnat_pushdecl): Add external DECLs that are
	not built-in functions to their binding scope.
	(create_subprog_decl): Add a DEFINITION parameter.  If it is true, tag
	the function as a definition.  Update all callers.
	(gnat_write_global_declarations): Emit debug info for imported
	functions.  Filter out external variables for which debug info
	is disabled.

gcc/testsuite/
	* gnat.dg/debug11_pkg.adb, gnat.dg/debug11_pkg.ads,
	gnat.dg/debug11_pkg2.ads: New testcase.

From-SVN: r249449

1 files changed, 0 insertions, 50 deletions

diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 92444e3..c277d27 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -25289,14 +25289,6 @@ gen_decl_die (tree decl, tree origin, struct vlr_context *ctx,
       break;
 
     case FUNCTION_DECL:
-      /* Don't output any DIEs to represent mere function declarations,
-	 unless they are class members or explicit block externs.  */
-      if (DECL_INITIAL (decl_or_origin) == NULL_TREE
-          && DECL_FILE_SCOPE_P (decl_or_origin)
-	  && (current_function_decl == NULL_TREE
-	      || DECL_ARTIFICIAL (decl_or_origin)))
-	break;
-
 #if 0
       /* FIXME */
       /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
@@ -25501,11 +25493,6 @@ dwarf2out_early_global_decl (tree decl)
       tree save_fndecl = current_function_decl;
       if (TREE_CODE (decl) == FUNCTION_DECL)
 	{
-	  /* No cfun means the symbol has no body, so there's nothing
-	     to emit.  */
-	  if (!DECL_STRUCT_FUNCTION (decl))
-	    goto early_decl_exit;
-
 	  /* For nested functions, make sure we have DIEs for the parents first
 	     so that all nested DIEs are generated at the proper scope in the
 	     first shot.  */
@@ -25522,7 +25509,6 @@ dwarf2out_early_global_decl (tree decl)
       if (TREE_CODE (decl) == FUNCTION_DECL)
 	current_function_decl = save_fndecl;
     }
- early_decl_exit:
   symtab->global_info_ready = save;
 }
 
@@ -25761,42 +25747,6 @@ dwarf2out_decl (tree decl)
       return;
 
     case FUNCTION_DECL:
-      /* What we would really like to do here is to filter out all mere
-	 file-scope declarations of file-scope functions which are never
-	 referenced later within this translation unit (and keep all of ones
-	 that *are* referenced later on) but we aren't clairvoyant, so we have
-	 no idea which functions will be referenced in the future (i.e. later
-	 on within the current translation unit). So here we just ignore all
-	 file-scope function declarations which are not also definitions.  If
-	 and when the debugger needs to know something about these functions,
-	 it will have to hunt around and find the DWARF information associated
-	 with the definition of the function.
-
-	 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
-	 nodes represent definitions and which ones represent mere
-	 declarations.  We have to check DECL_INITIAL instead. That's because
-	 the C front-end supports some weird semantics for "extern inline"
-	 function definitions.  These can get inlined within the current
-	 translation unit (and thus, we need to generate Dwarf info for their
-	 abstract instances so that the Dwarf info for the concrete inlined
-	 instances can have something to refer to) but the compiler never
-	 generates any out-of-lines instances of such things (despite the fact
-	 that they *are* definitions).
-
-	 The important point is that the C front-end marks these "extern
-	 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
-	 them anyway. Note that the C++ front-end also plays some similar games
-	 for inline function definitions appearing within include files which
-	 also contain `#pragma interface' pragmas.
-
-	 If we are called from dwarf2out_abstract_function output a DIE
-	 anyway.  We can end up here this way with early inlining and LTO
-	 where the inlined function is output in a different LTRANS unit
-	 or not at all.  */
-      if (DECL_INITIAL (decl) == NULL_TREE
-	  && ! DECL_ABSTRACT_P (decl))
-	return;
-
       /* If we're a nested function, initially use a parent of NULL; if we're
 	 a plain function, this will be fixed up in decls_for_scope.  If
 	 we're a method, it will be ignored, since we already have a DIE.  */