[PATCH v4 0/3] Dynamic properties of pointers

[PATCH v4 0/3] Dynamic properties of pointers

[Abdul Basit Ijaz]

From: "Ijaz, Abdul B" <abdul.b.ijaz@intel.com>

Hi!

Please find the attached v4 of this series where now majorly dropped
icc/ifort special dwarf handling related changes.  This is because
ifx/icpx compilers does not need such handling and they may be used
instead.  Also fix the copyrights and indentation issue as per the
feedback on V3 series.

V3 can be found here:
https://sourceware.org/pipermail/gdb-patches/2023-September/202143.html

V2 patch 2 was approved by Tom already in this discussion but there are
minor changes since then:
https://sourceware.org/pipermail/gdb-patches/2023-January/195353.html

V2 can be found here:
https://sourceware.org/pipermail/gdb-patches/2022-October/192389.html

V1 with feedback can be found here:
https://sourceware.org/pipermail/gdb-patches/2022-September/191934.html

Changes since v3:

  * Patch 1 : ICC/Ifort changes are dropped and instead it contains now
  only new indentation issue fixes for gdb.dwarf2/dynarr-ptr.exp.

  * Patch 2:
  Fix Tom and Thiago feedback related to copyrights and identation in test
  files.

  * Patch 3:
  Original patch 3 for handling of icc/ifort dwarf is dropped and now
  this is replaced by patch#4 of V3 series.  Ifort related comments are
  removed.  As this change is general for Fortran pointers.

Following test configurations are tested on Ubuntu22.04 and no
regression is seen:
gcc64/gcc32/native-gdbserver/native-extended-gdbserver(-m32)

I'm looking forward to comments.

Thanks & Best Regards,
Abdul Basit

Bernhard Heckel (1):
  gdb, types: Resolve pointer types dynamically

Ijaz, Abdul B (1):
  gdb/testsuite: Fix indentation issues in gdb.dwarf2/dynarr-ptr.exp

Nils-Christian Kempke (1):
  gdb, testsuite, fortran: Fix sizeof intrinsic for Fortran pointers

 gdb/eval.c                                    |   7 +
 gdb/gdbtypes.c                                |   7 +-
 gdb/testsuite/gdb.cp/vla-cxx.cc               |   4 +
 gdb/testsuite/gdb.cp/vla-cxx.exp              |  15 ++
 gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp       | 138 +++++++++---------
 .../gdb.fortran/pointer-to-pointer.exp        |   2 +-
 gdb/testsuite/gdb.fortran/pointers.exp        | 115 +++++++++++++++
 gdb/testsuite/gdb.fortran/pointers.f90        |  29 ++++
 gdb/testsuite/gdb.fortran/sizeof.exp          | 115 +++++++++++++++
 gdb/testsuite/gdb.fortran/sizeof.f90          | 108 ++++++++++++++
 gdb/valprint.c                                |   6 -
 11 files changed, 468 insertions(+), 78 deletions(-)
 create mode 100644 gdb/testsuite/gdb.fortran/pointers.exp
 create mode 100644 gdb/testsuite/gdb.fortran/sizeof.exp
 create mode 100644 gdb/testsuite/gdb.fortran/sizeof.f90

-- 
2.34.1

Intel Deutschland GmbH
Registered Address: Am Campeon 10, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de <http://www.intel.de>
Managing Directors: Christin Eisenschmid, Sharon Heck, Tiffany Doon Silva  
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928

[PATCH v4 1/3] gdb/testsuite: Fix indentation issues in gdb.dwarf2/dynarr-ptr.exp

[Abdul Basit Ijaz]

From: "Ijaz, Abdul B" <abdul.b.ijaz@intel.com>

---
 gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp | 138 ++++++++++++------------
 1 file changed, 69 insertions(+), 69 deletions(-)

diff --git a/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp b/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
index 6e4a331eca8..26c64278103 100644
--- a/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
+++ b/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
@@ -120,7 +120,7 @@ Dwarf::assemble $asm_file {
 # the compiler.
 
 if { [prepare_for_testing "failed to prepare" ${testfile} \
-	  [list $srcfile $asm_file] {nodebug}] } {
+    [list $srcfile $asm_file] {nodebug}] } {
     return -1
 }
 
@@ -133,219 +133,219 @@ gdb_test_no_output "set language ada"
 # foo.three_ptr.all
 
 gdb_test "print foo.three_ptr.all" \
-         " = \\(1, 2, 3\\)"
+    " = \\(1, 2, 3\\)"
 
 gdb_test "print foo.three_ptr.all(1)" \
-         " = 1"
+    " = 1"
 
 gdb_test "print foo.three_ptr.all(2)" \
-         " = 2"
+    " = 2"
 
 gdb_test "print foo.three_ptr.all(3)" \
-         " = 3"
+    " = 3"
 
 gdb_test "print foo.three_ptr.all'first" \
-         " = 1"
+    " = 1"
 
 gdb_test "print foo.three_ptr.all'last" \
-         " = 3"
+    " = 3"
 
 gdb_test "print foo.three_ptr.all'length" \
-         " = 3"
+    " = 3"
 
 gdb_test "ptype foo.three_ptr.all" \
-         " = array \\(<>\\) of integer"
+    " = array \\(<>\\) of integer"
 
 # foo.three_ptr
 
 gdb_test "print foo.three_ptr(1)" \
-         " = 1"
+    " = 1"
 
 gdb_test "print foo.three_ptr(2)" \
-         " = 2"
+    " = 2"
 
 gdb_test "print foo.three_ptr(3)" \
-         " = 3"
+    " = 3"
 
 gdb_test "print foo.three_ptr'first" \
-         " = 1"
+    " = 1"
 
 gdb_test "print foo.three_ptr'last" \
-         " = 3"
+    " = 3"
 
 gdb_test "print foo.three_ptr'length" \
-         " = 3"
+    " = 3"
 
 gdb_test "ptype foo.three_ptr" \
-         " = access array \\(<>\\) of integer"
+    " = access array \\(<>\\) of integer"
 
 # foo.three_ptr_tdef.all
 
 gdb_test "print foo.three_ptr_tdef.all" \
-         " = \\(1, 2, 3\\)"
+    " = \\(1, 2, 3\\)"
 
 gdb_test "print foo.three_ptr_tdef.all(1)" \
