Merge GDB 7.5.1

gdb/testsuite/gdb.base/printcmds.exp

 # This testcase is part of GDB, the GNU debugger.
 
 # Copyright 1992, 1994-1997, 1999-2000, 2002-2004, 2007-2012 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/>.
 
 # Please email any bugs, comments, and/or additions to this file to:
 # bug-gdb@gnu.org
 
 # This file was written by Fred Fish. (fnf@cygnus.com)
 
-if $tracelevel then {
-        strace $tracelevel
-}
-
 set testfile "printcmds"
 set srcfile ${testfile}.c
 set binfile ${objdir}/${subdir}/${testfile}
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
      untested printcmds.exp
      return -1
 }
 
-get_compiler_info ${binfile}
+get_compiler_info
 
 proc test_integer_literals_accepted {} {
     global gdb_prompt
 
     # Test various decimal values.
 
     gdb_test "p 123" " = 123"
     gdb_test "p -123" " = -123"
     gdb_test "p/d 123" " = 123"
 
@@ skipping 372 matching lines @@
     gdb_test "p ctable1\[252\]" " = 252 '\\\\374'"
     gdb_test "p ctable1\[253\]" " = 253 '\\\\375'"
     gdb_test "p ctable1\[254\]" " = 254 '\\\\376'"
     gdb_test "p ctable1\[255\]" " = 255 '\\\\377'"
 }
 
 # Test interaction of the number of print elements to print and the
 # repeat count, set to the default of 10.
 
 proc test_print_repeats_10 {} {
-    global gdb_prompt
+    global gdb_prompt decimal
 
     for { set x 1; } { $x <= 16 } { incr x; } {
         gdb_test_no_output "set print elements $x"
         for { set e 1; } { $e <= 16 } {incr e; } {
             set v [expr $e - 1];
             set command "p &ctable2\[${v}*16\]"
             if { $x < $e } {
                 set aval $x;
             } else {
                 set aval $e;
@@ skipping 21 matching lines @@
                     set xstr "[string range "XXXXXXXXXXXXXXXX" 1 $xval]\\\"";
                 } else {
                     if { $aval <= 10 } {
                         set xstr "\\\"";
                     }
                 }
             }
             if { $aval < 16 } {
                 set xstr "${xstr}\[.\]\[.\]\[.\]"
             }
-            set string " = \[(\]unsigned char \[*\]\[)\] ${a}${xstr}";
+            set string " = \[(\]unsigned char \[*\]\[)\] <ctable2(\\+$decimal)?> ${a}${xstr}";
             gdb_test "$command" "$string" "$command with print elements set to $x";
         }
     }
 }
 
 # This tests whether GDB uses the correct element content offsets
 # (relative to the complete `some_struct' value) when counting value
 # repetitions.
 
 proc test_print_repeats_embedded_array {} {
     global gdb_prompt
 
     gdb_test_escape_braces "p/x some_struct" \
         "= {a = 0x12345678, b = 0x87654321, array = {0xaa <repeats 20 times>}}" \
         "correct element repeats in array embedded at offset > 0"
 }
 
 proc test_print_strings {} {
-    global gdb_prompt
+    global gdb_prompt decimal
 
     # We accept "(unsigned char *) " before the string.  char vs. unsigned char
     # is already tested elsewhere.
 
     # Test that setting print elements unlimited doesn't completely suppress
     # printing; this was a bug in older gdb's.
     gdb_test_no_output "set print elements 0"
     gdb_test "p teststring" \
         " = (.unsigned char .. )?\"teststring contents\"" "p teststring with elements set to 0"
     gdb_test_no_output "set print elements 1"
     gdb_test "p teststring" \
         " = (.unsigned char .. )?\"t\"\\.\\.\\." "p teststring with elements set to 1"
     gdb_test_no_output "set print elements 5"
     gdb_test "p teststring" \
         " = (.unsigned char .. )?\"tests\"\\.\\.\\." "p teststring with elements set to 5"
     gdb_test_no_output "set print elements 19"
     gdb_test "p teststring" \
         " = (.unsigned char .. )?\"teststring contents\"" "p teststring with elements set to 19"
     gdb_test_no_output "set print elements 20"
     gdb_test "p teststring" \
         " = (.unsigned char .. )?\"teststring contents\"" "p teststring with elements set to 20"
 
     gdb_test_no_output "set print elements 8"
 
     gdb_test "p &ctable1\[0\]" \
-        " = \\(unsigned char \\*\\) \"\""
+        " = \\(unsigned char \\*\\) <ctable1> \"\""
     gdb_test "p &ctable1\[1\]" \
-        " = \\(unsigned char \\*\\) \"\\\\001\\\\002\\\\003\\\\004\\\\005\\\\006\\\\a\\\\b\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\001\\\\002\\\\003\\\\004\\\\005\\\\006\\\\a\\\\b\"..."
     gdb_test "p &ctable1\[1*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\b\\\\t\\\\n\\\\v\\\\f\\\\r\\\\016\\\\017\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\b\\\\t\\\\n\\\\v\\\\f\\\\r\\\\016\\\\017\"..."
     gdb_test "p &ctable1\[2*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\020\\\\021\\\\022\\\\023\\\\024\\\\025\\\\026\\\\027\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\020\\\\021\\\\022\\\\023\\\\024\\\\025\\\\026\\\\027\"..."
     gdb_test "p &ctable1\[3*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\030\\\\031\\\\032\\\\033\\\\034\\\\035\\\\036\\\\037\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\030\\\\031\\\\032\\\\033\\\\034\\\\035\\\\036\\\\037\"..."
     gdb_test "p &ctable1\[4*8\]" \
-        " = \\(unsigned char \\*\\) \" !\\\\\"#\\\$%&'\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \" !\\\\\"#\\\$%&'\"..."
     gdb_test "p &ctable1\[5*8\]" \
-        " = \\(unsigned char \\*\\) \"\\(\\)\\*\\+,-./\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\(\\)\\*\\+,-./\"..."
     gdb_test "p &ctable1\[6*8\]" \
-        " = \\(unsigned char \\*\\) \"01234567\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"01234567\"..."
     gdb_test "p &ctable1\[7*8\]" \
-        " = \\(unsigned char \\*\\) \"89:;<=>\\?\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"89:;<=>\\?\"..."
     gdb_test "p &ctable1\[8*8\]" \
-        " = \\(unsigned char \\*\\) \"@ABCDEFG\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"@ABCDEFG\"..."
     gdb_test "p &ctable1\[9*8\]" \
-        " = \\(unsigned char \\*\\) \"HIJKLMNO\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"HIJKLMNO\"..."
     gdb_test "p &ctable1\[10*8\]" \
-        " = \\(unsigned char \\*\\) \"PQRSTUVW\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"PQRSTUVW\"..."
     gdb_test "p &ctable1\[11*8\]" \
-        " = \\(unsigned char \\*\\) \"XYZ\\\[\\\\\\\\\\\]\\^_\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"XYZ\\\[\\\\\\\\\\\]\\^_\"..."
     gdb_test "p &ctable1\[12*8\]" \
-        " = \\(unsigned char \\*\\) \"`abcdefg\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"`abcdefg\"..."
     gdb_test "p &ctable1\[13*8\]" \
-        " = \\(unsigned char \\*\\) \"hijklmno\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"hijklmno\"..."
     gdb_test "p &ctable1\[14*8\]" \
-        " = \\(unsigned char \\*\\) \"pqrstuvw\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"pqrstuvw\"..."
     gdb_test "p &ctable1\[15*8\]" \
-        " = \\(unsigned char \\*\\) \"xyz\[{|}\]+\\~\\\\177\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"xyz\[{|}\]+\\~\\\\177\"..."
     gdb_test "p &ctable1\[16*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\200\\\\201\\\\202\\\\203\\\\204\\\\205\\\\206\\\\207\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\200\\\\201\\\\202\\\\203\\\\204\\\\205\\\\206\\\\207\"..."
     gdb_test "p &ctable1\[17*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\210\\\\211\\\\212\\\\213\\\\214\\\\215\\\\216\\\\217\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\210\\\\211\\\\212\\\\213\\\\214\\\\215\\\\216\\\\217\"..."
     gdb_test "p &ctable1\[18*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\220\\\\221\\\\222\\\\223\\\\224\\\\225\\\\226\\\\227\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\220\\\\221\\\\222\\\\223\\\\224\\\\225\\\\226\\\\227\"..."
     gdb_test "p &ctable1\[19*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\230\\\\231\\\\232\\\\233\\\\234\\\\235\\\\236\\\\237\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\230\\\\231\\\\232\\\\233\\\\234\\\\235\\\\236\\\\237\"..."
     gdb_test "p &ctable1\[20*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\240\\\\241\\\\242\\\\243\\\\244\\\\245\\\\246\\\\247\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\240\\\\241\\\\242\\\\243\\\\244\\\\245\\\\246\\\\247\"..."
     gdb_test "p &ctable1\[21*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\250\\\\251\\\\252\\\\253\\\\254\\\\255\\\\256\\\\257\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\250\\\\251\\\\252\\\\253\\\\254\\\\255\\\\256\\\\257\"..."
     gdb_test "p &ctable1\[22*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\260\\\\261\\\\262\\\\263\\\\264\\\\265\\\\266\\\\267\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\260\\\\261\\\\262\\\\263\\\\264\\\\265\\\\266\\\\267\"..."
     gdb_test "p &ctable1\[23*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\270\\\\271\\\\272\\\\273\\\\274\\\\275\\\\276\\\\277\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\270\\\\271\\\\272\\\\273\\\\274\\\\275\\\\276\\\\277\"..."
     gdb_test "p &ctable1\[24*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\300\\\\301\\\\302\\\\303\\\\304\\\\305\\\\306\\\\307\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\300\\\\301\\\\302\\\\303\\\\304\\\\305\\\\306\\\\307\"..."
     gdb_test "p &ctable1\[25*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\310\\\\311\\\\312\\\\313\\\\314\\\\315\\\\316\\\\317\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\310\\\\311\\\\312\\\\313\\\\314\\\\315\\\\316\\\\317\"..."
     gdb_test "p &ctable1\[26*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\320\\\\321\\\\322\\\\323\\\\324\\\\325\\\\326\\\\327\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\320\\\\321\\\\322\\\\323\\\\324\\\\325\\\\326\\\\327\"..."
     gdb_test "p &ctable1\[27*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\330\\\\331\\\\332\\\\333\\\\334\\\\335\\\\336\\\\337\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\330\\\\331\\\\332\\\\333\\\\334\\\\335\\\\336\\\\337\"..."
     gdb_test "p &ctable1\[28*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\340\\\\341\\\\342\\\\343\\\\344\\\\345\\\\346\\\\347\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\340\\\\341\\\\342\\\\343\\\\344\\\\345\\\\346\\\\347\"..."
     gdb_test "p &ctable1\[29*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\350\\\\351\\\\352\\\\353\\\\354\\\\355\\\\356\\\\357\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\350\\\\351\\\\352\\\\353\\\\354\\\\355\\\\356\\\\357\"..."
     gdb_test "p &ctable1\[30*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\360\\\\361\\\\362\\\\363\\\\364\\\\365\\\\366\\\\367\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\360\\\\361\\\\362\\\\363\\\\364\\\\365\\\\366\\\\367\"..."
     gdb_test "p &ctable1\[31*8\]" \
-        " = \\(unsigned char \\*\\) \"\\\\370\\\\371\\\\372\\\\373\\\\374\\\\375\\\\376\\\\377\"..."
+        " = \\(unsigned char \\*\\) <ctable1\\+$decimal> \"\\\\370\\\\371\\\\372\\\\373\\\\374\\\\375\\\\376\\\\377\"..."
 }
 
 proc test_print_int_arrays {} {
     global gdb_prompt
 
     gdb_test_no_output "set print elements 24"
 
     gdb_test_escape_braces "p int1dim" \
         " = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}"
     gdb_test_escape_braces "p int2dim" \
@@ skipping 30 matching lines @@
     gdb_test_escape_braces "p int1dim\[0\]\026@2" " = {0, 1}" {p int1dim[0]@2}
     gdb_test_escape_braces "p int1dim\[0\]\026@2\026@3" \
         "({{0, 1}, {2, 3}, {4, 5}}|\[Cc\]annot.*)" \
         {p int1dim[0]@2@3}
     gdb_test_escape_braces {p/x (short [])0x12345678} \
         " = ({0x1234, 0x5678}|{0x5678, 0x1234})"
 }
 
 proc test_print_char_arrays {} {
     global gdb_prompt
-    global hex
+    global hex decimal
 
     gdb_test_no_output "set print elements 24"
     gdb_test_no_output "set print address on"
 
     gdb_test "p arrays" \
         " = {array1 = \"abc\", array2 = \"d\", array3 = \"e\", array4 = \"fg\", array5 = \"hij\"}"
 
-    gdb_test "p parrays"                " = \\(struct some_arrays \\*\\) $hex"
+    gdb_test "p parrays"                " = \\(struct some_arrays \\*\\) $hex <arrays>"
     gdb_test "p parrays->array1"        " = \"abc\""
-    gdb_test "p &parrays->array1"       " = \\(unsigned char \\(\\*\\)\\\[4\\\]\\) $hex"
+    gdb_test "p &parrays->array1"       " = \\(unsigned char \\(\\*\\)\\\[4\\\]\\) $hex <arrays>"
     gdb_test "p parrays->array2"        " = \"d\""
-    gdb_test "p &parrays->array2"       " = \\(unsigned char \\(\\*\\)\\\[1\\\]\\) $hex"
+    gdb_test "p &parrays->array2"       " = \\(unsigned char \\(\\*\\)\\\[1\\\]\\) $hex <arrays\\+$decimal>"
     gdb_test "p parrays->array3"        " = \"e\""
-    gdb_test "p &parrays->array3"       " = \\(unsigned char \\(\\*\\)\\\[1\\\]\\) $hex"
+    gdb_test "p &parrays->array3"       " = \\(unsigned char \\(\\*\\)\\\[1\\\]\\) $hex <arrays\\+$decimal>"
     gdb_test "p parrays->array4"        " = \"fg\""
-    gdb_test "p &parrays->array4"       " = \\(unsigned char \\(\\*\\)\\\[2\\\]\\) $hex"
+    gdb_test "p &parrays->array4"       " = \\(unsigned char \\(\\*\\)\\\[2\\\]\\) $hex <arrays\\+$decimal>"
     gdb_test "p parrays->array5"        " = \"hij\""
-    gdb_test "p &parrays->array5"       " = \\(unsigned char \\(\\*\\)\\\[4\\\]\\) $hex"
+    gdb_test "p &parrays->array5"       " = \\(unsigned char \\(\\*\\)\\\[4\\\]\\) $hex <arrays\\+$decimal>"
 
     gdb_test_no_output "set print address off"
 }
 
 proc test_print_string_constants {} {
     global gdb_prompt
 
     gdb_test_no_output "set print elements 50"
 
     if [target_info exists gdb,cannot_call_functions] {
@@ skipping 34 matching lines @@
     gdb_test_escape_braces "print {0,1,2}"    " = {0, 1, 2}"
     gdb_test_escape_braces "print {(long)0,(long)1,(long)2}"  " = {0, 1, 2}"
     gdb_test_escape_braces "print {{0,1,2},{3,4,5}}"  " = {{0, 1, 2}, {3, 4, 5}}"
     gdb_test "print {4,5,6}\[2\]"       " = 6"
     gdb_test "print *&{4,5,6}\[1\]"     "Attempt to take address of value not located in memory."
 }
 
 proc test_print_enums {} {
     # Regression test for PR11827.
     gdb_test "print some_volatile_enum" "enumvolval1"
+
+    gdb_test "print three" " = \\\(ONE \\| TWO\\\)"
 }
 
 proc test_printf {} {
     gdb_test "printf \"x=%d,y=%d,z=%d\\n\", 5, 6, 7" "x=5,y=6,z=7"
     gdb_test "printf \"string=%.4sxx\\n\", teststring" "string=testxx"
     gdb_test "printf \"string=%sxx\\n\", teststring" \
         "string=teststring contentsxx"
 
     gdb_test "printf \"%f is fun\\n\", 1.0" "1\.0+ is fun"
 
@@ skipping 54 matching lines @@
     gdb_test "printf \"%DDf\\n\",-1234567890123456789012345678901234.dl" "-1234567890123456789012345678901234"
 
     gdb_test "printf \"%DDf\\n\",1.2E1dl" "12"
     gdb_test "printf \"%DDf\\n\",1.2E10dl" "1.2E\\+10"
     gdb_test "printf \"%DDf\\n\",1.2E-10dl" "1.2E-10"
 
     # The largest exponent for 128-bit dfp value is 6144.
     gdb_test "printf \"%DDf\\n\",1.2E6144dl" "1.200000000000000000000000000000000E\\+6144"
 }
 
+proc test_print_symbol {} {
+    gdb_test_no_output "set print symbol on"
+
+    gdb_test "print &three" " = .* <three>"
+    gdb_test "print parrays" " = .* <arrays>"
+
+    # In case somebody adds tests after this.
+    gdb_test_no_output "set print symbol off"
+}
+
 # Escape a left curly brace to prevent it from being interpreted as 
 # the beginning of a bound
 proc gdb_test_escape_braces { args } {
 
     set pattern [lindex $args 1]
     regsub -all {\{[0-9]} $pattern {\\&} esc_pattern
     gdb_test [lindex $args 0] $esc_pattern [lindex $args 2]
 }
 
 # Start with a fresh gdb.
@@ skipping 47 matching lines @@
 test_print_int_arrays
 test_print_typedef_arrays
 test_artificial_arrays
 test_print_char_arrays
 # We used to do the runto main here.
 test_print_string_constants
 test_print_array_constants
 test_print_enums
 test_printf
 test_printf_with_dfp
+test_print_symbol