gdb/testsuite/gdb.trace/backtrace.exp

   1 #   Copyright 1998-2015 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 standard_testfile actions.c
  21 set executable $testfile
  22 set expfile $testfile.exp
  23
  24 if [prepare_for_testing $expfile $executable $srcfile \
  25         [list debug nowarnings]] {
  26     untested "failed to prepare for trace tests"
  27     return -1
  28 }
  29
  30 if ![runto_main] {
  31     fail "Can't run to main to check for trace support"
  32     return -1
  33 }
  34
  35 if { ![gdb_target_supports_trace] } then {
  36     unsupported "Current target does not support trace"
  37     return 1
  38
  39 }
  40
  41 #
  42 # test backtraces in trace frames
  43 #
  44
  45 set testline1 0
  46 set testline2 0
  47 set testline3 0
  48 set testline4 0
  49 set testline5 0
  50 set testline6 0
  51
  52 set arg1 1
  53 set arg2 2
  54 set arg3 3
  55 set arg4 4
  56 set arg5 5
  57 set arg6 6
  58
  59 set baseline [gdb_find_recursion_test_baseline $srcfile]
  60 if { $baseline == -1 } {
  61     fail "Could not find gdb_recursion_test function"
  62     return
  63 }
  64
  65 set return_me 0
  66
  67 gdb_test_multiple "list $baseline, +12" "all tests in this module will fail" {
  68     -re "\[\r\n\](\[0-9\]+).*gdbtestline 1 " {
  69         set testline1 $expect_out(1,string)
  70         exp_continue
  71     }
  72     -re "\[\r\n\](\[0-9\]+).*gdbtestline 2 " {
  73         set testline2 $expect_out(1,string)
  74         exp_continue
  75     }
  76     -re "\[\r\n\](\[0-9\]+).*gdbtestline 3 " {
  77         set testline3 $expect_out(1,string)
  78         exp_continue
  79     }
  80     -re "\[\r\n\](\[0-9\]+).*gdbtestline 4 " {
  81         set testline4 $expect_out(1,string)
  82         exp_continue
  83     }
  84     -re "\[\r\n\](\[0-9\]+).*gdbtestline 5 " {
  85         set testline5 $expect_out(1,string)
  86         exp_continue
  87     }
  88     -re "\[\r\n\](\[0-9\]+).*gdbtestline 6 " {
  89         set testline6 $expect_out(1,string)
  90         exp_continue
  91     }
  92     -re ".*$gdb_prompt $" {
  93         if { ($testline1 == 0) || ($testline2 == 0) || ($testline3 == 0) || ($testline4 == 0) || ($testline5 == 0) || ($testline6 == 0) } {
  94             untested backtrace.exp
  95             set return_me 1
  96 all tests in this module will fail."
  97         }
  98     }
  99     default {
 100             untested backtrace.exp
 101             set return_me 1
 102 all tests in this module will fail."
 103     }
 104 }
 105
 106 if { $return_me == 1 } then {
 107     return -1
 108 }
 109
 110 #
 111 # Setup backtrace experiment.  This will involve:
 112 #   1) a tracepoint where nothing is collected
 113 #   2) a tracepoint where only regs are collected
 114 #   3) a tracepoint where regs, locals and args are collected
 115 #   4) a tracepoint where regs plus some amount of stack are collected.
 116 #
 117
 118 gdb_delete_tracepoints
 119 set tdp2 [gdb_gettpnum $testline2]
 120 set tdp3 [gdb_gettpnum $testline3]
 121 set tdp4 [gdb_gettpnum $testline4]
 122 set tdp5 [gdb_gettpnum $testline5]
 123 set tdp6 [gdb_gettpnum $testline6]
 124 if {    $tdp2 <= 0 || $tdp3 <= 0 || \
 125         $tdp4 <= 0 || $tdp5 <= 0 || $tdp6 <= 0 } then {
 126     fail "setting tracepoints failed"
 127     return
 128 }
 129
 130 #gdb_trace_setactions "setup TP to collect FP" \
 131 #       "$tdp2" \
 132 #       "collect \$fp" ""
 133 #
 134
 135 gdb_trace_setactions "8.6: setup TP to collect regs" \
 136         "$tdp3" \
 137         "collect \$regs" "^$"
 138
 139 gdb_trace_setactions "8.6: setup TP to collect regs, args, and locals" \
 140         "$tdp4" \
 141         "collect \$regs, \$args, \$locs" "^$"
 142
 143 if [is_amd64_regs_target] {
 144     set fpreg "\$rbp"
 145     set spreg "\$rsp"
 146 } elseif [is_x86_like_target] {
 147     set fpreg "\$ebp"
 148     set spreg "\$esp"
 149 } else {
 150     set fpreg "\$fp"
 151     set spreg "\$sp"
 152 }
 153
 154 gdb_trace_setactions "8.6: setup TP to collect stack mem cast expr" \
 155        "$tdp6" \
 156        "collect $fpreg, \(\*\(void \*\*\) \($spreg\)\) @ 64" "^$"
 157
 158 gdb_test_no_output "tstart" ""
 159
 160 gdb_test "break end" ".*" ""
 161 gdb_test "continue" \
 162     "Continuing.*Breakpoint $decimal, end.*" \
 163     "run trace experiment"
 164
 165 gdb_test_no_output "tstop" ""
 166
 167 proc gdb_backtrace_tdp_1 { msg } {
 168     global gdb_prompt
 169
 170     # We are in a trace frame at which we didn't collect anything
 171     # except $PC.  Therefore we expect to be able to identify stack
 172     # frame #0, but that's about all.  In particular we do not expect
 173     # to be able to display the function's arguments or locals, and we
 174     # do not expect to be able to identify the caller of this function.
 175
 176     gdb_test "backtrace" \
 177         "#0\[\t \]+gdb_recursion_test.*depth=.*" \
 178         "$msg"
 179 }
 180
 181 proc gdb_backtrace_tdp_2 { msg } {
 182     global gdb_prompt
 183
 184     # We are in a trace frame at which we collected only the registers
 185     # Therefore we expect to be able to identify stack frame #0, but
 186     # we don't expect to be able to display its args unles they are
 187     # passed in registers (which isn't the case for m68k), and we
 188     # don't expect to be able to identify the caller's stack frame.
 189
 190     gdb_test "backtrace" \
 191         "#0\[\t \]+gdb_recursion_test.*depth=.*" \
 192         "$msg"
 193 }
 194
 195 proc gdb_backtrace_tdp_3 { msg } {
 196     global gdb_prompt
 197
 198     # We are in a trace frame at which we collected all registers, all
 199     # arguments and all locals.  This means that the display of
 200     # stack frame #0 should be complete (including argument values).
 201
 202     gdb_test_multiple "backtrace" "$msg" {
 203         -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 $" {
 204             pass "$msg"
 205         }
 206         -re "#0\[\t \]+gdb_recursion_test.*depth=Cannot access.*$gdb_prompt $" {
 207             fail "$msg (failed to collect arguments)"
 208         }
 209     }
 210 }
 211
 212 proc gdb_backtrace_tdp_4 { msg depth traceframe } {
 213     global gdb_prompt
 214
 215     with_test_prefix "traceframe $traceframe" {
 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         set output_string0 ""
 235         # Match the output of command 'tdump' and save it in
 236         # $output_string0.
 237         set test "tdump on frame 0"
 238         gdb_test_multiple "tdump" $test {
 239             -re "tdump\[\r\n\]+(.*)\[\r\n\]+$gdb_prompt $" {
 240                 set output_string0 $expect_out(1,string)
 241             }
 242         }
 243
 244         gdb_test "up" ".*" ""
 245
 246         # Test that command 'tdump' still works properly when the
 247         # selected frame is not the current frame, and save the output
 248         # in $output_string1.
 249         set test "tdump on frame 1"
 250         set output_string1 ""
 251         gdb_test_multiple "tdump" $test {
 252             -re "tdump\[\r\n\]+(.*)\[\r\n\]+$gdb_prompt $" {
 253                 set output_string1 $expect_out(1,string)
 254             }
 255         }
 256
 257         # Output of 'tdump' on frame 0 and frame 1 should be
 258         # identical.
 259         gdb_assert ![string compare $output_string0 $output_string1] \
 260             "tdump output"
 261     }
 262 }
 263
 264 #
 265 # begin backtrace test
 266 #
 267
 268 set timeout 60
 269
 270 gdb_tfind_test "init: make sure not debugging any trace frame" "none" "-1"
 271
 272 gdb_tfind_test "8.6: find start frame" "start" "0"
 273 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 274         "TDP $tdp2:" ""
 275 gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 1, collect nothing"
 276
 277 gdb_tfind_test "8.6: find frame 1"     "1" "1"
 278 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 279         "TDP $tdp3:" ""
 280 gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 1, collect regs"
 281
 282 gdb_tfind_test "8.6: find frame 2"     "2" "2"
 283 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 284         "TDP $tdp4:" ""
 285 gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 1, collect args and locals"
 286
 287
 288 gdb_tfind_test "8.6: find frame 4"     "4" "4"
 289 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 290         "TDP $tdp6:" ""
 291 gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0" 4
 292
 293 gdb_tfind_test "8.6: find frame 5"     "5" "5"
 294 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 295         "TDP $tdp2:" ""
 296 gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 2, collect nothing"
 297
 298 gdb_tfind_test "8.6: find frame 6"     "6" "6"
 299 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 300         "TDP $tdp3:" ""
 301 gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 2, collect regs"
 302
 303 gdb_tfind_test "8.6: find frame 7"     "7" "7"
 304 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 305         "TDP $tdp4:" ""
 306 gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 2, collect args and locals"
 307
 308
 309 gdb_tfind_test "8.6: find frame 9"     "9" "9"
 310 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 311         "TDP $tdp6:" ""
 312 gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0" 9
 313
 314 gdb_tfind_test "8.6: find frame 10"    "10" "10"
 315 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 316         "TDP $tdp2:" ""
 317 gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 3, collect nothing"
 318
 319 gdb_tfind_test "8.6: find frame 11"    "11" "11"
 320 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 321         "TDP $tdp3:" ""
 322 gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 3, collect regs"
 323
 324 gdb_tfind_test "8.6: find frame 12"    "12" "12"
 325 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 326         "TDP $tdp4:" ""
 327 gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 3, collect args and locals"
 328
 329
 330 gdb_tfind_test "8.6: find frame 14"    "14" "14"
 331 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 332         "TDP $tdp6:" ""
 333 gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0" 14
 334
 335 gdb_tfind_test "8.6: find frame 15"    "15" "15"
 336 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 337         "TDP $tdp2:" ""
 338 gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 4, collect nothing"
 339
 340 gdb_tfind_test "8.6: find frame 16"    "16" "16"
 341 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 342         "TDP $tdp3:" ""
 343 gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 4, collect regs"
 344
 345 gdb_tfind_test "8.6: find frame 17"    "17" "17"
 346 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 347         "TDP $tdp4:" ""
 348 gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 4, collect args and locals"
 349
 350
 351 gdb_tfind_test "8.6: find frame 19"    "19" "19"
 352 gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
 353         "TDP $tdp6:" ""
 354 gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0" 19
 355
 356 gdb_test "printf \"x \%d x\\n\", depth == 3" \
 357         "x 0 x" \
 358         "1.13: trace in recursion: depth not equal to 3"
 359
 360 # Finished!
 361 gdb_test "tfind none" ".*" ""