-         " = 1"
+    " = 1"
 
 gdb_test "print foo.three_ptr_tdef.all(2)" \
-         " = 2"
+    " = 2"
 
 gdb_test "print foo.three_ptr_tdef.all(3)" \
-         " = 3"
+    " = 3"
 
 gdb_test "print foo.three_ptr_tdef.all'first" \
-         " = 1"
+    " = 1"
 
 gdb_test "print foo.three_ptr_tdef.all'last" \
-         " = 3"
+    " = 3"
 
 gdb_test "print foo.three_ptr_tdef.all'length" \
-         " = 3"
+    " = 3"
 
 gdb_test "ptype foo.three_ptr_tdef.all" \
-         " = array \\(<>\\) of integer"
+    " = array \\(<>\\) of integer"
 
 # foo.three_ptr_tdef
 
 gdb_test "print foo.three_ptr_tdef(1)" \
-         " = 1"
+    " = 1"
 
 gdb_test "print foo.three_ptr_tdef(2)" \
-         " = 2"
+    " = 2"
 
 gdb_test "print foo.three_ptr_tdef(3)" \
-         " = 3"
+    " = 3"
 
 gdb_test "print foo.three_ptr_tdef'first" \
-         " = 1"
+    " = 1"
 
 gdb_test "print foo.three_ptr_tdef'last" \
-         " = 3"
+    " = 3"
 
 gdb_test "print foo.three_ptr_tdef'length" \
-         " = 3"
+    " = 3"
 
 gdb_test "ptype foo.three_ptr_tdef" \
-         " = access array \\(<>\\) of integer"
+    " = access array \\(<>\\) of integer"
 
 # foo.five_ptr.all
 
 gdb_test "print foo.five_ptr.all" \
-         " = \\(2 => 5, 8, 13, 21, 34\\)"
+    " = \\(2 => 5, 8, 13, 21, 34\\)"
 
 gdb_test "print foo.five_ptr.all(2)" \
-         " = 5"
+    " = 5"
 
 gdb_test "print foo.five_ptr.all(3)" \
-         " = 8"
+    " = 8"
 
 gdb_test "print foo.five_ptr.all(4)" \
-         " = 13"
+    " = 13"
 
 gdb_test "print foo.five_ptr.all(5)" \
-         " = 21"
+    " = 21"
 
 gdb_test "print foo.five_ptr.all(6)" \
-         " = 34"
+    " = 34"
 
 gdb_test "print foo.five_ptr.all'first" \
-         " = 2"
+    " = 2"
 
 gdb_test "print foo.five_ptr.all'last" \
-         " = 6"
+    " = 6"
 
 gdb_test "print foo.five_ptr.all'length" \
-         " = 5"
+    " = 5"
 
 gdb_test "ptype foo.five_ptr.all" \
-         " = array \\(<>\\) of integer"
+    " = array \\(<>\\) of integer"
 
 # foo.five_ptr
 
 gdb_test "print foo.five_ptr(2)" \
-         " = 5"
+    " = 5"
 
 gdb_test "print foo.five_ptr(3)" \
-         " = 8"
+    " = 8"
 
 gdb_test "print foo.five_ptr(4)" \
-         " = 13"
+    " = 13"
 
 gdb_test "print foo.five_ptr(5)" \
-         " = 21"
+    " = 21"
 
 gdb_test "print foo.five_ptr(6)" \
-         " = 34"
+    " = 34"
 
 gdb_test "print foo.five_ptr'first" \
-         " = 2"
+    " = 2"
 
 gdb_test "print foo.five_ptr'last" \
-         " = 6"
+    " = 6"
 
 gdb_test "print foo.five_ptr'length" \
-         " = 5"
+    " = 5"
 
 gdb_test "ptype foo.five_ptr" \
-         " = access array \\(<>\\) of integer"
+    " = access array \\(<>\\) of integer"
 
 # foo.five_ptr_tdef.all
 
 gdb_test "print foo.five_ptr_tdef.all" \
-         " = \\(2 => 5, 8, 13, 21, 34\\)"
+    " = \\(2 => 5, 8, 13, 21, 34\\)"
 
 gdb_test "print foo.five_ptr_tdef.all(2)" \
-         " = 5"
+    " = 5"
 
 gdb_test "print foo.five_ptr_tdef.all(3)" \
-         " = 8"
+    " = 8"
 
 gdb_test "print foo.five_ptr_tdef.all(4)" \
-         " = 13"
+    " = 13"
 
 gdb_test "print foo.five_ptr_tdef.all(5)" \
-         " = 21"
+    " = 21"
 
 gdb_test "print foo.five_ptr_tdef.all(6)" \
-         " = 34"
+    " = 34"
 
 gdb_test "print foo.five_ptr_tdef.all'first" \
-         " = 2"
+    " = 2"
 
 gdb_test "print foo.five_ptr_tdef.all'last" \
-         " = 6"
+    " = 6"
 
 gdb_test "print foo.five_ptr_tdef.all'length" \
-         " = 5"
+    " = 5"
 
 gdb_test "ptype foo.five_ptr_tdef.all" \
-         " = array \\(<>\\) of integer"
+    " = array \\(<>\\) of integer"
 
 # foo.five_ptr_tdef
 
 gdb_test "print foo.five_ptr_tdef(2)" \
-         " = 5"
+    " = 5"
 
 gdb_test "print foo.five_ptr_tdef(3)" \
-         " = 8"
+    " = 8"
 
 gdb_test "print foo.five_ptr_tdef(4)" \
-         " = 13"
+    " = 13"
 
 gdb_test "print foo.five_ptr_tdef(5)" \
-         " = 21"
+    " = 21"
 
 gdb_test "print foo.five_ptr_tdef(6)" \
-         " = 34"
+    " = 34"
 
 gdb_test "print foo.five_ptr_tdef'first" \
-         " = 2"
+    " = 2"
 
 gdb_test "print foo.five_ptr_tdef'last" \
-         " = 6"
+    " = 6"
 
 gdb_test "print foo.five_ptr_tdef'length" \
-         " = 5"
+    " = 5"
 
 gdb_test "ptype foo.five_ptr_tdef" \
