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

login
register
mail settings
Submitter Wiederhake, Tim
Date Aug. 11, 2017, 11:06 a.m.
Message ID <1502449611-8865-7-git-send-email-tim.wiederhake@intel.com>
Download mbox | patch
Permalink /patch/22076/
State New
Headers show

Comments

Wiederhake, Tim - Aug. 11, 2017, 11:06 a.m.
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
Yao Qi - Sept. 4, 2017, 9:58 a.m.
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"
Wiederhake, Tim - Sept. 8, 2017, 12:12 p.m.
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

Patch

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;
+    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"
 
+
 # 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"
diff --git a/gdb/testsuite/gdb.fortran/nested-funcs.f90 b/gdb/testsuite/gdb.fortran/nested-funcs.f90
old mode 100755
new mode 100644
index 0e99996..e7289de
--- a/gdb/testsuite/gdb.fortran/nested-funcs.f90
+++ b/gdb/testsuite/gdb.fortran/nested-funcs.f90
@@ -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