gdb/testsuite/gdb.trace/backtrace.exp

   1 #   Copyright 1998-2013 Free Software Foundation, Inc.
   2 #
   3 # This program is free software; you can redistribute it and/or modify
   4 # it under the terms of the GNU General Public License as published by
   5 # the Free Software Foundation; either version 3 of the License, or
   6 # (at your option) any later version.
   7 #
   8 # This program is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 # GNU General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU General Public License
  14 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16 # This file was written by Michael Snyder (msnyder@cygnus.com)
  17
  18 load_lib "trace-support.exp"
  19
  20
  21 gdb_exit
  22 gdb_start
  23
  24 standard_testfile actions.c
  25 if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile \
  26           executable {debug nowarnings}] != "" } {
  27     untested backtrace.exp
  28     return -1
  29 }
  30 gdb_load $binfile
  31 gdb_test "tstop"       ".*" ""
  32 gdb_test "tfind none"  ".*" ""
  33 runto_main
  34 gdb_reinitialize_dir $srcdir/$subdir
  35
  36 if { ![gdb_target_supports_trace] } then {
  37     unsupported "Current target does not support trace"
  38     return 1
  39
  40 }
  41
  42 #
  43 # test backtraces in trace frames
  44 #
  45
  46 set testline1 0
  47 set testline2 0
  48 set testline3 0
  49 set testline4 0
  50 set testline5 0
  51 set testline6 0
  52
  53 set arg1 1
  54 set arg2 2
  55 set arg3 3
  56 set arg4 4
  57 set arg5 5
  58 set arg6 6
  59
  60 set baseline [gdb_find_recursion_test_baseline $srcfile]
  61 if { $baseline == -1 } {
  62     fail "Could not find gdb_recursion_test function"
  63     return
  64 }
  65
  66 set return_me 0
  67
  68 gdb_test_multiple "list $baseline, +12" "all tests in this module will fail" {
  69     -re "\[\r\n\](\[0-9\]+).*gdbtestline 1 " {
  70         set testline1 $expect_out(1,string)
  71         exp_continue
  72     }
  73     -re "\[\r\n\](\[0-9\]+).*gdbtestline 2 " {
  74         set testline2 $expect_out(1,string)
  75         exp_continue
  76     }
  77     -re "\[\r\n\](\[0-9\]+).*gdbtestline 3 " {
  78         set testline3 $expect_out(1,string)
  79         exp_continue
  80     }
  81     -re "\[\r\n\](\[0-9\]+).*gdbtestline 4 " {
  82         set testline4 $expect_out(1,string)
  83         exp_continue
  84     }
  85     -re "\[\r\n\](\[0-9\]+).*gdbtestline 5 " {
  86         set testline5 $expect_out(1,string)
  87         exp_continue
  88     }
  89     -re "\[\r\n\](\[0-9\]+).*gdbtestline 6 " {
  90         set testline6 $expect_out(1,string)
  91         exp_continue
  92     }
  93     -re ".*$gdb_prompt $" {
  94         if { ($testline1 == 0) || ($testline2 == 0) || ($testline3 == 0) || ($testline4 == 0) || ($testline5 == 0) || ($testline6 == 0) } {
  95             untested backtrace.exp
  96             set return_me 1
  97 all tests in this module will fail."
  98         }
  99     }
 100     default {
 101             untested backtrace.exp
 102             set return_me 1
 103 all tests in this module will fail."
 104     }
 105 }
 106
 107 if { $return_me == 1 } then {
 108     return -1
 109 }
 110
 111 #
 112 # Setup backtrace experiment.  This will involve:
 113 #   1) a tracepoint where nothing is collected
 114 #   2) a tracepoint where only regs are collected
 115 #   3) a tracepoint where regs, locals and args are collected
 116 #   4) a tracepoint where regs plus some amount of stack are collected.
 117 #
 118
 119 gdb_delete_tracepoints
 120 set tdp2 [gdb_gettpnum $testline2]
 121 set tdp3 [gdb_gettpnum $testline3]
 122 set tdp4 [gdb_gettpnum $testline4]
 123 set tdp5 [gdb_gettpnum $testline5]
 124 set tdp6 [gdb_gettpnum $testline6]
 125 if {    $tdp2 <= 0 || $tdp3 <= 0 || \
 126         $tdp4 <= 0 || $tdp5 <= 0 || $tdp6 <= 0 } then {
 127     fail "setting tracepoints failed"
 128     return
 129 }
 130
 131 #gdb_trace_setactions "setup TP to collect FP" \
 132 #       "$tdp2" \
 133 #       "collect \$fp" ""
 134 #
 135
 136 gdb_trace_setactions "8.6: setup TP to collect regs" \
 137         "$tdp3" \
 138         "collect \$regs" "^$"
 139
 140 gdb_trace_setactions "8.6: setup TP to collect regs, args, and locals" \
 141         "$tdp4" \
 142         "collect \$regs, \$args, \$locs" "^$"
 143
 144 if [is_amd64_regs_target] {
 145     set fpreg "\$rbp"
 146     set spreg "\$rsp"
 147 } elseif [is_x86_like_target] {
 148     set fpreg "\$ebp"
 149     set spreg "\$esp"
 150 } else {
 151     set fpreg "\$fp"
 152     set spreg "\$sp"
 153 }
 154
 155 gdb_trace_setactions "8.6: setup TP to collect stack mem cast expr" \
 156        "$tdp6" \
 157        "collect $fpreg, \(\*\(void \*\*\) \($spreg\)\) @ 64" "^$"
 158
 159 gdb_test "tstart" ".*" ""
 160
 161 gdb_test "break end" ".*" ""
 162 gdb_test "continue" \
 163     "Continuing.*Breakpoint $decimal, end.*" \
 164     "run trace experiment"
 165
 166 gdb_test "tstop" ".*" ""
 167
 168 proc gdb_backtrace_tdp_1 { msg } {
 169     global gdb_prompt
 170
 171     # We are in a trace frame at which we didn't collect anything
 172     # except $PC.  Therefore we expect to be able to identify stack
 173     # frame #0, but that's about all.  In particular we do not expect
 174     # to be able to display the function's arguments or locals, and we
 175     # do not expect to be able to identify the caller of this function.
 176
 177     gdb_test "backtrace" \
 178         "#0\[\t \]+gdb_recursion_test.*depth=.*" \
 179         "$msg"
 180 }
 181
 182 proc gdb_backtrace_tdp_2 { msg } {
 183     global gdb_prompt
 184
 185     # We are in a trace frame at which we collected only the registers
 186     # Therefore we expect to be able to identify stack frame #0, but
 187     # we don't expect to be able to display its args unles they are
 188     # passed in registers (which isn't the case for m68k), and we
 189     # don't expect to be able to identify the caller's stack frame.
 190
 191     gdb_test "backtrace" \
 192         "#0\[\t \]+gdb_recursion_test.*depth=.*" \
 193         "$msg"
 194 }
 195
 196 proc gdb_backtrace_tdp_3 { msg } {
 197     global gdb_prompt
 198
 199     # We are in a trace frame at which we collected all registers, all
 200     # arguments and all locals.  This means that the display of
 201     # stack frame #0 should be complete (including argument values).
 202
 203     gdb_test_multiple "backtrace" "$msg" {
 204         -re "#0\[\t \]+gdb_recursion_test.*depth=\[0-9\]+.*q1=\[0-9\]+.*q2=\[0-9\]+.*q3=\[0-9\]+.*q4=\[0-9\]+.*q5=\[0-9\]+.*q6=\[0-9\]+.*$gdb_prompt $" {
 205             pass "$msg"
 206         }
 207         -re "#0\[\t \]+gdb_recursion_test.*depth=Cannot access.*$gdb_prompt $" {
 208             fail "$msg (failed to collect arguments)"
 209         }
 210     }
 211 }
 212
 213 proc gdb_backtrace_tdp_4 { msg depth } {
 214     global gdb_prompt
 215
 216     # We are in a trace frame at which we collected all registers,
 217     # plus a sizeable hunk of stack memory.  This should enable us to
 218     # display at least several stack frames worth of backtrace.  We'll
 219     # assume that if we can't display at least "depth" levels (with
 220     # args), it counts as an error.
 221
 222     gdb_test_multiple "backtrace" "$msg" {
 223         -re "#$depth\[\t \].*gdb_recursion_test.*depth=\[0-9\]+.*q1=\[0-9\]+.*q2=\[0-9\]+.*q3=\[0-9\]+.*q4=\[0-9\]+.*q5=\[0-9\]+.*q6=\[0-9\]+.*$gdb_prompt $" {
 224             pass "$msg"
 225         }
 226         -re "#$depth\[\t \].*gdb_recursion_test.*depth=.*$gdb_prompt $" {
 227             fail "$msg (args missing from #$depth stack frame)"
 228         }
 229         -re "#\[0-9\]+\[\t \].*gdb_recursion_test.*depth=.*$gdb_prompt $" {
 230             fail "$msg (fewer than $depth stack frames found)"
 231         }
 232     }
 233 }
 234
 235 #
 236 # begin backtrace test
 237 #
 238
 239 set timeout 60
 240
 241 gdb_tfind_test "init: make sure not debugging any trace frame" "none" "-1"
 242
 243 gdb_tfind_test "8.6: find start frame" "start" "0"
 244 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 245         "TDP $tdp2:" ""
 246 gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 1, collect nothing"
 247
 248 gdb_tfind_test "8.6: find frame 1"     "1" "1"
 249 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 250         "TDP $tdp3:" ""
 251 gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 1, collect regs"
 252
 253 gdb_tfind_test "8.6: find frame 2"     "2" "2"
 254 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 255         "TDP $tdp4:" ""
 256 gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 1, collect args and locals"
 257
 258
 259 gdb_tfind_test "8.6: find frame 4"     "4" "4"
 260 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 261         "TDP $tdp6:" ""
 262 gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0"
 263
 264 gdb_tfind_test "8.6: find frame 5"     "5" "5"
 265 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 266         "TDP $tdp2:" ""
 267 gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 2, collect nothing"
 268
 269 gdb_tfind_test "8.6: find frame 6"     "6" "6"
 270 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 271         "TDP $tdp3:" ""
 272 gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 2, collect regs"
 273
 274 gdb_tfind_test "8.6: find frame 7"     "7" "7"
 275 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 276         "TDP $tdp4:" ""
 277 gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 2, collect args and locals"
 278
 279
 280 gdb_tfind_test "8.6: find frame 9"     "9" "9"
 281 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 282         "TDP $tdp6:" ""
 283 gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0"
 284
 285 gdb_tfind_test "8.6: find frame 10"    "10" "10"
 286 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 287         "TDP $tdp2:" ""
 288 gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 3, collect nothing"
 289
 290 gdb_tfind_test "8.6: find frame 11"    "11" "11"
 291 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 292         "TDP $tdp3:" ""
 293 gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 3, collect regs"
 294
 295 gdb_tfind_test "8.6: find frame 12"    "12" "12"
 296 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 297         "TDP $tdp4:" ""
 298 gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 3, collect args and locals"
 299
 300
 301 gdb_tfind_test "8.6: find frame 14"    "14" "14"
 302 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 303         "TDP $tdp6:" ""
 304 gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0"
 305
 306 gdb_tfind_test "8.6: find frame 15"    "15" "15"
 307 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 308         "TDP $tdp2:" ""
 309 gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 4, collect nothing"
 310
 311 gdb_tfind_test "8.6: find frame 16"    "16" "16"
 312 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 313         "TDP $tdp3:" ""
 314 gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 4, collect regs"
 315
 316 gdb_tfind_test "8.6: find frame 17"    "17" "17"
 317 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 318         "TDP $tdp4:" ""
 319 gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 4, collect args and locals"
 320
 321
 322 gdb_tfind_test "8.6: find frame 19"    "19" "19"
 323 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 324         "TDP $tdp6:" ""
 325 gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0"
 326
 327 gdb_test "printf \"x \%d x\\n\", depth == 3" \
 328         "x 0 x" \
 329         "1.13: trace in recursion: depth not equal to 3"
 330
 331 # Finished!
 332 gdb_test "tfind none" ".*" ""