-         " = access array \\(<>\\) of integer"
+    " = access array \\(<>\\) of integer"
-- 
2.34.1

Intel Deutschland GmbH
Registered Address: Am Campeon 10, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de <http://www.intel.de>
Managing Directors: Christin Eisenschmid, Sharon Heck, Tiffany Doon Silva  
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928

[PATCH v4 2/3] gdb, types: Resolve pointer types dynamically

[Abdul Basit Ijaz]

From: Bernhard Heckel <bernhard.heckel@intel.com>

This commit allows pointers to be dynamic types (on the outmost
level).  Similar to references, a pointer is considered a dynamic type
if its target type is a dynamic type and it is on the outmost level.
Also this commit removes the redundant code inside function
"value_check_printable" for handling of DW_AT_associated type.

The pointer resolution follows the one of references.

This change generally makes the GDB output more verbose.  We are able to
print more details about a pointer's target like the dimension of an array.

In Fortran, if we have a pointer to a dynamic type

  type buffer
    real, dimension(:), pointer :: ptr
  end type buffer
  type(buffer), pointer :: buffer_ptr
  allocate (buffer_ptr)
  allocate (buffer_ptr%ptr (5))

which then gets allocated, we now resolve the dynamic type before
printing the pointer's type:

Before:

  (gdb) ptype buffer_ptr
  type = PTR TO -> ( Type buffer
    real(kind=4) :: alpha(:)
  End Type buffer )

After:

  (gdb) ptype buffer_ptr
  type = PTR TO -> ( Type buffer
    real(kind=4) :: alpha(5)
  End Type buffer )

Similarly in C++ we can dynamically resolve e.g. pointers to arrays:

  int len = 3;
  int arr[len];
  int (*ptr)[len];
  int ptr = &arr;

Once the pointer is assigned one gets:

Before:

  (gdb) p ptr
  $1 = (int (*)[variable length]) 0x123456
  (gdb) ptype ptr
  type = int (*)[variable length]

After:

  (gdb) p ptr
  $1 = (int (*)[3]) 0x123456
  (gdb) ptype ptr
  type = int (*)[3]

For more examples see the modified/added test cases.

