Merge GDB 7.5.1

gdb/testsuite/gdb.base/funcargs.exp

 # Copyright 1992, 1994-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/>.
 
 # This file was written by Fred Fish. (fnf@cygnus.com)
 
-if $tracelevel {
-    strace $tracelevel
-}
-
 
 set testfile "funcargs"
 set srcfile ${testfile}.c
 set binfile ${objdir}/${subdir}/${testfile}
 
 set compile_flags {debug nowarnings quiet}
 if [support_complex_tests] {
     lappend compile_flags "additional_flags=-DTEST_COMPLEX"
 }
 
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable $compile_flags] != "" } {
      untested funcargs.exp
      return -1
 }
 
 # Create and source the file that provides information about the compiler
 # used to compile the test case.
-if [get_compiler_info ${binfile}] {
+if [get_compiler_info] {
     return -1;
 }
 
 #
 # Locate actual args; integral types.
 #
 
 proc integral_args {} {
     global gdb_prompt
     global det_file
@@ skipping 211 matching lines @@
     gdb_breakpoint callce
     gdb_breakpoint callcf
 
     # Run; should stop at call1a and print actual arguments.
     gdb_run_cmd
     gdb_expect {
         -re ".* callca \\(f1=1 \\+ 2 \\* I, f2=1 \\+ 2 \\* I, f3=1 \\+ 2 \\* I\\) .*$gdb_prompt $" { pass "run to call2a" }
         timeout { fail "(timeout) run to callca" ; gdb_suppress_tests; }
     }
     gdb_test "cont" ".* callcb \\(d1=3 \\+ 4 \\* I, d2=3 \\+ 4 \\* I, d3=3 \\+ 4 \\* I\\) .*" "continue to callcb"
-    gdb_test "cont" ".* callcc \\(ld1=5 \\+ 6 \\* I, ld2=5 \\+ 6 \\* I, ld3=5 \\+ 6 \\* I\\) .*" "continue to callcb"
+    gdb_test "cont" ".* callcc \\(ld1=5 \\+ 6 \\* I, ld2=5 \\+ 6 \\* I, ld3=5 \\+ 6 \\* I\\) .*" "continue to callcc"
     gdb_test "cont" ".* callcd \\(fc1=1 \\+ 2 \\* I, dc1=3 \\+ 4 \\* I, ldc1=5 \\+ 6 \\* I\\) .*" "continue to callcd"
     gdb_test "cont" ".* callce \\(dc1=3 \\+ 4 \\* I, ldc1=5 \\+ 6 \\* I, fc1=1 \\+ 2 \\* I\\) .*" "continue to callce"
     gdb_test "cont" ".* callcf \\(ldc1=5 \\+ 6 \\* I, fc1=1 \\+ 2 \\* I, dc1=3 \\+ 4 \\* I\\) .*" "continue to callcf"
 }
 
 
 #
 # Locate actual args; _Complex types and integral.
 #
 proc complex_integral_args {} {
@@ skipping 46 matching lines @@
 
     gdb_breakpoint call3a
     gdb_breakpoint call3b
     gdb_breakpoint call3c
 
     # Run; should stop at call3a and print actual arguments.
     # Try dereferencing the arguments.
 
     gdb_run_cmd
     gdb_expect {
-         -re ".* call3a \\(cp=$hex \"a.*\", sp=$hex, ip=$hex, lp=$hex\\) .*$gdb_prompt $" { pass "run to call3a" }
+         -re ".* call3a \\(cp=$hex <c> \"a.*\", sp=$hex <s>, ip=$hex <i>, lp=$hex <l>\\) .*$gdb_prompt $" { pass "run to call3a" }
          -re "$gdb_prompt $" { fail "run to call3a" ; gdb_suppress_tests; }
          timeout { fail "(timeout) run to call3a" ; gdb_suppress_tests; }
     }
 
     gdb_test "print *cp" ".* = 97 'a'"
     gdb_test "print *sp" ".* = 1"
     gdb_test "print *ip" ".* = 2"
     gdb_test "print *lp" ".* = 3"
 
     # Continue; should stop at call3b and print actual arguments.
     # Try dereferencing the arguments.
-    if [gdb_test "cont" ".* call3b \\(ucp=$hex \"b.*\", usp=$hex, uip=$hex, ulp=$hex\\) .*" "continue to call3b"] {
+    if [gdb_test "cont" ".* call3b \\(ucp=$hex <uc> \"b.*\", usp=$hex <us>, uip=$hex <ui>, ulp=$hex <ul>\\) .*" "continue to call3b"] {
         gdb_suppress_tests;
     }
 
     gdb_test "print *ucp" ".* = 98 'b'"
     gdb_test "print *usp" ".* = 6"
     gdb_test "print *uip" ".* = 7"
     gdb_test "print *ulp" ".* = 8"
 
     # Continue; should stop at call3c and print actual arguments.
     # Try dereferencing the arguments.
-    if [gdb_test "cont" ".* call3c \\(fp=$hex, dp=$hex\\) .*" "continue to call3c"] {
+    if [gdb_test "cont" ".* call3c \\(fp=$hex <f>, dp=$hex <d>\\) .*" "continue to call3c"] {
         gdb_suppress_tests;
     }
 
     gdb_test "print *fp" ".* = 4"
     gdb_test "print *dp" ".* = 5"
 
 #    pass "locate actual args, pointer types"
     gdb_stop_suppressing_tests;
 }
 
@@ skipping 12 matching lines @@
     delete_breakpoints
 
     gdb_breakpoint call4a
     gdb_breakpoint call4b
 
     # Run; should stop at call4a and print actual arguments.
     # Try dereferencing the arguments.
 
     gdb_run_cmd
     gdb_expect {
-         -re ".* call4a \\(stp=$hex\\) .*$gdb_prompt $" {
+         -re ".* call4a \\(stp=$hex <st>\\) .*$gdb_prompt $" {
             pass "run to call4a"
         }
          -re "$gdb_prompt $" { fail "run to call4a" ; gdb_suppress_tests; }
          timeout { fail "(timeout) run to call4a" ; gdb_suppress_tests; }
     }
 
     gdb_test "print *stp" ".* = \{s1 = 101, s2 = 102\}"
 
     # Continue; should stop at call4b and print actual arguments.
 
-    gdb_test "cont" ".* call4b \\(unp=$hex\\) .*" "continue to call4b"
+    gdb_test "cont" ".* call4b \\(unp=$hex <un>\\) .*" "continue to call4b"
 
     # Try dereferencing the arguments.
     if { $target_sizeof_long == $target_sizeof_int } {
         gdb_test "print *unp" ".* = \{u1 = 1, u2 = 1\}" \
                 "print *unp (sizeof long == sizeof int)"
     } elseif { ! $target_bigendian_p } {
         gdb_test "print *unp" ".* = \{u1 = 1, u2 = 1\}" \
                 "print *unp (little-endian, sizeof long != sizeof int)"
     } elseif { $target_sizeof_long == 8 && $target_sizeof_int == 4 } {
         gdb_test "print *unp" ".* = \{u1 = 1, u2 = 4294967296\}" \
@@ skipping 545 matching lines @@
             "\[\r\n\]#5 .* recurse \\(a=\{s = 4, i = 4, l = 4\}, depth=4\\) "
             "\[\r\n\]#6 .* test_struct_args \\(\\) "
             "\[\r\n\]#7 .* main \\(.*\\) at "
         }
     } else {
         fail "recursive passing of structs by value (sparclet)"
     }
     gdb_stop_suppressing_tests;
 }
 
-proc funcargs_reload { } {
-    global objdir
-    global subdir
-    global binfile
-    global srcdir
-
-    if [istarget "mips-idt-*"] {
-        # Restart because IDT/SIM runs out of file descriptors.
-        gdb_exit
-        gdb_start
-        gdb_reinitialize_dir $srcdir/$subdir
-        gdb_load ${binfile}
-    }
-}
-
 #
 # Test for accessing local stack variables in functions which call alloca
 #
 proc localvars_after_alloca { } {
     global gdb_prompt
     global hex
     global decimal
     global gcc_compiled
 
     if { ! [ runto localvars_after_alloca ] } then { gdb_suppress_tests; }
@@ skipping 234 matching lines @@
         set target_bigendian_p 1
         # pass silently
     }
 }
 
 # Perform tests
 
 gdb_test_no_output "set print frame-arguments all"
 
 integral_args
-funcargs_reload
 unsigned_integral_args
-funcargs_reload
 if {![target_info exists gdb,skip_float_tests]} {
   float_and_integral_args
 }
 
 # Test _Complex type here if supported.
 if [support_complex_tests] {
-    funcargs_reload
     complex_args
 
-    funcargs_reload
     complex_integral_args
 
     if {![target_info exists gdb,skip_float_tests]} {
-        funcargs_reload
         complex_float_integral_args
     }
 }
 
-funcargs_reload
 pointer_args
-funcargs_reload
 structs_by_reference
-funcargs_reload
 structs_by_value
-funcargs_reload
 discard_and_shuffle
-funcargs_reload
 shuffle_round_robin
-funcargs_reload
 recursive_structs_by_value
-funcargs_reload
 localvars_after_alloca
-funcargs_reload
 call_after_alloca
-funcargs_reload
 localvars_in_indirect_call
-funcargs_reload
 test_stepping_over_trampolines
 
 set timeout $prev_timeout