PR debug/12389

	* Makefile.in (dwarf2out.o): Depend on cgraph.h.
	* cgraph.c (cgraph_function_possibly_inlined_p): New function.
	* cgraph.h (cgraph_function_possibly_inlined_p): Declare.
	(cgraph_global_info): Add flag inlined
	* dwarf2out.c (gen_subprogram_die, gen_decl_die): Use
	cgraph_function_possibly_inded_p
	* cgraphunit.c (mark_inline): Set inlined flag.
	* toplev.c (rest_of_decl_compilation): Call outlining_inline_function
	only for possibly inlined functions.
	* c-decl.c (duplicate_decls): Never output abstract DIE representing old
	body of function.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@72795 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 32d6208..badc59e 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,18 @@
+2003-10-22  Jan Hubicka  <jh@suse.cz>
+
+       PR debug/12389
+       * Makefile.in (dwarf2out.o): Depend on cgraph.h.
+       * cgraph.c (cgraph_function_possibly_inlined_p): New function.
+       * cgraph.h (cgraph_function_possibly_inlined_p): Declare.
+       (cgraph_global_info): Add flag inlined
+       * dwarf2out.c (gen_subprogram_die, gen_decl_die): Use
+       cgraph_function_possibly_inded_p
+       * cgraphunit.c (mark_inline): Set inlined flag.
+       * toplev.c (rest_of_decl_compilation): Call outlining_inline_function
+       only for possibly inlined functions.
+       * c-decl.c (duplicate_decls): Never output abstract DIE representing old
+       body of function.
+
 2003-10-22  Andrew Haley  <aph@redhat.com>
 
        * varasm.c (output_constructor): Make constructor annotation

diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 4f28e80..0b89ddd 100644 (file)
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1586,7 +1586,7 @@ dwarf2out.o : dwarf2out.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H)
    $(RTL_H) dwarf2.h debug.h flags.h insn-config.h reload.h output.h $(DIAGNOSTIC_H) real.h \
    hard-reg-set.h $(REGS_H) $(EXPR_H) libfuncs.h toplev.h dwarf2out.h varray.h \
    $(GGC_H) except.h dwarf2asm.h $(TM_P_H) langhooks.h $(HASHTAB_H) \
-   gt-dwarf2out.h $(TARGET_H)
+   gt-dwarf2out.h $(TARGET_H) cgraph.h
 dwarf2asm.o : dwarf2asm.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) flags.h $(RTL_H) \
    $(TREE_H) output.h dwarf2asm.h $(TM_P_H) $(GGC_H) gt-dwarf2asm.h
 vmsdbgout.o : vmsdbgout.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \

diff --git a/gcc/c-decl.c b/gcc/c-decl.c
index 7880f7f..93ce347 100644 (file)
--- a/gcc/c-decl.c
+++ b/gcc/c-decl.c
@@ -1406,7 +1406,10 @@ duplicate_decls (tree newdecl, tree olddecl, int different_binding_level,
         been written out yet.  */
       if (new_is_definition && DECL_INITIAL (olddecl))
        {
-         if (TREE_USED (olddecl))
+         if (TREE_USED (olddecl)
+             /* In unit-at-a-time mode we never inline re-defined extern
+                inline functions. */
+             && !flag_unit_at_a_time)
            (*debug_hooks->outlining_inline_function) (olddecl);
 
          /* The new defn must not be inline.  */

diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index eedbd9e..b28d9f3 100644 (file)
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -531,5 +531,15 @@ cgraph_varpool_assemble_pending_decls (void)
   return changed;
 }
 
+/* Return true when the DECL can possibly be inlined.  */
+bool
+cgraph_function_possibly_inlined_p (tree decl)
+{
+  if (!flag_unit_at_a_time)
+    return (DECL_INLINE (decl) && !flag_no_inline);
+  if (!cgraph_global_info_ready)
+    abort ();
+  return cgraph_node (decl)->global.inlined;
+}
 
 #include "gt-cgraph.h"

diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index 9bdbfdc..a37227e 100644 (file)
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -59,6 +59,9 @@ struct cgraph_global_info GTY(())
      Once we inline all calls to the function and the function is local,
      it is set to false.  */
   bool will_be_output;
+
+  /* Set iff at least one of the caller edges has inline_call flag set.  */
+  bool inlined;
 };
 
 /* Information about the function that is propagated by the RTL backend.
@@ -168,6 +171,8 @@ void cgraph_varpool_mark_needed_node (struct cgraph_varpool_node *);
 void cgraph_varpool_finalize_decl (tree);
 bool cgraph_varpool_assemble_pending_decls (void);
 
+bool cgraph_function_possibly_inlined_p (tree);
+
 /* In cgraphunit.c  */
 bool cgraph_assemble_pending_functions (void);
 void cgraph_finalize_function (tree, bool);

diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index c20367d..673419f 100644 (file)
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -833,6 +833,7 @@ cgraph_mark_inline (struct cgraph_node *to, struct cgraph_node *what,
   bool called = false;
   int new_insns;
 
+  what->global.inlined = 1;
   for (e = what->callers; e; e = e->next_caller)
     {
       if (e->caller == to)

diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 2642e81..32b9332 100644 (file)
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -64,6 +64,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "target.h"
 #include "langhooks.h"
 #include "hashtab.h"
+#include "cgraph.h"
 
 #ifdef DWARF2_DEBUGGING_INFO
 static void dwarf2out_source_line (unsigned int, const char *);
@@ -10685,20 +10686,20 @@ gen_subprogram_die (tree decl, dw_die_ref context_die)
     }
   else if (DECL_ABSTRACT (decl))
     {
-      if (DECL_INLINE (decl) && !flag_no_inline)
+      if (DECL_DECLARED_INLINE_P (decl))
        {
-         /* ??? Checking DECL_DEFER_OUTPUT is correct for static
-            inline functions, but not for extern inline functions.
-            We can't get this completely correct because information
-            about whether the function was declared inline is not
-            saved anywhere.  */
-         if (DECL_DEFER_OUTPUT (decl))
+          if (cgraph_function_possibly_inlined_p (decl))
            add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
          else
-           add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
+           add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
        }
       else
-       add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
+       {
+         if (cgraph_function_possibly_inlined_p (decl))
+            add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
+         else
+           abort ();
+       }
 
       equate_decl_number_to_die (decl, subr_die);
     }
@@ -11800,7 +11801,8 @@ gen_decl_die (tree decl, dw_die_ref context_die)
 
       /* If we're emitting an out-of-line copy of an inline function,
         emit info for the abstract instance and set up to refer to it.  */
-      else if (DECL_INLINE (decl) && ! DECL_ABSTRACT (decl)
+      else if (cgraph_function_possibly_inlined_p (decl)
+              && ! DECL_ABSTRACT (decl)
               && ! class_scope_p (context_die)
               /* dwarf2out_abstract_function won't emit a die if this is just
                  a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in

diff --git a/gcc/toplev.c b/gcc/toplev.c
index a393c52..219c699 100644 (file)
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -3177,7 +3177,7 @@ rest_of_compilation (tree decl)
   /* We are now committed to emitting code for this function.  Do any
      preparation, such as emitting abstract debug info for the inline
      before it gets mangled by optimization.  */
-  if (DECL_INLINE (decl))
+  if (cgraph_function_possibly_inlined_p (decl))
     (*debug_hooks->outlining_inline_function) (decl);
 
   /* Remove any notes we don't need.  That will make iterating