Tested-by: Thiago Jung Bauermann <thiago.bauermann@linaro.org>
---
 gdb/gdbtypes.c                                |   7 +-
 gdb/testsuite/gdb.cp/vla-cxx.cc               |   4 +
 gdb/testsuite/gdb.cp/vla-cxx.exp              |  15 +++
 gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp       |  16 +--
 .../gdb.fortran/pointer-to-pointer.exp        |   2 +-
 gdb/testsuite/gdb.fortran/pointers.exp        | 115 ++++++++++++++++++
 gdb/testsuite/gdb.fortran/pointers.f90        |  29 +++++
 gdb/valprint.c                                |   6 -
 8 files changed, 177 insertions(+), 17 deletions(-)
 create mode 100644 gdb/testsuite/gdb.fortran/pointers.exp

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 2580b4f19ee..14589eafb93 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -2042,8 +2042,10 @@ is_dynamic_type_internal (struct type *type, int top_level)
 {
   type = check_typedef (type);
 
-  /* We only want to recognize references at the outermost level.  */
-  if (top_level && type->code () == TYPE_CODE_REF)
+  /* We only want to recognize references and pointers at the outermost
+     level.  */
+  if (top_level
+      && (type->code () == TYPE_CODE_REF || type->code () == TYPE_CODE_PTR))
     type = check_typedef (type->target_type ());
 
   /* Types that have a dynamic TYPE_DATA_LOCATION are considered
@@ -2779,6 +2781,7 @@ resolve_dynamic_type_internal (struct type *type,
       switch (type->code ())
 	{
 	case TYPE_CODE_REF:
+	case TYPE_CODE_PTR:
 	  {
 	    struct property_addr_info pinfo;
 
diff --git a/gdb/testsuite/gdb.cp/vla-cxx.cc b/gdb/testsuite/gdb.cp/vla-cxx.cc
index 0ecb130f676..83e238339ac 100644
--- a/gdb/testsuite/gdb.cp/vla-cxx.cc
+++ b/gdb/testsuite/gdb.cp/vla-cxx.cc
@@ -40,6 +40,10 @@ int main(int argc, char **argv)
   typedef typeof (vla) &vlareftypedef;
   vlareftypedef vlaref2 (vla);
   container c;
+  typeof (vla) *ptr = nullptr;
+
+  // Before pointer assignment.
+  ptr = &vla;
 
   for (int i = 0; i < z; ++i)
     vla[i] = 5 + 2 * i;
diff --git a/gdb/testsuite/gdb.cp/vla-cxx.exp b/gdb/testsuite/gdb.cp/vla-cxx.exp
index 0a588220679..ade688cedda 100644
--- a/gdb/testsuite/gdb.cp/vla-cxx.exp
+++ b/gdb/testsuite/gdb.cp/vla-cxx.exp
@@ -23,6 +23,18 @@ if ![runto_main] {
     return -1
 }
 
+gdb_breakpoint [gdb_get_line_number "Before pointer assignment"]
+gdb_continue_to_breakpoint "Before pointer assignment"
+
+gdb_test "ptype ptr" "= int \\(\\*\\)\\\[3\\\]" \
+    "ptype ptr, before pointer assignment"
+
+gdb_test "print ptr" "= \\(int \\(\\*\\)\\\[3\\\]\\) 0x0" \
+    "print ptr, before pointer assignment"
+
+gdb_test "print *ptr" "Cannot access memory at address 0x0" \
+    "print *ptr, before pointer assignment"
+
 gdb_breakpoint [gdb_get_line_number "vlas_filled"]
 gdb_continue_to_breakpoint "vlas_filled"
 
@@ -33,3 +45,6 @@ gdb_test "print vlaref" " = \\(int \\(&\\)\\\[3\\\]\\) @$hex: \\{5, 7, 9\\}"
 # bug being tested, it's better not to depend on the exact spelling.
 gdb_test "print vlaref2" " = \\(.*\\) @$hex: \\{5, 7, 9\\}"
 gdb_test "print c" " = \\{e = \\{c = @$hex\\}\\}"
+gdb_test "ptype ptr" "int \\(\\*\\)\\\[3\\\]"
+gdb_test "print ptr" "\\(int \\(\\*\\)\\\[3\\\]\\) $hex"
+gdb_test "print *ptr" " = \\{5, 7, 9\\}"
diff --git a/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp b/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
index 26c64278103..72b79a87235 100644
--- a/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
+++ b/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
@@ -154,7 +154,7 @@ gdb_test "print foo.three_ptr.all'length" \
     " = 3"
 
 gdb_test "ptype foo.three_ptr.all" \
-    " = array \\(<>\\) of integer"
+    " = array \\(1 \\.\\. 3\\) of integer"
 
 # foo.three_ptr
 
@@ -177,7 +177,7 @@ gdb_test "print foo.three_ptr'length" \
     " = 3"
 
 gdb_test "ptype foo.three_ptr" \
-    " = access array \\(<>\\) of integer"
+    " = access array \\(1 \\.\\. 3\\) of integer"
 
 # foo.three_ptr_tdef.all
 
@@ -203,7 +203,7 @@ gdb_test "print foo.three_ptr_tdef.all'length" \
     " = 3"
 
 gdb_test "ptype foo.three_ptr_tdef.all" \
-    " = array \\(<>\\) of integer"
+    " = array \\(1 \\.\\. 3\\) of integer"
 
 # foo.three_ptr_tdef
 
@@ -226,7 +226,7 @@ gdb_test "print foo.three_ptr_tdef'length" \
     " = 3"
 
 gdb_test "ptype foo.three_ptr_tdef" \
-    " = access array \\(<>\\) of integer"
+    " = access array \\(1 \\.\\. 3\\) of integer"
 
 # foo.five_ptr.all
 
@@ -258,7 +258,7 @@ gdb_test "print foo.five_ptr.all'length" \
     " = 5"
 
 gdb_test "ptype foo.five_ptr.all" \
-    " = array \\(<>\\) of integer"
+    " = array \\(2 \\.\\. 6\\) of integer"
 
 # foo.five_ptr
 
@@ -287,7 +287,7 @@ gdb_test "print foo.five_ptr'length" \
     " = 5"
 
 gdb_test "ptype foo.five_ptr" \
-    " = access array \\(<>\\) of integer"
+    " = access array \\(2 \\.\\. 6\\) of integer"
 
 # foo.five_ptr_tdef.all
 
@@ -319,7 +319,7 @@ gdb_test "print foo.five_ptr_tdef.all'length" \
     " = 5"
 
 gdb_test "ptype foo.five_ptr_tdef.all" \
-    " = array \\(<>\\) of integer"
+    " = array \\(2 \\.\\. 6\\) of integer"
 
 # foo.five_ptr_tdef
 
@@ -348,4 +348,4 @@ gdb_test "print foo.five_ptr_tdef'length" \
     " = 5"
 
 gdb_test "ptype foo.five_ptr_tdef" \
-    " = access array \\(<>\\) of integer"
+    " = access array \\(2 \\.\\. 6\\) of integer"
diff --git a/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp b/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp
index 0fd5fb0996f..78b7ba17588 100644
--- a/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp
+++ b/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp
@@ -41,7 +41,7 @@ gdb_test "print buffer" \
 gdb_test "ptype buffer" \
     [multi_line \
 	 "type = PTR TO -> \\( Type l_buffer" \
-	 "    $real4 :: alpha\\(:\\)" \
+	 "    $real4 :: alpha\\(5\\)" \
 	 "End Type l_buffer \\)" ]
 gdb_test "ptype buffer%alpha" "type = $real4 \\(5\\)"
 
diff --git a/gdb/testsuite/gdb.fortran/pointers.exp b/gdb/testsuite/gdb.fortran/pointers.exp
new file mode 100644
index 00000000000..dafea392799
--- /dev/null
+++ b/gdb/testsuite/gdb.fortran/pointers.exp
@@ -0,0 +1,115 @@
+# Copyright 2024 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+standard_testfile "pointers.f90"
+load_lib fortran.exp
+
+if {[prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+    {debug f90 quiet}]} {
+    return -1
+}
+
+if {![fortran_runto_main]} {
+    untested "could not run to main"
+    return -1
+}
+
+# Depending on the compiler being used, the type names can be printed
+# differently.
+set logical [fortran_logical4]
+set real [fortran_real4]
+set int [fortran_int4]
+set complex [fortran_complex4]
+
+gdb_breakpoint [gdb_get_line_number "Before pointer assignment"]
+gdb_continue_to_breakpoint "Before pointer assignment"
+gdb_test "print logp" "= \\(PTR TO -> \\( $logical \\)\\) 0x0" \
+    "print logp, not associated"
+gdb_test "print *logp" "Cannot access memory at address 0x0" \
+    "print *logp, not associated"
+gdb_test "print comp" "= \\(PTR TO -> \\( $complex \\)\\) 0x0" \
+    "print comp, not associated"
+gdb_test "print *comp" "Cannot access memory at address 0x0" \
+    "print *comp, not associated"
+gdb_test "print charp" "= \\(PTR TO -> \\( character\\*1 \\)\\) 0x0" \
+    "print charp, not associated"
+gdb_test "print *charp" "Cannot access memory at address 0x0" \
+    "print *charp, not associated"
+gdb_test "print charap" "= \\(PTR TO -> \\( character\\*3 \\)\\) 0x0" \
+    "print charap, not associated"
+gdb_test "print *charap" "Cannot access memory at address 0x0" \
+    "print *charap, not associated"
+gdb_test "print intp" "= \\(PTR TO -> \\( $int \\)\\) 0x0" \
+    "print intp, not associated"
+gdb_test "print *intp" "Cannot access memory at address 0x0" \
+    "print *intp, not associated"
+gdb_test "print intap" " = <not associated>" "print intap, not associated"
+gdb_test "print realp" "= \\(PTR TO -> \\( $real \\)\\) 0x0" \
+    "print realp, not associated"
+gdb_test "print *realp" "Cannot access memory at address 0x0" \
+    "print *realp, not associated"
+gdb_test "print \$my_var = intp" "= \\(PTR TO -> \\( $int \\)\\) 0x0"
+gdb_test "print cyclicp1" "= \\( i = -?\\d+, p = 0x0 \\)" \
+    "print cyclicp1, not associated"
+gdb_test "print cyclicp1%p" \
+    "= \\(PTR TO -> \\( Type typewithpointer \\)\\) 0x0" \
+    "print cyclicp1%p, not associated"
+
+gdb_breakpoint [gdb_get_line_number "Before value assignment"]
+gdb_continue_to_breakpoint "Before value assignment"
+gdb_test "print *(twop)%ivla2" "= <not allocated>"
+
+gdb_breakpoint [gdb_get_line_number "After value assignment"]
+gdb_continue_to_breakpoint "After value assignment"
+gdb_test "print logp" "= \\(PTR TO -> \\( $logical \\)\\) $hex\( <.*>\)?"
+gdb_test "print *logp" "= \\.TRUE\\."
+gdb_test "print comp" "= \\(PTR TO -> \\( $complex \\)\\) $hex\( <.*>\)?"
+gdb_test "print *comp" "= \\(1,2\\)"
+gdb_test "print charp" "= \\(PTR TO -> \\( character\\*1 \\)\\) $hex\( <.*>\)?"
+gdb_test "print *charp" "= 'a'"
+gdb_test "print charap" "= \\(PTR TO -> \\( character\\*3 \\)\\) $hex\( <.*>\)?"
+gdb_test "print *charap" "= 'abc'"
+gdb_test "print intp" "= \\(PTR TO -> \\( $int \\)\\) $hex\( <.*>\)?"
+gdb_test "print *intp" "= 10"
+gdb_test "print intap" "= \\(\\(1, 1, 3(, 1){7}\\) \\(1(, 1){9}\\)\\)" \
+    "print intap, associated"
+gdb_test "print intvlap" "= \\(2, 2, 2, 4(, 2){6}\\)" \
+    "print intvlap, associated"
+gdb_test "print realp" "= \\(PTR TO -> \\( $real \\)\\) $hex\( <.*>\)?"
+gdb_test "print *realp" "= 3\\.14000\\d+"
+gdb_test "print arrayOfPtr(2)%p" "= \\(PTR TO -> \\( Type two \\)\\) $hex\( <.*>\)?"
+gdb_test "print *(arrayOfPtr(2)%p)" \
+    "= \\( ivla1 = \\(11, 12, 13\\), ivla2 = \\(\\(211, 221\\) \\(212, 222\\)\\) \\)"
+gdb_test "print arrayOfPtr(3)%p" "= \\(PTR TO -> \\( Type two \\)\\) 0x0" \
+    "print arrayOfPtr(3)%p"
+
+gdb_test_multiple "print *(arrayOfPtr(3)%p)" \
+    "print *(arrayOfPtr(3)%p), associated" {
+    # gfortran
+    -re -wrap "Cannot access memory at address 0x0" {
+	pass $gdb_test_name
+    }
+    # ifx
+    -re -wrap "Location address is not set." {
+	pass $gdb_test_name
+    }
+}
+
+gdb_test "print cyclicp1" "= \\( i = 1, p = $hex\( <.*>\)? \\)"
+gdb_test "print cyclicp1%p" "= \\(PTR TO -> \\( Type typewithpointer \\)\\) $hex\( <.*>\)?"
+gdb_test "print *((integer*) &inta + 2)" "= 3" "print temporary pointer, array"
+gdb_test "print *((integer*) &intvla + 3)" "= 4" "print temporary pointer, allocated vla"
+gdb_test "print \$pc" "\\(PTR TO -> \\( void \\(\\) \\(\\) \\)\\) $hex <pointers\\+\\d+>" \
+    "Print program counter"
diff --git a/gdb/testsuite/gdb.fortran/pointers.f90 b/gdb/testsuite/gdb.fortran/pointers.f90
index 8708d505ada..0fb6b36a25c 100644
--- a/gdb/testsuite/gdb.fortran/pointers.f90
+++ b/gdb/testsuite/gdb.fortran/pointers.f90
@@ -20,14 +20,26 @@ program pointers
     integer, allocatable :: ivla2 (:, :)
   end type two
 
+  type :: typeWithPointer
+    integer i
+    type(typeWithPointer), pointer:: p
+  end type typeWithPointer
+
+  type :: twoPtr
+    type (two), pointer :: p
+  end type twoPtr
+
   logical, target :: logv
   complex, target :: comv
   character, target :: charv
   character (len=3), target :: chara
   integer, target :: intv
   integer, target, dimension (10,2) :: inta
+  integer, target, allocatable, dimension (:) :: intvla
   real, target :: realv
   type(two), target :: twov
+  type(twoPtr) :: arrayOfPtr (3)
+  type(typeWithPointer), target:: cyclicp1,cyclicp2
 
   logical, pointer :: logp
   complex, pointer :: comp
@@ -35,6 +47,7 @@ program pointers
   character (len=3), pointer :: charap
   integer, pointer :: intp
   integer, pointer, dimension (:,:) :: intap
+  integer, pointer, dimension (:) :: intvlap
   real, pointer :: realp
   type(two), pointer :: twop
 
@@ -44,8 +57,14 @@ program pointers
   nullify (charap)
   nullify (intp)
   nullify (intap)
+  nullify (intvlap)
   nullify (realp)
   nullify (twop)
+  nullify (arrayOfPtr(1)%p)
+  nullify (arrayOfPtr(2)%p)
+  nullify (arrayOfPtr(3)%p)
+  nullify (cyclicp1%p)
+  nullify (cyclicp2%p)
 
   logp => logv    ! Before pointer assignment
   comp => comv
@@ -53,8 +72,14 @@ program pointers
   charap => chara
   intp => intv
   intap => inta
+  intvlap => intvla
   realp => realv
   twop => twov
+  arrayOfPtr(2)%p => twov
+  cyclicp1%i = 1
+  cyclicp1%p => cyclicp2
+  cyclicp2%i = 2
+  cyclicp2%p => cyclicp1
 
   logv = associated(logp)     ! Before value assignment
   comv = cmplx(1,2)
@@ -63,6 +88,10 @@ program pointers
   intv = 10
   inta(:,:) = 1
   inta(3,1) = 3
+  allocate (intvla(10))
+  intvla(:) = 2
+  intvla(4) = 4
+  intvlap => intvla
   realv = 3.14
 
   allocate (twov%ivla1(3))
diff --git a/gdb/valprint.c b/gdb/valprint.c
index 00943c1111a..2da435d153b 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -1156,12 +1156,6 @@ value_check_printable (struct value *val, struct ui_file *stream,
       return 0;
     }
 
-  if (type_not_associated (val->type ()))
-    {
-      val_print_not_associated (stream);
-      return 0;
-    }
-
   if (type_not_allocated (val->type ()))
     {
       val_print_not_allocated (stream);
-- 
2.34.1

Intel Deutschland GmbH
Registered Address: Am Campeon 10, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de <http://www.intel.de>
Managing Directors: Christin Eisenschmid, Sharon Heck, Tiffany Doon Silva  
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928

[PATCH v4 3/3] gdb, testsuite, fortran: Fix sizeof intrinsic for Fortran pointers

[Abdul Basit Ijaz]

From: Nils-Christian Kempke <nils-christian.kempke@intel.com>

For Fortran pointers gfortran/ifx emits DW_TAG_pointer_types like

<2><17d>: Abbrev Number: 22 (DW_TAG_variable)
   <180>   DW_AT_name        : (indirect string, offset: 0x1f1): fptr
   <184>   DW_AT_type        : <0x214>
...
<1><219>: Abbrev Number: 27 (DW_TAG_array_type)
   <21a>   DW_AT_type        : <0x10e>
   <216>   DW_AT_associated  : ...

The 'pointer property' in Fortran is implicitly modeled by adding a
DW_AT_associated to the type of the variable (see also the
DW_AT_associated description in DWARF 5).  A Fortran pointer is more
than an address and thus different from a C pointer.  It is a
self contained type having additional fields such as, e.g., the rank of
its underlying array.  This motivates the intended DWARF modeling of
Fortran pointers via the DW_AT_associated attribute.

This patch adds support for the sizeof intrinsic by simply dereferencing
pointer types when encountered during a sizeof evaluation.

The patch also adds a test for the sizeof intrinsic which was not tested
before.

Tested-by: Thiago Jung Bauermann <thiago.bauermann@linaro.org>
---
 gdb/eval.c                           |   7 ++
 gdb/testsuite/gdb.fortran/sizeof.exp | 115 +++++++++++++++++++++++++++
 gdb/testsuite/gdb.fortran/sizeof.f90 | 108 +++++++++++++++++++++++++
 3 files changed, 230 insertions(+)
 create mode 100644 gdb/testsuite/gdb.fortran/sizeof.exp
 create mode 100644 gdb/testsuite/gdb.fortran/sizeof.f90

diff --git a/gdb/eval.c b/gdb/eval.c
index e075cc3138d..b7c6aa8ed69 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -2706,6 +2706,13 @@ evaluate_subexp_for_sizeof_base (struct expression *exp, struct type *type)
   if (exp->language_defn->la_language == language_cplus
       && (TYPE_IS_REFERENCE (type)))
     type = check_typedef (type->target_type ());
+  else if (exp->language_defn->la_language == language_fortran
+	   && type->code () == TYPE_CODE_PTR)
+    {
+      /* Dereference Fortran pointer types to allow them for the Fortran
+	 sizeof intrinsic.  */
+      type = check_typedef (type->target_type ());
+    }
   return value_from_longest (size_type, (LONGEST) type->length ());
 }
 
