GDB 7.6.50

gdb/testsuite/gdb.cp/derivation.exp

-# Copyright 1998-2004, 2007-2012 Free Software Foundation, Inc.
+# Copyright 1998-2013 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.
@@ skipping 13 matching lines @@
 set ws "\[\r\n\t \]+"
 set nl "\[\r\n\]+"
 
 # Start program.
 
 
 if { [skip_cplus_tests] } { continue }
 
 load_lib "cp-support.exp"
 
-standard_testfile .cc
+standard_testfile derivation.cc derivation2.cc
 
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing $testfile.exp $testfile \
+        [list $srcfile $srcfile2] {debug c++}]} {
     return -1
 }
 
+# Check inheritance of typedefs.
+with_test_prefix "before run" {
+    foreach klass {"A" "D" "E" "F" "A2" "D2"} {
+        gdb_test "ptype ${klass}::value_type" "type = int"
+        gdb_test "whatis ${klass}::value_type" "type = int"
+        gdb_test "p (${klass}::value_type) 0" " = 0"
+    }
+    foreach klass {"Z" "ZZ"} {
+        gdb_test "ptype ${klass}::value_type" "type = float"
+        gdb_test "whatis ${klass}::value_type" "type = float"
+        gdb_test "p (${klass}::value_type) 0" " = 0"
+    }
+}
+
 # Set it up at a breakpoint so we can play with the variable values.
 
 if ![runto 'marker1'] then {
     perror "couldn't run to marker1"
     continue
 }
 
+# Check inheritance of typedefs again, but this time with an active block.
+with_test_prefix "at marker1" {
+    foreach klass {"A" "D" "A2" "D2"} {
+        gdb_test "ptype ${klass}::value_type" "type = int"
+        gdb_test "whatis ${klass}::value_type" "type = int"
+        gdb_test "p (${klass}::value_type) 0" " = 0"
+    }
+}
+
 gdb_test "up" ".*main.*" "up from marker1"
 
 # Print class types and values.
 
 # class A
 
 gdb_test "print a_instance" "\\$\[0-9\]+ = \{a = 1, aa = 2\}" "print value of a_instance"
 
 cp_test_ptype_class \
-    "ptype a_instance" "" "class" "A" \
+    "a_instance" "" "class" "A" \
     {
-        { field  public "int a;" }
-        { field  public "int aa;" }
+        { field  public "A::value_type a;" }
+        { field  public "A::value_type aa;" }
         { method public "A();" }
-        { method public "int afoo();" }
-        { method public "int foo();" }
+        { method public "A::value_type afoo();" }
+        { method public "A::value_type foo();" }
+        { typedef public "typedef int value_type;" }
     }
 
 # class D
 
 gdb_test_multiple "print d_instance" "print value of d_instance" {
     -re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, d = 7, dd = 8\}$nl$gdb_prompt $" {
         pass "print value of d_instance"
     }
 }
 
 cp_test_ptype_class \
-    "ptype d_instance" "" "class" "D" \
+    "d_instance" "" "class" "D" \
     {
         { base          "private A" }
         { base          "public B" }
         { base          "protected C" }
-        { field  public "int d;" }
-        { field  public "int dd;" }
+        { field  public "A::value_type d;" }
+        { field  public "A::value_type dd;" }
         { method public "D();" }
-        { method public "int dfoo();" }
-        { method public "int foo();" }
+        { method public "A::value_type dfoo();" }
+        { method public "A::value_type foo();" }
     } \
     "" \
     {
         { "protected C" "private C" { setup_xfail "*-*-*" "gcc/13539" } }
     }
 
 # class E
 
 gdb_test_multiple "print e_instance" "print value of e_instance" {
     -re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, e = 9, ee = 10\}$nl$gdb_prompt $" {
         pass "print value of e_instance"
     }
 }
 
 cp_test_ptype_class \
-    "ptype e_instance" "" "class" "E" \
+    "e_instance" "" "class" "E" \
     {
         { base          "public A" }
         { base          "private B" }
         { base          "protected C" }
-        { field  public "int e;" }
-        { field  public "int ee;" }
+        { field  public "A::value_type e;" }
+        { field  public "A::value_type ee;" }
         { method public "E();" }
-        { method public "int efoo();" }
-        { method public "int foo();" }
+        { method public "A::value_type efoo();" }
+        { method public "A::value_type foo();" }
     } \
     "" \
     {
         { "protected C" "private C" { setup_xfail "*-*-*" "gcc/13539" } }
     }
 
 # class F
 
 gdb_test_multiple "print f_instance" "print value of f_instance" {
     -re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, f = 11, ff = 12\}$nl$gdb_prompt $" {
         pass "print value of f_instance"
     }
 }
 
 cp_test_ptype_class \
