Re: [PATCH v3 6/6] Fortran: Nested functions, add scope parameter.

Yao Qi
2017-09-04T09:58:26Z

On 17-08-11 13:06:51, Tim Wiederhake wrote:
> From: Bernhard Heckel <bernhard.heckel@intel.com>
>
> In order to avoid name clashing in GDB, we add a scope
> to nested subroutines. Enveloping function gives the
> scope.

Hi Tim,
Is there any reason that you split it from patch #5? IMO, both #5 and
#6 should be a single patch, and we need a NEWS entry.

According to your patch #5, I think both Ada and Fortran have the similar
feature here. I think we need to keep semantics same in both languages,
like, "break func::nest_func"?

>
> ---
> gdb/doc/gdb.texinfo | 3 ++
> gdb/dwarf2read.c | 26 +++++++++++-
> gdb/testsuite/gdb.fortran/nested-funcs.exp | 28 +++++++++++--
> gdb/testsuite/gdb.fortran/nested-funcs.f90 | 66 ++++++++++++++++++++++++++++--
> 4 files changed, 114 insertions(+), 9 deletions(-)
> mode change 100755 => 100644 gdb/testsuite/gdb.fortran/nested-funcs.f90
>
> diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
> index d098eba..983a570 100644
> --- a/gdb/doc/gdb.texinfo
> +++ b/gdb/doc/gdb.texinfo
> @@ -15259,6 +15259,9 @@ The access component operator. Normally used to access elements in derived
> types. Also suitable for unions. As unions aren't part of regular Fortran,
> this can only happen when accessing a register that uses a gdbarch-defined
> union type.
> +@item ::
> +The scope operator. Normally used to access variables in modules or to set
> +breakpoints on subroutines nested in modules or in other (internal) subroutines.
> @end table
>
> @node Fortran Defaults
> diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
> index 894e6a0..92a9c49 100644
> --- a/gdb/dwarf2read.c
> +++ b/gdb/dwarf2read.c
> @@ -7042,6 +7042,7 @@ partial_die_parent_scope (struct partial_die_info *pdi,
> return NULL;
> }
>
> + /* Internal (nested) subroutines in Fortran get a prefix. */
> if (pdi->tag == DW_TAG_enumerator)
> /* Enumerators should not get the name of the enumeration as a prefix. */
> parent->scope = grandparent_scope;
> @@ -7051,7 +7052,10 @@ partial_die_parent_scope (struct partial_die_info *pdi,
> || parent->tag == DW_TAG_class_type
> || parent->tag == DW_TAG_interface_type
> || parent->tag == DW_TAG_union_type
> - || parent->tag == DW_TAG_enumeration_type)
> + || parent->tag == DW_TAG_enumeration_type
> + || (cu->language == language_fortran
> + && parent->tag == DW_TAG_subprogram
> + && pdi->tag == DW_TAG_subprogram))
> {
> if (grandparent_scope == NULL)
> parent->scope = parent->name;
> @@ -8560,8 +8564,13 @@ process_die (struct die_info *die, struct dwarf2_cu *cu)
> case DW_TAG_type_unit:
> read_type_unit_scope (die, cu);
> break;
> - case DW_TAG_entry_point:
> case DW_TAG_subprogram:
> + /* Internal subprograms in Fortran get a prefix. */
> + if (cu->language == language_fortran
> + && die->parent != NULL
> + && die->parent->tag == DW_TAG_subprogram)
> + cu->processing_has_namespace_info = 1;

We need some fall-through annotation to suppress warning in GCC 7.

> + case DW_TAG_entry_point:
> case DW_TAG_inlined_subroutine:
> read_func_scope (die, cu);
> break;
> @@ -20169,6 +20178,19 @@ determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
> return TYPE_TAG_NAME (parent_type);
> return "";
> }
> + case DW_TAG_subprogram:
> + /* Only internal subroutines in Fortran get a prefix with the name
> + of the parent's subroutine. */
> + if (cu->language == language_fortran)
> + {
> + if ((die->tag == DW_TAG_subprogram)
> + && (dwarf2_name (parent, cu) != NULL))
> + return dwarf2_name (parent, cu);
> + else
> + return "";
> + }
> + else
> + return determine_prefix (parent, cu);
> /* Fall through. */
> default:
> return determine_prefix (parent, cu);
> diff --git a/gdb/testsuite/gdb.fortran/nested-funcs.exp b/gdb/testsuite/gdb.fortran/nested-funcs.exp
> index 4c2ee2a..0c8a416 100644
> --- a/gdb/testsuite/gdb.fortran/nested-funcs.exp
> +++ b/gdb/testsuite/gdb.fortran/nested-funcs.exp
> @@ -31,8 +31,8 @@ if ![runto MAIN__] then {
> }
>
> # Test if we can set a breakpoint in a nested function
> -gdb_breakpoint "sub_nested_outer"
> -gdb_continue_to_breakpoint "sub_nested_outer" ".*local_int = 19"
> +gdb_breakpoint "testnestedfuncs::sub_nested_outer"
> +gdb_continue_to_breakpoint "testnestedfuncs::sub_nested_outer" ".*local_int = 19"
>
> # Test if we can access local and
> # non-local variables defined one level up.
> @@ -43,13 +43,16 @@ gdb_test "set index = 42"
> gdb_test "print index" "= 42" "print index at BP_outer, manipulated"
> gdb_test "print local_int" "= 19" "print local_int in outer function"
>
> +

Unnecessary change, multiple instances.

> # Non-local variable should be affected in one frame up as well.
> gdb_test "up"

--
Yao (é½å°§)