diff --git a/gdb/testsuite/gdb.fortran/sizeof.exp b/gdb/testsuite/gdb.fortran/sizeof.exp
new file mode 100644
index 00000000000..be59a37f1a6
--- /dev/null
+++ b/gdb/testsuite/gdb.fortran/sizeof.exp
@@ -0,0 +1,115 @@
+# Copyright 2024 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/> .
+
+# Testing GDB's implementation of SIZE keyword.
+
+require allow_fortran_tests
+
+standard_testfile ".f90"
+load_lib fortran.exp
+
+if {[prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+    {debug f90}]} {
+    return -1
+}
+
+if ![fortran_runto_main] {
+    return -1
+}
+
+gdb_breakpoint [gdb_get_line_number "Test breakpoint"]
+gdb_breakpoint [gdb_get_line_number "Past unassigned pointers"]
+gdb_breakpoint [gdb_get_line_number "Final breakpoint"]
+
+set done_unassigned 0
+set found_final_breakpoint 0
+set test_count 0
+
+# We are running tests defined in the executable here.  So, in the .exp file
+# we do not know when the 'Final breakpoint' will be hit exactly.  We place a
+# limit on the number of tests that can be run, just in case something goes
+# wrong, and GDB gets stuck in an loop here.
+while { $test_count < 200 } {
+    with_test_prefix "test $test_count" {
+	incr test_count
+
+	gdb_test_multiple "continue" "continue" {
+	    -re -wrap "! Test breakpoint" {
+		# We can run a test from here.
+	    }
+	    -re -wrap "! Past unassigned pointers" {
+		# Done with testing unassigned pointers.
+		set done_unassigned 1
+		continue
+	    }
+	    -re -wrap "! Final breakpoint" {
+		# We're done with the tests.
+		set found_final_breakpoint 1
+	    }
+	}
+
+	if ($found_final_breakpoint) {
+	    break
+	}
+
+	# First grab the expected answer.
+	set answer [get_valueof "" "answer" "**unknown**"]
+
+	# Now move up a frame and figure out a command for us to run
+	# as a test.
+	set command ""
+	gdb_test_multiple "up" "up" {
+	    -re -wrap "\r\n\[0-9\]+\[ \t\]+call test_sizeof \\((\[^\r\n\]+)\\)" {
+		set command $expect_out(1,string)
+	    }
+	}
+
+	gdb_assert { ![string equal $command ""] } "found a command to run"
+
+	set is_pointer_to_array [string match "sizeof (*a_p)*" $command]
+
+	if {$done_unassigned || !$is_pointer_to_array} {
+	    gdb_test "p $command" " = $answer"
+	} else {
+	    # Gfortran and ifx have slightly different behavior for unassigned
+	    # pointers to arrays.  While ifx will print 0 as the sizeof result,
+	    # gfortran will print the size of the base type of the pointer or
+	    # array.  Since the default behavior in GDB was to print 0 we keep
+	    # this and make an exception for gfortran here.
+	    gdb_test_multiple "p $command" "p $command" {
+		-re -wrap " = $answer" {
+		    pass $gdb_test_name
+		}
+		-re -wrap " = 0" {
+		    pass $gdb_test_name
+		}
+	    }
+	}
+    }
+}
+
+gdb_assert {$found_final_breakpoint} "ran all compiled in tests"
+
+# Here some more GDB specific tests that might fail with compilers.
+# GDB will print sizeof(1.4) = 8 while gfortran will probably print 4 but
+# GDB says ptype 1.4 is real*8 so the output is expected.
+
+gdb_test "ptype 1" "type = int"
+gdb_test "p sizeof(1)" "= 4"
+
+gdb_test "ptype 1.3" "type = real\\*8"
+gdb_test "p sizeof(1.3)" "= 8"
+
+gdb_test  "p sizeof ('asdsasd')" "= 7"
diff --git a/gdb/testsuite/gdb.fortran/sizeof.f90 b/gdb/testsuite/gdb.fortran/sizeof.f90
new file mode 100644
index 00000000000..b8490a1cdb1
--- /dev/null
+++ b/gdb/testsuite/gdb.fortran/sizeof.f90
@@ -0,0 +1,108 @@
+! Copyright 2024 Free Software Foundation, Inc.
+
+! This program is free software; you can redistribute it and/or modify
+! it under the terms of the GNU General Public License as published by
+! the Free Software Foundation; either version 3 of the License, or
+! (at your option) any later version.
+!
+! This program is distributed in the hope that it will be useful,
+! but WITHOUT ANY WARRANTY; without even the implied warranty of
+! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+! GNU General Public License for more details.
+!
+! You should have received a copy of the GNU General Public License
+! along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module data
+  use, intrinsic :: iso_c_binding, only : C_SIZE_T
+  implicit none
+
+  character, target :: char_v
+  character (len=3), target :: char_a
+  integer, target :: int_v
+  integer, target, dimension(:,:) :: int_2da (3,2)
+  real*4, target :: real_v
+  real*4, target :: real_a(4)
+  real*4, target, dimension (:), allocatable :: real_a_alloc
+
+  character, pointer :: char_v_p
+  character (len=3), pointer :: char_a_p
+  integer, pointer :: int_v_p
+  integer, pointer, dimension (:,:) :: int_2da_p
+  real*4, pointer :: real_v_p
+  real*4, pointer, dimension(:) :: real_a_p
+  real*4, dimension(:), pointer :: real_alloc_a_p
+
+contains
+subroutine test_sizeof (answer)
+  integer(C_SIZE_T) :: answer
+
+  print *, answer ! Test breakpoint
+end subroutine test_sizeof
+
+subroutine run_tests ()
+  call test_sizeof (sizeof (char_v))
+  call test_sizeof (sizeof (char_a))
+  call test_sizeof (sizeof (int_v))
+  call test_sizeof (sizeof (int_2da))
+  call test_sizeof (sizeof (real_v))
+  call test_sizeof (sizeof (real_a))
+  call test_sizeof (sizeof (real_a_alloc))
+
+  call test_sizeof (sizeof (char_v_p))
+  call test_sizeof (sizeof (char_a_p))
+  call test_sizeof (sizeof (int_v_p))
+  call test_sizeof (sizeof (int_2da_p))
+  call test_sizeof (sizeof (real_v_p))
+  call test_sizeof (sizeof (real_a_p))
+  call test_sizeof (sizeof (real_alloc_a_p))
+end subroutine run_tests
+
+end module data
+
+program sizeof_tests
+  use iso_c_binding
+  use data
+
+  implicit none
+
+  allocate (real_a_alloc(5))
+
+  nullify (char_v_p)
+  nullify (char_a_p)
+  nullify (int_v_p)
+  nullify (int_2da_p)
+  nullify (real_v_p)
+  nullify (real_a_p)
+  nullify (real_alloc_a_p)
+
+  ! Test nullified
+  call run_tests ()
+
+  char_v_p => char_v ! Past unassigned pointers
+  char_a_p => char_a
+  int_v_p => int_v
+  int_2da_p => int_2da
+  real_v_p => real_v
+  real_a_p => real_a
+  real_alloc_a_p => real_a_alloc
+
+  ! Test pointer assignment
+  call run_tests ()
+
+  char_v = 'a'
+  char_a = "aaa"
+  int_v = 10
+  int_2da = reshape((/1, 2, 3, 4, 5, 6/), shape(int_2da))
+  real_v = 123.123
+  real_a_p = (/-1.1, -1.2, -1.3, -1.4/)
+  real_a_alloc = (/1.1, 2.2, 3.3, 4.4, 5.5/)
+
+  ! After allocate/value assignment
+  call run_tests ()
+
+  deallocate (real_a_alloc)
+
+  print *, "done" ! Final breakpoint
+
+end program sizeof_tests
-- 
2.34.1

