[PATCH] VLA debug info fix (PR debug/42801, take 2)
Jakub Jelinek
jakub@redhat.com
Tue May 25 14:19:00 GMT 2010
On Mon, May 24, 2010 at 04:40:26PM -0400, Jason Merrill wrote:
> Rather than duplicate the existing add_type_attribute code, please
> just change its conditions.
Here is an updated patch, bootstrapped/regtested on x86_64-linux and
i686-linux.
2010-05-25 Jakub Jelinek <jakub@redhat.com>
PR debug/42801
* tree-inline.c (remap_decls): Remap DECL_VALUE_EXPR here...
(copy_bind_expr): ... instead of here.
(copy_tree_body_r): If id->remapping_type_depth clear TREE_BLOCK
if the block hasn't been remapped.
* dwarf2out.c (gen_formal_parameter_die, gen_variable_die): When
emitting concrete instance of abstract VLA, add DW_AT_type attribute.
* gcc.dg/guality/sra-2.c: New test.
--- gcc/tree-inline.c.jj 2010-05-24 17:52:25.000000000 +0200
+++ gcc/tree-inline.c 2010-05-24 18:50:16.000000000 +0200
@@ -574,6 +574,19 @@ remap_decls (tree decls, VEC(tree,gc) **
gcc_assert (DECL_P (new_var));
TREE_CHAIN (new_var) = new_decls;
new_decls = new_var;
+
+ /* Also copy value-expressions. */
+ if (TREE_CODE (new_var) == VAR_DECL
+ && DECL_HAS_VALUE_EXPR_P (new_var))
+ {
+ tree tem = DECL_VALUE_EXPR (new_var);
+ bool old_regimplify = id->regimplify;
+ id->remapping_type_depth++;
+ walk_tree (&tem, copy_tree_body_r, id, NULL);
+ id->remapping_type_depth--;
+ id->regimplify = old_regimplify;
+ SET_DECL_VALUE_EXPR (new_var, tem);
+ }
}
}
@@ -665,23 +678,9 @@ copy_bind_expr (tree *tp, int *walk_subt
}
if (BIND_EXPR_VARS (*tp))
- {
- tree t;
-
- /* This will remap a lot of the same decls again, but this should be
- harmless. */
- BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id);
-
- /* Also copy value-expressions. */
- for (t = BIND_EXPR_VARS (*tp); t; t = TREE_CHAIN (t))
- if (TREE_CODE (t) == VAR_DECL
- && DECL_HAS_VALUE_EXPR_P (t))
- {
- tree tem = DECL_VALUE_EXPR (t);
- walk_tree (&tem, copy_tree_body_r, id, NULL);
- SET_DECL_VALUE_EXPR (t, tem);
- }
- }
+ /* This will remap a lot of the same decls again, but this should be
+ harmless. */
+ BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id);
}
@@ -1116,8 +1115,9 @@ copy_tree_body_r (tree *tp, int *walk_su
tree *n;
n = (tree *) pointer_map_contains (id->decl_map,
TREE_BLOCK (*tp));
- gcc_assert (n);
- new_block = *n;
+ gcc_assert (n || id->remapping_type_depth != 0);
+ if (n)
+ new_block = *n;
}
TREE_BLOCK (*tp) = new_block;
}
--- gcc/dwarf2out.c.jj 2010-05-24 17:52:25.000000000 +0200
+++ gcc/dwarf2out.c 2010-05-25 09:42:28.000000000 +0200
@@ -17906,22 +17906,26 @@ gen_formal_parameter_die (tree node, tre
origin = ultimate_origin;
if (origin != NULL)
add_abstract_origin_attribute (parm_die, origin);
- else
+ else if (emit_name_p)
+ add_name_and_src_coords_attributes (parm_die, node);
+ if (origin == NULL
+ || (! DECL_ABSTRACT (node_or_origin)
+ && variably_modified_type_p (TREE_TYPE (node_or_origin),
+ decl_function_context
+ (node_or_origin))))
{
- tree type = TREE_TYPE (node);
- if (emit_name_p)
- add_name_and_src_coords_attributes (parm_die, node);
- if (decl_by_reference_p (node))
+ tree type = TREE_TYPE (node_or_origin);
+ if (decl_by_reference_p (node_or_origin))
add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
context_die);
else
add_type_attribute (parm_die, type,
- TREE_READONLY (node),
- TREE_THIS_VOLATILE (node),
+ TREE_READONLY (node_or_origin),
+ TREE_THIS_VOLATILE (node_or_origin),
context_die);
- if (DECL_ARTIFICIAL (node))
- add_AT_flag (parm_die, DW_AT_artificial, 1);
}
+ if (origin == NULL && DECL_ARTIFICIAL (node))
+ add_AT_flag (parm_die, DW_AT_artificial, 1);
if (node && node != origin)
equate_decl_number_to_die (node, parm_die);
@@ -18624,8 +18628,9 @@ gen_variable_die (tree decl, tree origin
dw_die_ref var_die;
dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
dw_die_ref origin_die;
- int declaration = (DECL_EXTERNAL (decl_or_origin)
- || class_or_namespace_scope_p (context_die));
+ bool declaration = (DECL_EXTERNAL (decl_or_origin)
+ || class_or_namespace_scope_p (context_die));
+ bool specialization_p = false;
ultimate_origin = decl_ultimate_origin (decl_or_origin);
if (decl || ultimate_origin)
@@ -18769,6 +18774,7 @@ gen_variable_die (tree decl, tree origin
{
/* This is a definition of a C++ class level static. */
add_AT_specification (var_die, old_die);
+ specialization_p = true;
if (DECL_NAME (decl))
{
expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
@@ -18782,16 +18788,26 @@ gen_variable_die (tree decl, tree origin
}
}
else
+ add_name_and_src_coords_attributes (var_die, decl);
+
+ if ((origin == NULL && !specialization_p)
+ || (origin != NULL
+ && !DECL_ABSTRACT (decl_or_origin)
+ && variably_modified_type_p (TREE_TYPE (decl_or_origin),
+ decl_function_context
+ (decl_or_origin))))
{
- tree type = TREE_TYPE (decl);
+ tree type = TREE_TYPE (decl_or_origin);
- add_name_and_src_coords_attributes (var_die, decl);
- if (decl_by_reference_p (decl))
+ if (decl_by_reference_p (decl_or_origin))
add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
else
- add_type_attribute (var_die, type, TREE_READONLY (decl),
- TREE_THIS_VOLATILE (decl), context_die);
+ add_type_attribute (var_die, type, TREE_READONLY (decl_or_origin),
+ TREE_THIS_VOLATILE (decl_or_origin), context_die);
+ }
+ if (origin == NULL && !specialization_p)
+ {
if (TREE_PUBLIC (decl))
add_AT_flag (var_die, DW_AT_external, 1);
--- gcc/testsuite/gcc.dg/guality/sra-2.c.jj 2010-05-24 17:58:30.000000000 +0200
+++ gcc/testsuite/gcc.dg/guality/sra-2.c 2010-05-24 17:58:30.000000000 +0200
@@ -0,0 +1,55 @@
+/* PR debug/42801 */
+/* { dg-do run } */
+/* { dg-options "-g" } */
+
+void __attribute__((noinline))
+fn1 (int *x, int y)
+{
+ asm volatile ("" : : "rm" (x), "rm" (y) : "memory");
+}
+
+static inline __attribute__((always_inline)) int
+fn2 (int i)
+{
+ int a[i];
+ fn1 (a, i);
+ fn1 (a, i); /* { dg-final { gdb-test 16 "sizeof (a)" "5 * sizeof (int)" } } */
+ return i;
+}
+
+static inline __attribute__((always_inline)) int
+fn3 (int i)
+{
+ int a[i];
+ fn1 (a, i);
+ fn1 (a, i); /* { dg-final { gdb-test 25 "sizeof (a)" "6 * sizeof (int)" } } */
+ return i;
+}
+
+static inline __attribute__((always_inline)) int
+fn4 (int i)
+{
+ return fn3 (i);
+}
+
+int __attribute__((noinline))
+fn5 (void)
+{
+ return fn2 (5) + 1;
+}
+
+int __attribute__((noinline))
+fn6 (int i)
+{
+ return fn2 (i + 1) + fn4 (i + 2) + fn4 (i + 2) + 1;
+}
+
+int
+main (void)
+{
+ int x = 4;
+ asm volatile ("" : "+r" (x));
+ fn5 ();
+ fn6 (x);
+ return 0;
+}
Jakub
More information about the Gcc-patches
mailing list