[v3,6/6] Fortran: Nested functions, add scope parameter.
Commit Message
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.
xxxx-yy-zz Bernhard Heckel <bernhard.heckel@intel.com>
gdb/ChangeLog:
* dwarf2read.c: (partial_die_parent_scope): Add prefix for Fortran
subroutines.
(process_die): Same.
(determine_prefix): Same.
gdb/doc/ChangeLog:
* doc/gdb.texinfo: Describe scope operator.
gdb/testsuite/ChangeLog:
* gdb.fortran/nested-funcs.exp: Add tests for nested subroutines.
Adjust existing tests to include prefix.
* gdb.fortran/nested-funcs.f90: Add nested subroutines.
---
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
Comments
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"
Hi Yao,
Thanks for the feedback!
> -----Original Message-----
> From: Yao Qi [mailto:qiyaoltc@gmail.com]
> Sent: Monday, September 4, 2017 11:58 AM
> To: Wiederhake, Tim <tim.wiederhake@intel.com>
> Cc: gdb-patches@sourceware.org; Bernhard Heckel
> <bernhard.heckel@intel.com>
> Subject: Re: [PATCH v3 6/6] Fortran: Nested functions, add scope
> parameter.
>
> 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.
I agree. Merged and NEWS entry written.
> 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"?
Sorry, I don't quite follow you. What is it that you'd like to see changed?
> >
> > ---
> > 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.
Thanks, fixed.
> > + 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.
Fixed as well.
>
> > # Non-local variable should be affected in one frame up as well.
> > gdb_test "up"
>
>
> --
> Yao (齐尧)
Regards,
Tim
Intel Deutschland GmbH
Registered Address: Am Campeon 10-12, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de
Managing Directors: Christin Eisenschmid, Christian Lamprechter
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928
@@ -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
@@ -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;
+ 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);
@@ -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"
+
# Non-local variable should be affected in one frame up as well.
gdb_test "up"
gdb_test "print index" "= 42" "print index at BP1, one frame up"
+
# Test if we can set a breakpoint in a nested function
-gdb_breakpoint "sub_nested_inner"
-gdb_continue_to_breakpoint "sub_nested_inner" ".*local_int = 17"
+gdb_breakpoint "testnestedfuncs::sub_nested_inner"
+gdb_continue_to_breakpoint "testnestedfuncs::sub_nested_inner" ".*local_int = 17"
+
# Test if we can access local and
# non-local variables defined two level up.
@@ -59,12 +62,29 @@ gdb_test "print index" "= 42" "print index at BP_inner"
gdb_test "print v_state%code" "= 61" "print v_state%code at BP_inner"
gdb_test "print local_int" "= 17" "print local_int in inner function"
+
# Test if local variable is still correct.
gdb_breakpoint [gdb_get_line_number "! BP_outer_2"]
gdb_continue_to_breakpoint "! BP_outer_2" ".*! BP_outer_2"
gdb_test "print local_int" "= 19" \
"print local_int in outer function, after sub_nested_inner"
+
+# Test if we can set a breakpoint in public routine with the same name as the internal
+gdb_breakpoint "sub_nested_outer"
+gdb_continue_to_breakpoint "sub_nested_outer" ".*name = 'sub_nested_outer external'"
+
+
+# Test if we can set a breakpoint in public routine with the same name as the internal
+gdb_breakpoint "sub_with_sub_nested_outer::sub_nested_outer"
+gdb_continue_to_breakpoint "sub_with_sub_nested_outer::sub_nested_outer" ".*local_int = 11"
+
+
+# Test if we can set a breakpoint in public routine with the same name as the internal
+gdb_breakpoint "mod1::sub_nested_outer"
+gdb_continue_to_breakpoint "mod1::sub_nested_outer" ".*name = 'sub_nested_outer_mod1'"
+
+
# Sanity check in main.
gdb_breakpoint [gdb_get_line_number "! BP_main"]
gdb_continue_to_breakpoint "! BP_main" ".*! BP_main"
old mode 100755
new mode 100644
@@ -13,8 +13,64 @@
! You should have received a copy of the GNU General Public License
! along with this program. If not, see <http://www.gnu.org/licenses/>.
-program TestNestedFuncs
+module mod1
+ integer :: var_i = 1
+ integer :: var_const
+ parameter (var_const = 20)
+
+CONTAINS
+
+ SUBROUTINE sub_nested_outer
+ integer :: local_int
+ character (len=20) :: name
+
+ name = 'sub_nested_outer_mod1'
+ local_int = 11
+
+ END SUBROUTINE sub_nested_outer
+end module mod1
+
+
+! Public sub_nested_outer
+SUBROUTINE sub_nested_outer
+ integer :: local_int
+ character (len=16) :: name
+
+ name = 'sub_nested_outer external'
+ local_int = 11
+END SUBROUTINE sub_nested_outer
+
+! Needed indirection to call public sub_nested_outer from main
+SUBROUTINE sub_nested_outer_ind
+ character (len=20) :: name
+
+ name = 'sub_nested_outer_ind'
+ CALL sub_nested_outer
+END SUBROUTINE sub_nested_outer_ind
+
+! public routine with internal subroutine
+SUBROUTINE sub_with_sub_nested_outer()
+ integer :: local_int
+ character (len=16) :: name
+
+ name = 'subroutine_with_int_sub'
+ local_int = 1
+
+ CALL sub_nested_outer ! Should call the internal fct
+
+CONTAINS
+
+ SUBROUTINE sub_nested_outer
+ integer :: local_int
+ local_int = 11
+ END SUBROUTINE sub_nested_outer
+
+END SUBROUTINE sub_with_sub_nested_outer
+
+! Main
+program TestNestedFuncs
+ USE mod1, sub_nested_outer_use_mod1 => sub_nested_outer
IMPLICIT NONE
TYPE :: t_State
@@ -22,10 +78,14 @@ program TestNestedFuncs
END TYPE t_State
TYPE (t_State) :: v_state
- integer index
+ integer index, local_int
+ local_int = 14
index = 13
- CALL sub_nested_outer
+ CALL sub_nested_outer ! Call internal sub_nested_outer
+ CALL sub_nested_outer_ind ! Call external sub_nested_outer via sub_nested_outer_ind
+ CALL sub_with_sub_nested_outer ! Call external routine with nested sub_nested_outer
+ CALL sub_nested_outer_use_mod1 ! Call sub_nested_outer imported via module
index = 11 ! BP_main
v_state%code = 27