+2002-02-26 Alexandre Oliva <aoliva@redhat.com>
+
+ * dwarf2out.c (gen_inlined_subroutine_die): If block is abstract,
+ generate a die for the lexical block.
+
2002-02-26 Kazu Hirata <kazu@hxi.com>
* config/h8300/h8300-protos.h: Add a prototype for
decls_for_scope (stmt, subr_die, depth);
current_function_has_inlines = 1;
}
+ else
+ /* We may get here if we're the outer block of function A that was
+ inlined into function B that was inlined into function C. When
+ generating debugging info for C, dwarf2out_abstract_function(B)
+ would mark all inlined blocks as abstract, including this one.
+ So, we wouldn't (and shouldn't) expect labels to be generated
+ for this one. Instead, just emit debugging info for
+ declarations within the block. This is particularly important
+ in the case of initializers of arguments passed from B to us:
+ if they're statement expressions containing declarations, we
+ wouldn't generate dies for their abstract variables, and then,
+ when generating dies for the real variables, we'd die (pun
+ intended :-) */
+ gen_lexical_block_die (stmt, context_die, depth);
}
/* Generate a DIE for a field in a record, or structure. */
+2002-02-26 Alexandre Oliva <aoliva@redhat.com>
+
+ * gcc.dg/debug/20020224-1.c: New.
+
2002-02-25 Kazu Hirata <kazu@hxi.com>
* gcc.c-torture/execute/960416-1.x: New.
--- /dev/null
+/* { dg-do compile } */
+
+/* Here's the deal: f3 is not inlined because it's too big, but f2 and
+ f1 are inlined into it. We used to fail to emit debugging info for
+ t1, because it was moved inside the (inlined) block of f1, marked
+ as abstract, then we'd crash. */
+
+#define UNUSED __attribute__((unused))
+#define EXT __extension__
+
+int undef(void);
+
+inline static void
+f1 (int i UNUSED)
+{
+}
+
+inline static void
+f2 (void)
+{
+ f1 (EXT ({ int t1 UNUSED; undef (); }));
+}
+
+inline static void
+f3 (void)
+{
+ int v1 UNUSED;
+ int v2 UNUSED;
+
+ EXT ({ int t2 UNUSED; if (0) undef (); 0; })
+ && EXT ({ int t3 UNUSED; if (0) undef (); 0; });
+
+ if (1)
+ {
+ undef ();
+ if (1)
+ f2 ();
+ }
+
+ {
+ undef ();
+ }
+}
+
+inline static void
+f4 (void)
+{
+ EXT ({ undef (); 1; }) && EXT ({ int t4 UNUSED = ({ 1; }); 1; });
+
+ { }
+
+ EXT ({ int t5 UNUSED; if (0) undef (); 0; });
+
+ f4 ();
+
+ undef ();
+ f3 ();
+
+ return;
+}