Intel Deutschland GmbH
Registered Address: Am Campeon 10, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de <http://www.intel.de>
Managing Directors: Christin Eisenschmid, Sharon Heck, Tiffany Doon Silva  
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928

Re: [PATCH v4 1/3] gdb/testsuite: Fix indentation issues in gdb.dwarf2/dynarr-ptr.exp

[Tom Tromey]

>>>>> "Abdul" == Abdul Basit Ijaz <abdul.b.ijaz@intel.com> writes:

Abdul> From: "Ijaz, Abdul B" <abdul.b.ijaz@intel.com>
Abdul> ---
Abdul>  gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp | 138 ++++++++++++------------
Abdul>  1 file changed, 69 insertions(+), 69 deletions(-)

Abdul> diff --git a/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp b/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
Abdul> index 6e4a331eca8..26c64278103 100644
Abdul> --- a/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
Abdul> +++ b/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
Abdul> @@ -120,7 +120,7 @@ Dwarf::assemble $asm_file {
Abdul>  # the compiler.
 
Abdul>  if { [prepare_for_testing "failed to prepare" ${testfile} \
Abdul> -	  [list $srcfile $asm_file] {nodebug}] } {
Abdul> +    [list $srcfile $asm_file] {nodebug}] } {
Abdul>      return -1
Abdul>  }
 
