gdb/testsuite/gdb.trace/unavailable.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 load_lib "trace-support.exp"
  17
  18 standard_testfile unavailable.cc
  19 set executable $testfile
  20
  21 if {[prepare_for_testing $testfile.exp $testfile $srcfile \
  22          {debug nowarnings c++}]} {
  23     return -1
  24 }
  25
  26 set ws "\[\r\n\t \]+"
  27 set cr "\[\r\n\]+"
  28
  29 if [is_amd64_regs_target] {
  30     set fpreg "rbp"
  31     set spreg "rsp"
  32     set pcreg "rip"
  33 } elseif [is_x86_like_target] {
  34     set fpreg "ebp"
  35     set spreg "esp"
  36     set pcreg "eip"
  37 } elseif [is_aarch64_target] {
  38     set fpreg "x29"
  39     set spreg "sp"
  40     set pcreg "pc"
  41 } else {
  42     set fpreg "fp"
  43     set spreg "sp"
  44     set pcreg "pc"
  45 }
  46
  47 #
  48 # Utility procs
  49 #
  50
  51 proc test_register { reg } {
  52     global gdb_prompt
  53     global hex
  54     global cr
  55
  56     gdb_test_multiple "print /x $reg" "collected $reg" {
  57         -re "\\$\[0-9\]+ = \[x0\]+$cr$gdb_prompt $" {
  58             fail "collected $reg (zero)"
  59         }
  60         -re "\\$\[0-9\]+ = $hex$cr$gdb_prompt $" {
  61             pass "collected $reg"
  62         }
  63         -re "\[Ee\]rror.*$gdb_prompt $" {
  64             fail "collected $reg (error)"
  65         }
  66     }
  67 }
  68
  69 proc test_register_unavailable { reg } {
  70     gdb_test "print /x $reg" \
  71         "<unavailable>" \
  72         "correctly report $reg as unavailable"
  73 }
  74
  75 proc prepare_for_trace_test {} {
  76     global executable
  77
  78     clean_restart $executable
  79
  80     runto_main
  81
  82     gdb_test "break begin" ".*" ""
  83     gdb_test "break end" ".*" ""
  84 }
  85
  86 proc run_trace_experiment { test_func } {
  87     global gdb_prompt
  88
  89     gdb_test "continue" \
  90         ".*Breakpoint \[0-9\]+, begin .*" \
  91         "advance to begin"
  92
  93     gdb_test_no_output "tstart" "start trace experiment"
  94
  95     gdb_test "continue" \
  96             "Continuing.*Breakpoint \[0-9\]+, end.*" \
  97             "run trace experiment"
  98     gdb_test "tstop" \
  99             "\[\r\n\]+" \
 100             "stop trace experiment"
 101     gdb_test "tfind start" \
 102             "#0  $test_func .*" \
 103             "tfind test frame"
 104 }
 105
 106 # Test that "display VAR" works as expected, assuming VAR is wholly
 107 # unavailable.
 108
 109 proc test_maybe_regvar_display { var } {
 110     global gdb_prompt
 111
 112     # Evaluating VAR's location description may throw an internal
 113     # "unavailable" exception, if for example, the value of a register
 114     # necessary for computing VAR's location is unavailable.  Such an
 115     # exception is caught, and should not cause automatic disablement
 116     # of the current display being printed.  (GDB used to disable the
 117     # current display whenever any exception was thrown.)
 118     set test "display $var"
 119     gdb_test_multiple "$test" "$test" {
 120         -re "Disabling display ? to avoid infinite recursion.*$gdb_prompt $" {
 121             fail "$test"
 122         }
 123         -re "display ${var}\r\n1: ${var} = <unavailable>\r\n$gdb_prompt $" {
 124             pass "$test"
 125         }
 126     }
 127     gdb_test "info display" ".*1:\[ \t\]+y\[ \t\]+${var}" "display ${var} is enabled"
 128
 129     gdb_test "undisp" \
 130         "" \
 131         "delete $var display" \
 132         ".*Delete all auto-display expressions.*y or n. $" \
 133         "y"
 134 }
 135
 136 #
 137 # Test procs
 138 #
 139
 140 proc gdb_collect_args_test_1 {} {
 141     global cr
 142
 143     # Test printing the variables, and also their addresses.  We
 144     # haven't collected any stack, so there's no way GDB can figure
 145     # out the latter.
 146
 147     gdb_test "print argc" " = <unavailable>"
 148     gdb_test "print &argc" \
 149         "Can't take address of \"argc\" which isn't an lvalue\."
 150
 151     gdb_test "print argi" " = <unavailable>"
 152     gdb_test "print &argi" \
 153         "Can't take address of \"argi\" which isn't an lvalue\."
 154
 155     gdb_test "print argf" " = <unavailable>"
 156     gdb_test "print &argf" \
 157         "Can't take address of \"argf\" which isn't an lvalue\."
 158
 159     gdb_test "print argd" " = <unavailable>"
 160     gdb_test "print &argd" \
 161         "Can't take address of \"argd\" which isn't an lvalue\."
 162
 163     # struct arg as one of several args (near end of list)
 164
 165     gdb_test "print argstruct" " = <unavailable>"
 166
 167     gdb_test "print argstruct.memberc" " = <unavailable>"
 168     gdb_test "print argstruct.memberi" " = <unavailable>"
 169     gdb_test "print argstruct.memberf" " = <unavailable>"
 170     gdb_test "print argstruct.memberd" " = <unavailable>"
 171
 172     gdb_test "print argarray" " = <unavailable>"
 173
 174     gdb_test "print &argarray" \
 175         "Can't take address of \"argarray\" which isn't an lvalue\."
 176
 177     gdb_test "print argarray\[0\]" "value is not available"
 178
 179     # Test "info args"
 180     set r ""
 181     set r "${r}argc = <unavailable>${cr}"
 182     set r "${r}argi = <unavailable>${cr}"
 183     set r "${r}argf = <unavailable>${cr}"
 184     set r "${r}argd = <unavailable>${cr}"
 185     set r "${r}argstruct = <unavailable>${cr}"
 186     set r "${r}argarray = <unavailable>${cr}"
 187     gdb_test "info args" "$r" "info args"
 188
 189     test_maybe_regvar_display "argc"
 190 }
 191
 192 proc gdb_collect_args_test {} {
 193     with_test_prefix "unavailable arguments" {
 194         global gdb_prompt
 195         global testfile srcdir subdir binfile
 196         global trace_file_targets
 197
 198         prepare_for_trace_test
 199
 200         gdb_test "trace args_test_func" \
 201             "Tracepoint \[0-9\]+ at .*" \
 202             "set tracepoint"
 203
 204         # Begin the test.
 205         run_trace_experiment args_test_func
 206
 207         gdb_collect_args_test_1
 208
 209         gdb_test "tfind none" \
 210             "#0  end .*" \
 211             "cease trace debugging"
 212
 213         set tracefile [standard_output_file ${testfile}]
 214         gdb_test "tsave ${tracefile}.args.tfile" \
 215             "Trace data saved to file '${tracefile}.args.tfile'\.\\r" \
 216             "tsave ${testfile}.args.tfile"
 217         gdb_test "tsave -ctf ${tracefile}.args.ctf" \
 218             "Trace data saved to directory '${tracefile}.args.ctf'\.\\r" \
 219             "save ctf trace file"
 220
 221         foreach target_name ${trace_file_targets} {
 222             # Restart GDB and read the trace data in ${TARGET_NAME} target.
 223             gdb_exit
 224             gdb_start
 225             gdb_reinitialize_dir $srcdir/$subdir
 226             gdb_file_cmd $binfile
 227             gdb_test "target ${target_name} ${tracefile}.args.${target_name}" ".*" \
 228                 "change to ${target_name} target"
 229
 230             with_test_prefix "${target_name}" {
 231                 gdb_test "tfind start" "#0  args_test_func .*" \
 232                     "tfind test frame"
 233                 gdb_collect_args_test_1
 234             }
 235         }
 236     }
 237 }
 238
 239 proc gdb_collect_locals_test_1 { func } {
 240     global cr
 241
 242     gdb_test "print locc" " = <unavailable>"
 243     gdb_test "print loci" " = <unavailable>"
 244     gdb_test "print locf" " = <unavailable>"
 245     gdb_test "print locd" " = <unavailable>"
 246
 247     gdb_test "print locst.memberc" " = <unavailable>"
 248     gdb_test "print locst.memberi" " = <unavailable>"
 249     gdb_test "print locst.memberf" " = <unavailable>"
 250     gdb_test "print locst.memberd" " = <unavailable>"
 251
 252     gdb_test "print locar\[0\]" " = <unavailable>"
 253     gdb_test "print locar\[1\]" " = <unavailable>"
 254     gdb_test "print locar\[2\]" " = <unavailable>"
 255     gdb_test "print locar\[3\]" " = <unavailable>"
 256
 257     # Test "info locals"
 258     set r ""
 259     set r "${r}locf = <unavailable>${cr}"
 260     set r "${r}locd = <unavailable>${cr}"
 261     set r "${r}locst = <unavailable>${cr}"
 262     set r "${r}locar = <unavailable>${cr}"
 263     set r "${r}i = <unavailable>${cr}"
 264     if { $func == "local_test_func" } {
 265         set r "${r}locdefst = <unavailable>${cr}"
 266     }
 267     set r "${r}locc = <unavailable>${cr}"
 268     set r "${r}loci = <unavailable>${cr}"
 269     gdb_test "info locals" "$r" "info locals"
 270
 271     test_maybe_regvar_display "loci"
 272 }
 273
 274 proc gdb_collect_locals_test { func msg } {
 275     with_test_prefix "unavailable locals: $msg" {
 276         global gdb_prompt
 277         global testfile srcdir subdir binfile
 278         global trace_file_targets
 279
 280         prepare_for_trace_test
 281
 282         set testline [gdb_get_line_number "set $func tracepoint here"]
 283
 284         gdb_test "trace $testline" \
 285             "Tracepoint \[0-9\]+ at .*" \
 286             "set tracepoint"
 287
 288         # Begin the test.
 289         run_trace_experiment $func
 290
 291         gdb_collect_locals_test_1 $func
 292
 293         gdb_test "tfind none" \
 294             "#0  end .*" \
 295             "cease trace debugging"
 296
 297         set tracefile [standard_output_file ${testfile}]
 298         gdb_test "tsave ${tracefile}.locals.tfile" \
 299             "Trace data saved to file '${tracefile}.locals.tfile'\.\\r" \
 300             "tsave ${testfile}.locals.tfile"
 301         gdb_test "tsave -ctf ${tracefile}.locals.ctf" \
 302             "Trace data saved to directory '${tracefile}.locals.ctf'\.\\r" \
 303             "save ctf trace file"
 304
 305         foreach target_name ${trace_file_targets} {
 306             # Restart GDB and read the trace data in ${TARGET_NAME} target.
 307             gdb_exit
 308             gdb_start
 309             gdb_reinitialize_dir $srcdir/$subdir
 310             gdb_file_cmd $binfile
 311             gdb_test "target ${target_name} ${tracefile}.locals.${target_name}" ".*" \
 312                 "change to ${target_name} target"
 313
 314             with_test_prefix "${target_name}" {
 315                 gdb_test "tfind start" "#0  $func .*" \
 316                     "tfind test frame"
 317                 gdb_collect_locals_test_1 $func
 318             }
 319         }
 320     }
 321 }
 322
 323 proc gdb_unavailable_registers_test_1 { } {
 324     global spreg
 325     global pcreg
 326
 327     # On some archs, the $sp/$pc are a real raw registers.  On others,
 328     # like x86, they're user registers.  Test both variants.
 329     test_register_unavailable "\$$spreg"
 330     test_register_unavailable "\$sp"
 331
 332     # Test reading uncollected pseudo-registers.  The set of which
 333     # depends on target.
 334     if [is_amd64_regs_target] {
 335         # Check the raw register first.
 336         test_register_unavailable "\$rax"
 337         test_register_unavailable "\$eax"
 338         test_register_unavailable "\$ax"
 339     } elseif [is_x86_like_target] {
 340         # Check the raw register first.
 341         test_register_unavailable "\$eax"
 342         test_register_unavailable "\$ax"
 343     }
 344
 345     # GDBserver always provides the PC value of regular tracepoint
 346     # hits, since it's the same as the tracepoint's address.
 347     test_register "\$$pcreg"
 348     test_register "\$pc"
 349
 350     gdb_test "info registers" \
 351         "<unavailable>.*<unavailable>" \
 352         "info registers, multiple registers not available"
 353
 354     gdb_test "info registers \$$spreg" \
 355         "<unavailable>" \
 356         "info registers \$$spreg reports not available"
 357 }
 358
 359 proc gdb_unavailable_registers_test { } {
 360     with_test_prefix "unavailable registers" {
 361         global testfile srcdir subdir binfile
 362         global trace_file_targets
 363
 364         prepare_for_trace_test
 365
 366         # We'll simply re-use the globals_test_function for this test
 367         gdb_test "trace globals_test_func" \
 368             "Tracepoint \[0-9\]+ at .*" \
 369             "set tracepoint"
 370
 371         # Collect nothing.
 372
 373         # Begin the test.
 374         run_trace_experiment globals_test_func
 375
 376         gdb_unavailable_registers_test_1
 377
 378         gdb_test "tfind none" "#0  end .*" "cease trace debugging"
 379
 380         set tracefile [standard_output_file ${testfile}]
 381         gdb_test "tsave ${tracefile}.registers.tfile" \
 382             "Trace data saved to file '${tracefile}.registers.tfile'\.\\r" \
 383             "tsave ${testfile}.registers.tfile"
 384         gdb_test "tsave -ctf ${tracefile}.registers.ctf" \
 385             "Trace data saved to directory '${tracefile}.registers.ctf'\.\\r" \
 386             "save ctf trace file"
 387
 388         foreach target_name ${trace_file_targets} {
 389             # Restart GDB and read the trace data in ${TARGET_NAME} target.
 390             gdb_exit
 391             gdb_start
 392             gdb_reinitialize_dir $srcdir/$subdir
 393             gdb_file_cmd $binfile
 394             gdb_test "target ${target_name} ${tracefile}.registers.${target_name}" ".*" \
 395                 "change to ${target_name} target"
 396
 397             with_test_prefix "${target_name}" {
 398                 gdb_test "tfind start" "#0  globals_test_func .*" \
 399                     "tfind test frame"
 400                 gdb_unavailable_registers_test_1
 401             }
 402         }
 403     }
 404 }
 405
 406 proc gdb_unavailable_floats_1 { } {
 407     global gdb_prompt
 408
 409     # Necessarily target specific.
 410     if {[istarget "x86_64-*-*"] || [istarget i?86-*]} {
 411         send_gdb "info float\n"
 412         gdb_expect_list "info float" ".*$gdb_prompt $" {
 413             "Status Word:         <unavailable>"
 414             "Control Word:        <unavailable>"
 415             "Tag Word:            <unavailable>"
 416             "Instruction Pointer: <unavailable>:<unavailable>"
 417             "Operand Pointer:     <unavailable>:<unavailable>"
 418             "Opcode:              <unavailable>"
 419         }
 420     }
 421 }
 422
 423 proc gdb_unavailable_floats { } {
 424     with_test_prefix "unavailable floats" {
 425         global testfile srcdir subdir binfile
 426         global trace_file_targets
 427
 428         prepare_for_trace_test
 429
 430         # We'll simply re-use the globals_test_function for this test
 431         gdb_test "trace globals_test_func" \
 432             "Tracepoint \[0-9\]+ at .*" \
 433             "set tracepoint"
 434
 435         # Collect nothing.
 436
 437         # Begin the test.
 438         run_trace_experiment globals_test_func
 439
 440         gdb_unavailable_floats_1
 441
 442         gdb_test "tfind none" "#0  end .*" "cease trace debugging"
 443
 444         set tracefile [standard_output_file ${testfile}]
 445         gdb_test "tsave ${tracefile}.floats.tfile" \
 446             "Trace data saved to file '${tracefile}.floats.tfile'\.\\r" \
 447             "tsave ${testfile}.floats.tfile"
 448         gdb_test "tsave -ctf ${tracefile}.floats.ctf" \
 449             "Trace data saved to directory '${tracefile}.floats.ctf'\.\\r" \
 450             "save ctf trace file"
 451
 452         foreach target_name ${trace_file_targets} {
 453             # Restart GDB and read the trace data in ${TARGET_NAME} target.
 454             gdb_exit
 455             gdb_start
 456             gdb_reinitialize_dir $srcdir/$subdir
 457             gdb_file_cmd $binfile
 458             gdb_test "target ${target_name} ${tracefile}.floats.${target_name}" ".*" \
 459                 "change to ${target_name} target"
 460
 461             with_test_prefix "${target_name}" {
 462                 gdb_test "tfind start" "#0  globals_test_func .*" \
 463                     "tfind test frame"
 464                 gdb_unavailable_floats_1
 465             }
 466         }
 467     }
 468 }
 469
 470 proc gdb_collect_globals_test_1 { } {
 471     global ws
 472     global cr
 473     global gdb_prompt
 474     global hex
 475
 476     gdb_test "print globalc" " = <unavailable>"
 477     gdb_test "print globali" " = <unavailable>"
 478     gdb_test "print globalf" " = <unavailable>"
 479     gdb_test "print globald" " = <unavailable>"
 480
 481     gdb_test "print globalstruct.memberc" " = <unavailable>"
 482     gdb_test "print globalstruct.memberi" " = <unavailable>"
 483     gdb_test "print globalstruct.memberf" " = <unavailable>"
 484     gdb_test "print globalstruct.memberd" " = <unavailable>"
 485
 486     gdb_test "print globalstruct" " = <unavailable>"
 487
 488     gdb_test "print globalp == &globalstruct" \
 489         "value is not available" \
 490         "can't compare using non collected global pointer"
 491
 492     gdb_test "print globalarr\[1\]" " = <unavailable>"
 493     gdb_test "print globalarr\[2\]" " = <unavailable>"
 494     gdb_test "print globalarr\[3\]" " = <unavailable>"
 495
 496     gdb_test "print struct_b" \
 497         " = {d = <unavailable>, ef = <unavailable>, struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, -1431655766, <unavailable> <repeats 97 times>, -1431655766, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}, s = <unavailable>, static static_struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable> <repeats 10000 times>}, ptr = <unavailable>, bitfield = <unavailable>}, string = <unavailable>}"
 498
 499     gdb_test "print /x struct_b" \
 500         " = {d = <unavailable>, ef = <unavailable>, struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}, s = <unavailable>, static static_struct_a = {a = <unavailable>, b = <unavailable>, array = {<unavailable> <repeats 10000 times>}, ptr = <unavailable>, bitfield = <unavailable>}, string = <unavailable>}"
 501
 502     gdb_test "print /x struct_b.struct_a" \
 503         " = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}"
 504
 505     gdb_test "print /x struct_b.struct_a.array" \
 506         " = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}"
 507
 508     gdb_test "print /x struct_b.struct_a.array\[0\]" " = <unavailable>"
 509
 510     gdb_test "print /x struct_b.struct_a.array\[2\]" " = 0xaaaaaaaa"
 511
 512     # Check the target doesn't overcollect.  GDB used to merge memory
 513     # ranges to collect if they were close enough (collecting the hole
 514     # as well), but does not do that anymore.  It's plausible that a
 515     # target may do this on its end, but as of this writing, no known
 516     # target does it.
 517     gdb_test "print {a, b, c}" \
 518         " = \\{1, <unavailable>, 3\\}" \
 519         "No overcollect of almost but not quite adjacent memory ranges"
 520
 521     # Check <unavailable> isn't confused with 0 in array element repetitions
 522
 523     gdb_test_no_output "set print repeat 1"
 524
 525     gdb_test "print /x tarray" \
 526         " = \{\{a = 0x0, b = <unavailable>\} <repeats 2 times>, \{a = <unavailable>, b = <unavailable>\}, \{a = 0x0, b = 0x0\}, \{a = <unavailable>, b = 0x0\} <repeats 2 times>, \{a = <unavailable>, b = <unavailable>\} <repeats 2 times>\}" \
 527         "<unavailable> is not the same as 0 in array element repetitions"
 528
 529     gdb_test_no_output "set print repeat 10"
 530
 531     # Check that value repeat handles unavailable-ness.
 532     gdb_test "print *tarray@3" " = \\{\\{a = 0, b = <unavailable>\\}, \\{a = 0, b = <unavailable>\\}, \\{a = <unavailable>, b = <unavailable>\\}\\}"
 533
 534     # Static fields
 535
 536     gdb_test "print struct_b.static_struct_a" " = <unavailable>"
 537
 538     # Bitfields
 539
 540     gdb_test "print struct_b.struct_a.bitfield" " = <unavailable>"
 541
 542     # References
 543
 544     gdb_test "print g_int" " = <unavailable>"
 545
 546     gdb_test "print g_ref" \
 547         "\\(int &\\) @$hex: <unavailable>" \
 548         "global reference shows address but not value"
 549
 550     gdb_test "print *&g_ref" \
 551         "\\$\[0-9\]+ = <unavailable>$cr" \
 552         "referenced integer was not collected (taking address of reference)"
 553
 554     gdb_test "print *g_structref_p" " = <unavailable>"
 555
 556     # Strings
 557
 558     # Const string is always available, even when not collected.
 559     gdb_test "print g_const_string" \
 560         " = \"hello world\"$cr" \
 561         "non collected const string is still printable"
 562
 563     gdb_test "print g_string_p" \
 564         " = $hex <g_const_string> \"hello world\"" \
 565         "printing constant string through collected pointer"
 566
 567     gdb_test "print g_string_unavail" \
 568         " = <unavailable>" \
 569         "printing non collected string"
 570
 571     # Incomplete strings print as an array.
 572     gdb_test "print g_string_partial" \
 573         "\\$\[0-9\]+ = \{<unavailable>, 101 'e', 108 'l', <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>\}" \
 574         "printing partially collected string"
 575
 576     # It is important for this test that the last examined value is
 577     # <unavailable>, to exercise the case of the $__ convenience
 578     # variable being set to <unavailable> without error.
 579     set msg "examining partially collected object"
 580     gdb_test_multiple "x /10x &struct_b" "$msg" {
 581         -re "$hex <struct_b>:${ws}<unavailable>${ws}<unavailable>${ws}<unavailable>${ws}<unavailable>$cr$hex <struct_b\\+16>:${ws}<unavailable>${ws}<unavailable>${ws}0xaaaaaaaa${ws}<unavailable>$cr$hex <struct_b\\+32>:${ws}<unavailable>${ws}<unavailable>$cr$gdb_prompt $" {
 582             pass "$msg"
 583         }
 584         -re "value is not available" {
 585             fail "$msg"
 586         }
 587     }
 588
 589     gdb_test "p \$__" " = <unavailable>" "last examined value was <unavailable>"
 590
 591     # This tests that building the array does not require accessing
 592     # g_int's contents.
 593     gdb_test "print { 1, g_int, 3 }" \
 594         " = \\{1, <unavailable>, 3\\}" \
 595         "build array from unavailable value"
 596
 597     # Note, depends on previous test.
 598     gdb_test "print \$\[1\]" \
 599         " = <unavailable>" \
 600         "subscript a non-memory rvalue array, accessing an unvailable element"
 601
 602     # Access a field of a non-lazy value, making sure the
 603     # unavailable-ness is propagated.  History values are easy
 604     # non-lazy values, so use those.  The first test just sets up for
 605     # the second.
 606     gdb_test "print g_smallstruct" " = <unavailable>"
 607     gdb_test "print \$.member" " = <unavailable>"
 608
 609     # Cast to baseclass, checking the unavailable-ness is propagated.
 610     gdb_test "print (small_struct) g_smallstruct_b" " = <unavailable>"
 611
 612     # Same cast, but starting from a non-lazy, value.
 613     gdb_test "print g_smallstruct_b" " = <unavailable>"
 614     gdb_test "print (small_struct) \$" " = <unavailable>"
 615
 616     gdb_test_no_output "set print object on"
 617
 618     with_test_prefix "print object on" {
 619         # With print object on, printing a pointer may need to fetch
 620         # the pointed-to object, to check its run-time type.  Make
 621         # sure that fails gracefully and transparently when the
 622         # pointer itself is unavailable.
 623         gdb_test "print virtualp" " = <unavailable>"
 624
 625         # no vtable pointer available
 626         gdb_test "print derived_unavail" " = <unavailable>"
 627
 628         # vtable pointer available, but nothing else
 629         gdb_test "print derived_partial" \
 630             " = \\(Derived\\) {<Middle> = {<Base> = <unavailable>, _vptr.Middle = <unavailable>, y = <unavailable>}, _vptr.Derived = $hex <vtable for Derived.*>, z = <unavailable>}"
 631
 632         # whole object available
 633         gdb_test "print derived_whole" \
 634             " = \\(Derived\\) {<Middle> = {<Base> = {x = 2}, _vptr.Middle = $hex, y = 3}, _vptr.Derived = $hex <vtable for Derived.*>, z = 4}"
 635     }
 636
 637     gdb_test_no_output "set print object off"
 638
 639     with_test_prefix "print object off" {
 640         gdb_test "print virtualp" " = <unavailable>"
 641
 642         # no vtable pointer available
 643         gdb_test "print derived_unavail" \
 644             " = <unavailable>"
 645
 646         # vtable pointer available, but nothing else
 647         gdb_test "print derived_partial" \
 648             " = {<Middle> = {<Base> = <unavailable>, _vptr.Middle = <unavailable>, y = <unavailable>}, _vptr.Derived = $hex <vtable for Derived.*>, z = <unavailable>}"
 649
 650         # whole object available
 651         gdb_test "print derived_whole" \
 652             " = {<Middle> = {<Base> = {x = 2}, _vptr.Middle = $hex, y = 3}, _vptr.Derived = $hex <vtable for Derived.*>, z = 4}"
 653     }
 654
 655     # An instance of a virtual class where we collected everything but
 656     # the vptr.
 657     gdb_test "print virtual_partial" \
 658         " = {_vptr.Virtual = <unavailable>, z = 0}"
 659 }
 660
 661 proc gdb_collect_globals_test { } {
 662     with_test_prefix "collect globals" {
 663         global testfile binfile srcdir subdir
 664         global trace_file_targets
 665
 666         prepare_for_trace_test
 667
 668         set testline [gdb_get_line_number "set globals_test_func tracepoint here"]
 669
 670         gdb_test "trace $testline" \
 671             "Tracepoint \[0-9\]+ at .*" \
 672             "set tracepoint"
 673
 674         # We collect the initial sizeof(pointer) bytes of derived_partial
 675         # in an attempt of collecting the vptr.  Not portable, but should
 676         # work everywhere we need to care.
 677         gdb_trace_setactions "define actions" \
 678             "" \
 679             "collect struct_b.struct_a.array\[2\]" "^$" \
 680             "collect struct_b.struct_a.array\[100\]" "^$" \
 681             \
 682             "collect a" "^$" \
 683             "collect c" "^$" \
 684             \
 685             "collect tarray\[0\].a" "^$" \
 686             "collect tarray\[1\].a" "^$" \
 687             "collect tarray\[3\].a" "^$" \
 688             "collect tarray\[3\].b" "^$" \
 689             "collect tarray\[4\].b" "^$" \
 690             "collect tarray\[5\].b" "^$" \
 691             \
 692             "collect g_string_p" "^$" \
 693             "collect g_string_partial\[1\]" "^$" \
 694             "collect g_string_partial\[2\]" "^$" \
 695             \
 696             "collect g_structref_p" "^$" \
 697             \
 698             "collect *((char *)&derived_partial)@sizeof\(void *\)" "^$" \
 699             "collect derived_whole" "^$" \
 700             \
 701             "collect virtual_partial.z" "^$"
 702
 703         # Begin the test.
 704         run_trace_experiment globals_test_func
 705
 706         gdb_collect_globals_test_1
 707
 708         gdb_test "tfind none" \
 709             "#0  end .*" \
 710             "cease trace debugging"
 711
 712         set tracefile [standard_output_file ${testfile}]
 713         gdb_test "tsave ${tracefile}.globals.tfile" \
 714             "Trace data saved to file '${tracefile}.globals.tfile'\.\\r" \
 715             "tsave ${testfile}.globals.tfile"
 716         gdb_test "tsave -ctf ${tracefile}.globals.ctf" \
 717             "Trace data saved to directory '${tracefile}.globals.ctf'\.\\r" \
 718             "save ctf trace file"
 719
 720         foreach target_name ${trace_file_targets} {
 721             # Restart GDB and read the trace data in ${TARGET_NAME} target.
 722             gdb_exit
 723             gdb_start
 724             gdb_reinitialize_dir $srcdir/$subdir
 725             gdb_file_cmd $binfile
 726             gdb_test "target ${target_name} ${tracefile}.globals.${target_name}" ".*" \
 727                 "change to ${target_name} target"
 728
 729             with_test_prefix "${target_name}" {
 730                 gdb_test "tfind start" "#0  globals_test_func .*" \
 731                     "tfind test frame"
 732                 gdb_collect_globals_test_1
 733             }
 734         }
 735
 736     }
 737 }
 738
 739 proc gdb_trace_collection_test {} {
 740     gdb_collect_globals_test
 741     gdb_unavailable_registers_test
 742     gdb_unavailable_floats
 743
 744     gdb_collect_args_test
 745     gdb_collect_locals_test local_test_func "auto locals"
 746     gdb_collect_locals_test reglocal_test_func "register locals"
 747     gdb_collect_locals_test statlocal_test_func "static locals"
 748 }
 749
 750 runto_main
 751
 752 if { ![gdb_target_supports_trace] } then {
 753     unsupported "Current target does not support trace"
 754     return 1
 755 }
 756
 757 set trace_file_targets [list "tfile"]
 758 gdb_test_multiple "target ctf" "" {
 759     -re "Undefined target command: \"ctf\"\.  Try \"help target\"\.\r\n$gdb_prompt $" {
 760     }
 761     -re "No CTF directory specified.*\r\n$gdb_prompt $" {
 762         lappend trace_file_targets "ctf"
 763     }
 764 }
 765
 766 # Body of test encased in a proc so we can return prematurely.
 767 gdb_trace_collection_test
 768
 769 # Finished!
 770 gdb_test "tfind none" ".*" ""