-    "ptype f_instance" "" "class" "F" \
+    "f_instance" "" "class" "F" \
     {
         { base          "private A" }
         { base          "public B" }
         { base          "private C" }
-        { field  public "int f;" }
-        { field  public "int ff;" }
+        { field  public "A::value_type f;" }
+        { field  public "A::value_type ff;" }
         { method public "F();" }
-        { method public "int ffoo();" }
+        { method public "A::value_type ffoo();" }
+        { method public "A::value_type foo();" }
+    }
+
+# class G
+cp_test_ptype_class \
+    "g_instance" "" "class" "G" \
+    {
+        { base          "private A" }
+        { base          "public B" }
+        { base          "protected C" }
+        { field public "int g;" }
+        { field public "int gg;" }
+        { field public "int a;" }
+        { field public "int b;" }
+        { field public "int c;" }
+        { method public "int gfoo();" }
         { method public "int foo();" }
     }
 
 # Print individual fields.
 
 gdb_test "print d_instance.a"  "\\$\[0-9\]+ = 1" "print value of d_instance.a"
 gdb_test "print d_instance.aa" "\\$\[0-9\]+ = 2" "print value of d_instance.aa"
 gdb_test "print d_instance.b"  "\\$\[0-9\]+ = 3" "print value of d_instance.b"
 gdb_test "print d_instance.bb" "\\$\[0-9\]+ = 4" "print value of d_instance.bb"
 gdb_test "print d_instance.c"  "\\$\[0-9\]+ = 5" "print value of d_instance.c"
@@ skipping 25 matching lines @@
         gdb_test "finish" ".*main.*at .*derivation.cc:.*// marker1-returns-here.*" \
             "finish call to marker1"
     }
     -re "#1  ($hex in )?main.*$gdb_prompt $" {
         pass "re-selected 'main' frame after inferior call"
     }
 }
 
 gdb_test "print g_instance.bfoo()" "\\$\[0-9\]+ = 2" "print value of g_instance.bfoo()"
 gdb_test "print g_instance.cfoo()" "\\$\[0-9\]+ = 3" "print value of g_instance.cfoo()"
+
+# Check typedefs of fields
+foreach Klass {"C" "G"} {
+    set klass [string tolower $Klass]
+    set instance "${klass}_instance"
+    set var "${instance}.$klass"
+    gdb_test "whatis $var" "int"
+    gdb_test "ptype $var" "int"
+}
+
+foreach Klass {"A" "B" "D" "E" "F"} {
+    set klass [string tolower $Klass]
+    set instance "${klass}_instance"
+    set var "${instance}.$klass"
+    gdb_test "whatis $var" "A::value_type"
+    gdb_test "ptype $var" "int"
+    if {![string equal $Klass "B"]} {
+        gdb_test "p (${Klass}::value_type) 0" " = 0"
+    }
+}
+
+foreach Klass {"Z" "ZZ"} {
+    set klass [string tolower $Klass]
+    set instance "${klass}_instance"
+    set var "${instance}.$klass"
+    gdb_test "whatis $var" "Z::value_type"
+    gdb_test "ptype $var" "float"
+    gdb_test "p (${Klass}::value_type) 0" " = 0"
+}
+
+# This is a regression test for a bug that caused a crash when trying
+# to print the vtbl pointer.  We don't care about the output so much
+# here (it is tested elsewhere), just that gdb doesn't crash.  We test
+# "ptype" first because, before the gdb fix, that was the only code
+# path calling get_vptr_fieldno.
+gdb_test "ptype vderived" "type = .*"
+gdb_test "print vderived" " = {.* inter = 0.*x = 0}"
+
+# Test whether inheritance of typedefs is properly
+# reported when stopped.
+gdb_test "ptype N::value_type" "type = double"
+gdb_test "ptype N::Derived::value_type" "type = int"
+
+# Now run to N::Derived::doit and get the type of "value_type"
+if {![runto "N::Derived::doit"]} {
+    perror "couldn't run to N::Derived::doit"
+    continue
+}
+
+gdb_test "ptype value_type" "type = int"