This hunk doesn't look correct.

The rest is ok though.

Tom

Re: [PATCH v4 2/3] gdb, types: Resolve pointer types dynamically

[Tom Tromey]

>>>>> "Abdul" == Abdul Basit Ijaz <abdul.b.ijaz@intel.com> writes:

Abdul> +  /* We only want to recognize references and pointers at the outermost
Abdul> +     level.  */
Abdul> +  if (top_level
Abdul> +      && (type->code () == TYPE_CODE_REF || type->code () == TYPE_CODE_PTR))

Seems like this could use type->is_pointer_or_reference instead.

That would also fix the oversight where TYPE_CODE_RVALUE_REF is omitted.

Abdul>    /* Types that have a dynamic TYPE_DATA_LOCATION are considered
Abdul> @@ -2779,6 +2781,7 @@ resolve_dynamic_type_internal (struct type *type,
Abdul>        switch (type->code ())
Abdul>  	{
Abdul>  	case TYPE_CODE_REF:
Abdul> +	case TYPE_CODE_PTR:

... though I guess you'd have to add TYPE_CODE_RVALUE_REF here as well.

Tom

Re: [PATCH v4 0/3] Dynamic properties of pointers

[Tom Tromey]

>>>>> "Abdul" == Abdul Basit Ijaz <abdul.b.ijaz@intel.com> writes:

Abdul> Please find the attached v4 of this series where now majorly dropped
Abdul> icc/ifort special dwarf handling related changes.  This is because
Abdul> ifx/icpx compilers does not need such handling and they may be used
Abdul> instead.  Also fix the copyrights and indentation issue as per the
Abdul> feedback on V3 series.

I sent a few notes.  Nothing very serious, this is looking good to me.

Tom

RE: [PATCH v4 1/3] gdb/testsuite: Fix indentation issues in gdb.dwarf2/dynarr-ptr.exp

[Ijaz, Abdul B]

Hi Tom,

Thanks for the feedback.

Abdul>      return -1
Abdul>  }
 
Tom > This hunk doesn't look correct.
Second line is used differently in existing testsuite (e.g. with 4 spaces or tab + 2 spaces or more etc).  I have used "4 spaces" in this patch for the splitted line. Will replace it with "Tab + 2 spaces" in V5 patch, hope it would be fine.

Best Regards,
Abdul Basit

-----Original Message-----
From: Tom Tromey <tom@tromey.com> 
Sent: Thursday, January 11, 2024 6:47 PM
To: Ijaz, Abdul B <abdul.b.ijaz@intel.com>
Cc: gdb-patches@sourceware.org; thiago.bauermann@linaro.org; tom@tromey.com; simark@simark.ca
Subject: Re: [PATCH v4 1/3] gdb/testsuite: Fix indentation issues in gdb.dwarf2/dynarr-ptr.exp

>>>>> "Abdul" == Abdul Basit Ijaz <abdul.b.ijaz@intel.com> writes:

Abdul> From: "Ijaz, Abdul B" <abdul.b.ijaz@intel.com>
Abdul> ---
Abdul>  gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp | 138 
Abdul> ++++++++++++------------
Abdul>  1 file changed, 69 insertions(+), 69 deletions(-)

Abdul> diff --git a/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp 
Abdul> b/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
Abdul> index 6e4a331eca8..26c64278103 100644
Abdul> --- a/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
Abdul> +++ b/gdb/testsuite/gdb.dwarf2/dynarr-ptr.exp
Abdul> @@ -120,7 +120,7 @@ Dwarf::assemble $asm_file {  # the compiler.
 
Abdul>  if { [prepare_for_testing "failed to prepare" ${testfile} \
Abdul> -	  [list $srcfile $asm_file] {nodebug}] } {
Abdul> +    [list $srcfile $asm_file] {nodebug}] } {
Abdul>      return -1
Abdul>  }
 
This hunk doesn't look correct.

The rest is ok though.

Tom
Intel Deutschland GmbH
Registered Address: Am Campeon 10, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de <http://www.intel.de>
Managing Directors: Christin Eisenschmid, Sharon Heck, Tiffany Doon Silva  
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928

RE: [PATCH v4 2/3] gdb, types: Resolve pointer types dynamically

[Ijaz, Abdul B]

Hi Tom,

Thanks for the feedback.

Abdul> +      && (type->code () == TYPE_CODE_REF || type->code () == 
Abdul> + TYPE_CODE_PTR))

Tom > Seems like this could use type->is_pointer_or_reference instead.

Will update to it in V5 series.

Abdul> +	case TYPE_CODE_PTR:

Tom > ... though I guess you'd have to add TYPE_CODE_RVALUE_REF here as well.

Will add it here in V5 series.

Thanks & Best Regards
Abdul Basit

-----Original Message-----
From: Tom Tromey <tom@tromey.com> 
Sent: Thursday, January 11, 2024 6:50 PM
To: Ijaz, Abdul B <abdul.b.ijaz@intel.com>
Cc: gdb-patches@sourceware.org; thiago.bauermann@linaro.org; tom@tromey.com; simark@simark.ca; Bernhard Heckel <bernhard.heckel@intel.com>
Subject: Re: [PATCH v4 2/3] gdb, types: Resolve pointer types dynamically

>>>>> "Abdul" == Abdul Basit Ijaz <abdul.b.ijaz@intel.com> writes:

Abdul> +  /* We only want to recognize references and pointers at the outermost
Abdul> +     level.  */
Abdul> +  if (top_level
Abdul> +      && (type->code () == TYPE_CODE_REF || type->code () == 
Abdul> + TYPE_CODE_PTR))

Seems like this could use type->is_pointer_or_reference instead.

That would also fix the oversight where TYPE_CODE_RVALUE_REF is omitted.

Abdul>    /* Types that have a dynamic TYPE_DATA_LOCATION are considered 
Abdul> @@ -2779,6 +2781,7 @@ resolve_dynamic_type_internal (struct type *type,
Abdul>        switch (type->code ())
Abdul>  	{
Abdul>  	case TYPE_CODE_REF:
Abdul> +	case TYPE_CODE_PTR:

... though I guess you'd have to add TYPE_CODE_RVALUE_REF here as well.

Tom
Intel Deutschland GmbH
Registered Address: Am Campeon 10, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de <http://www.intel.de>
Managing Directors: Christin Eisenschmid, Sharon Heck, Tiffany Doon Silva  
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928