[PATCH 1/4] Move traceframe checking out of traceframe generation

[Yao Qi <yao@codesourcery.com>]

This patch moves traceframe checking code out of traceframe generation,
so that we can generation traceframe once, and do the checking in multiple
times (with target remote, tfile and ctf respectively).  This is a
pure refactor, not functional changes in unavailable.exp.

gdb/testsuite:

2014-04-26  Yao Qi  <yao@codesourcery.com>

	* gdb.trace/unavailable.exp (gdb_collect_args_test): Move some
	code to ...
	(gdb_collect_args_test_1): ... it.  New proc.
	(gdb_collect_locals_test): Move some code to ...
	(gdb_collect_locals_test_1): ... it.  New proc.
	(gdb_unavailable_registers_test): Move some code to ...
	(gdb_unavailable_registers_test_1): ... it.  New proc.
	(gdb_unavailable_floats): Move some code to ...
	(gdb_unavailable_floats_1): ... it.  New proc.
---
 gdb/testsuite/gdb.trace/unavailable.exp | 618 +++++++++++++++++---------------
 1 file changed, 320 insertions(+), 298 deletions(-)

diff --git a/gdb/testsuite/gdb.trace/unavailable.exp b/gdb/testsuite/gdb.trace/unavailable.exp
index 589cd77..d76b54d 100644
--- a/gdb/testsuite/gdb.trace/unavailable.exp
+++ b/gdb/testsuite/gdb.trace/unavailable.exp
@@ -133,67 +133,72 @@ proc test_maybe_regvar_display { var } {
 # Test procs
 #
 
-proc gdb_collect_args_test {} {
-    with_test_prefix "unavailable arguments" {
-	global cr
-	global gdb_prompt
+proc gdb_collect_args_test_1 {} {
+    global cr
 
-	prepare_for_trace_test
+    # Test printing the variables, and also their addresses.  We
+    # haven't collected any stack, so there's no way GDB can figure
+    # out the latter.
 
-	gdb_test "trace args_test_func" \
-	    "Tracepoint \[0-9\]+ at .*" \
-	    "set tracepoint"
+    gdb_test "print argc" " = <unavailable>"
+    gdb_test "print &argc" \
+	"Can't take address of \"argc\" which isn't an lvalue\."
 
-	# Begin the test.
-	run_trace_experiment args_test_func
+    gdb_test "print argi" " = <unavailable>"
+    gdb_test "print &argi" \
+	"Can't take address of \"argi\" which isn't an lvalue\."
 
-	# Test printing the variables, and also their addresses.  We
-	# haven't collected any stack, so there's no way GDB can figure
-	# out the latter.
+    gdb_test "print argf" " = <unavailable>"
+    gdb_test "print &argf" \
+	"Can't take address of \"argf\" which isn't an lvalue\."
 
-	gdb_test "print argc" " = <unavailable>"
-	gdb_test "print &argc" \
-	    "Can't take address of \"argc\" which isn't an lvalue\."
+    gdb_test "print argd" " = <unavailable>"
+    gdb_test "print &argd" \
+	"Can't take address of \"argd\" which isn't an lvalue\."
 
-	gdb_test "print argi" " = <unavailable>"
-	gdb_test "print &argi" \
-	    "Can't take address of \"argi\" which isn't an lvalue\."
+    # struct arg as one of several args (near end of list)
 
-	gdb_test "print argf" " = <unavailable>"
-	gdb_test "print &argf" \
-	    "Can't take address of \"argf\" which isn't an lvalue\."
+    gdb_test "print argstruct" " = <unavailable>"
 
-	gdb_test "print argd" " = <unavailable>"
-	gdb_test "print &argd" \
-	    "Can't take address of \"argd\" which isn't an lvalue\."
+    gdb_test "print argstruct.memberc" " = <unavailable>"
+    gdb_test "print argstruct.memberi" " = <unavailable>"
+    gdb_test "print argstruct.memberf" " = <unavailable>"
+    gdb_test "print argstruct.memberd" " = <unavailable>"
 
-	# struct arg as one of several args (near end of list)
+    gdb_test "print argarray" " = <unavailable>"
 
-	gdb_test "print argstruct" " = <unavailable>"
+    gdb_test "print &argarray" \
+	"Can't take address of \"argarray\" which isn't an lvalue\."
 
-	gdb_test "print argstruct.memberc" " = <unavailable>"
-	gdb_test "print argstruct.memberi" " = <unavailable>"
-	gdb_test "print argstruct.memberf" " = <unavailable>"
-	gdb_test "print argstruct.memberd" " = <unavailable>"
+    gdb_test "print argarray\[0\]" "value is not available"
 
-	gdb_test "print argarray" " = <unavailable>"
+    # Test "info args"
+    set r ""
+    set r "${r}argc = <unavailable>${cr}"
+    set r "${r}argi = <unavailable>${cr}"
+    set r "${r}argf = <unavailable>${cr}"
+    set r "${r}argd = <unavailable>${cr}"
+    set r "${r}argstruct = <unavailable>${cr}"
+    set r "${r}argarray = <unavailable>${cr}"
+    gdb_test "info args" "$r" "info args"
 
-	gdb_test "print &argarray" \
-	    "Can't take address of \"argarray\" which isn't an lvalue\."
+    test_maybe_regvar_display "argc"
+}
 
-	gdb_test "print argarray\[0\]" "value is not available"
+proc gdb_collect_args_test {} {
+    with_test_prefix "unavailable arguments" {
+	global gdb_prompt
 
-	# Test "info args"
-	set r ""
-	set r "${r}argc = <unavailable>${cr}"
-	set r "${r}argi = <unavailable>${cr}"
-	set r "${r}argf = <unavailable>${cr}"
-	set r "${r}argd = <unavailable>${cr}"
-	set r "${r}argstruct = <unavailable>${cr}"
-	set r "${r}argarray = <unavailable>${cr}"
-	gdb_test "info args" "$r" "info args"
+	prepare_for_trace_test
 
-	test_maybe_regvar_display "argc"
+	gdb_test "trace args_test_func" \
+	    "Tracepoint \[0-9\]+ at .*" \
+	    "set tracepoint"
+
+	# Begin the test.
+	run_trace_experiment args_test_func
+
+	gdb_collect_args_test_1
 
 	gdb_test "tfind none" \
 	    "#0  end .*" \
@@ -201,9 +206,43 @@ proc gdb_collect_args_test {} {
     }
 }
 
+proc gdb_collect_locals_test_1 { func } {
+    global cr
+
+    gdb_test "print locc" " = <unavailable>"
+    gdb_test "print loci" " = <unavailable>"
+    gdb_test "print locf" " = <unavailable>"
+    gdb_test "print locd" " = <unavailable>"
+
+    gdb_test "print locst.memberc" " = <unavailable>"
+    gdb_test "print locst.memberi" " = <unavailable>"
+    gdb_test "print locst.memberf" " = <unavailable>"
+    gdb_test "print locst.memberd" " = <unavailable>"
+
+    gdb_test "print locar\[0\]" " = <unavailable>"
+    gdb_test "print locar\[1\]" " = <unavailable>"
+    gdb_test "print locar\[2\]" " = <unavailable>"
+    gdb_test "print locar\[3\]" " = <unavailable>"
+
+    # Test "info locals"
+    set r ""
+    set r "${r}locf = <unavailable>${cr}"
+    set r "${r}locd = <unavailable>${cr}"
+    set r "${r}locst = <unavailable>${cr}"
+    set r "${r}locar = <unavailable>${cr}"
+    set r "${r}i = <unavailable>${cr}"
+    if { $func == "local_test_func" } {
+	set r "${r}locdefst = <unavailable>${cr}"
+    }
+    set r "${r}locc = <unavailable>${cr}"
+    set r "${r}loci = <unavailable>${cr}"
+    gdb_test "info locals" "$r" "info locals"
+
+    test_maybe_regvar_display "loci"
+}
+
 proc gdb_collect_locals_test { func msg } {
     with_test_prefix "unavailable locals: $msg" {
-	global cr
 	global gdb_prompt
 
 	prepare_for_trace_test
@@ -217,36 +256,7 @@ proc gdb_collect_locals_test { func msg } {
 	# Begin the test.
 	run_trace_experiment $func
 
-	gdb_test "print locc" " = <unavailable>"
-	gdb_test "print loci" " = <unavailable>"
-	gdb_test "print locf" " = <unavailable>"
-	gdb_test "print locd" " = <unavailable>"
-
-	gdb_test "print locst.memberc" " = <unavailable>"
-	gdb_test "print locst.memberi" " = <unavailable>"
-	gdb_test "print locst.memberf" " = <unavailable>"
-	gdb_test "print locst.memberd" " = <unavailable>"
-
-	gdb_test "print locar\[0\]" " = <unavailable>"
-	gdb_test "print locar\[1\]" " = <unavailable>"
-	gdb_test "print locar\[2\]" " = <unavailable>"
-	gdb_test "print locar\[3\]" " = <unavailable>"
-
-	# Test "info locals"
-	set r ""
-	set r "${r}locf = <unavailable>${cr}"
-	set r "${r}locd = <unavailable>${cr}"
-	set r "${r}locst = <unavailable>${cr}"
-	set r "${r}locar = <unavailable>${cr}"
-	set r "${r}i = <unavailable>${cr}"
-	if { $func == "local_test_func" } {
-	    set r "${r}locdefst = <unavailable>${cr}"
-	}
-	set r "${r}locc = <unavailable>${cr}"
-	set r "${r}loci = <unavailable>${cr}"
-	gdb_test "info locals" "$r" "info locals"
-
-	test_maybe_regvar_display "loci"
+	gdb_collect_locals_test_1 $func
 
 	gdb_test "tfind none" \
 	    "#0  end .*" \
@@ -254,11 +264,44 @@ proc gdb_collect_locals_test { func msg } {
     }
 }
 
+proc gdb_unavailable_registers_test_1 { } {
+    global spreg
+    global pcreg
+
+    # On some archs, the $sp/$pc are a real raw registers.  On others,
+    # like x86, they're user registers.  Test both variants.
+    test_register_unavailable "\$$spreg"
+    test_register_unavailable "\$sp"
+
+    # Test reading uncollected pseudo-registers.  The set of which
+    # depends on target.
+    if [is_amd64_regs_target] {
+	# Check the raw register first.
+	test_register_unavailable "\$rax"
+	test_register_unavailable "\$eax"
+	test_register_unavailable "\$ax"
+    } elseif [is_x86_like_target] {
+	# Check the raw register first.
+	test_register_unavailable "\$eax"
+	test_register_unavailable "\$ax"
+    }
+
+    # GDBserver always provides the PC value of regular tracepoint
+    # hits, since it's the same as the tracepoint's address.
+    test_register "\$$pcreg"
+    test_register "\$pc"
+
+    gdb_test "info registers" \
+	"<unavailable>.*<unavailable>" \
+	"info registers, multiple registers not available"
+
+    gdb_test "info registers \$$spreg" \
+	"<unavailable>" \
+	"info registers \$$spreg reports not available"
+}
+
 proc gdb_unavailable_registers_test { } {
     with_test_prefix "unavailable registers" {
-	global gdb_prompt
-	global spreg
-	global pcreg
 
 	prepare_for_trace_test
 
@@ -272,44 +315,30 @@ proc gdb_unavailable_registers_test { } {
 	# Begin the test.
 	run_trace_experiment globals_test_func
 
-	# On some archs, the $sp/$pc are a real raw registers.  On others,
-	# like x86, they're user registers.  Test both variants.
-	test_register_unavailable "\$$spreg"
-	test_register_unavailable "\$sp"
-
-	# Test reading uncollected pseudo-registers.  The set of which
-	# depends on target.
-	if [is_amd64_regs_target] {
-	    # Check the raw register first.
-	    test_register_unavailable "\$rax"
-	    test_register_unavailable "\$eax"
-	    test_register_unavailable "\$ax"
-	} elseif [is_x86_like_target] {
-	    # Check the raw register first.
-	    test_register_unavailable "\$eax"
-	    test_register_unavailable "\$ax"
-	}
-
-	# GDBserver always provides the PC value of regular tracepoint
-	# hits, since it's the same as the tracepoint's address.
-	test_register "\$$pcreg"
-	test_register "\$pc"
-
-	gdb_test "info registers" \
-	    "<unavailable>.*<unavailable>" \
-	    "info registers, multiple registers not available"
-
-	gdb_test "info registers \$$spreg" \
-	    "<unavailable>" \
-	    "info registers \$$spreg reports not available"
+	gdb_unavailable_registers_test_1
 
 	gdb_test "tfind none" "#0  end .*" "cease trace debugging"
     }
 }
 
-proc gdb_unavailable_floats { } {
+proc gdb_unavailable_floats_1 { } {
     global gdb_prompt
 
+    # Necessarily target specific.
+    if {[istarget "x86_64-*-*"] || [istarget i?86-*]} {
+	send_gdb "info float\n"
+	gdb_expect_list "info float" ".*$gdb_prompt $" {
+	    "Status Word:         <unavailable>"
+	    "Control Word:        <unavailable>"
+	    "Tag Word:            <unavailable>"
+	    "Instruction Pointer: <unavailable>:<unavailable>"
+	    "Operand Pointer:     <unavailable>:<unavailable>"
+	    "Opcode:              <unavailable>"
+	}
+    }
+}
+
+proc gdb_unavailable_floats { } {
     with_test_prefix "unavailable floats" {
 	prepare_for_trace_test
 
@@ -323,253 +352,246 @@ proc gdb_unavailable_floats { } {
 	# Begin the test.
 	run_trace_experiment globals_test_func
 
-	# Necessarily target specific.
-	if {[istarget "x86_64-*-*"] || [istarget i?86-*]} {
-	    send_gdb "info float\n"
-	    gdb_expect_list "info float" ".*$gdb_prompt $" {
-		"Status Word:         <unavailable>"
-		"Control Word:        <unavailable>"
-		"Tag Word:            <unavailable>"
-		"Instruction Pointer: <unavailable>:<unavailable>"
-		"Operand Pointer:     <unavailable>:<unavailable>"
-		"Opcode:              <unavailable>"
-	    }
-	}
+	gdb_unavailable_floats_1
 
 	gdb_test "tfind none" "#0  end .*" "cease trace debugging"
     }
 }
 
-proc gdb_collect_globals_test { } {
-    with_test_prefix "collect globals" {
-	global ws
-	global cr
-	global gdb_prompt
-	global hex
+proc gdb_collect_globals_test_1 { } {
+    global ws
+    global cr
+    global gdb_prompt
+    global hex
 
-	prepare_for_trace_test
+    gdb_test "print globalc" " = <unavailable>"
+    gdb_test "print globali" " = <unavailable>"
+    gdb_test "print globalf" " = <unavailable>"
+    gdb_test "print globald" " = <unavailable>"
 
-	set testline [gdb_get_line_number "set globals_test_func tracepoint here"]
+    gdb_test "print globalstruct.memberc" " = <unavailable>"
+    gdb_test "print globalstruct.memberi" " = <unavailable>"
+    gdb_test "print globalstruct.memberf" " = <unavailable>"
+    gdb_test "print globalstruct.memberd" " = <unavailable>"
 
-	gdb_test "trace $testline" \
-	    "Tracepoint \[0-9\]+ at .*" \
-	    "set tracepoint"
+    gdb_test "print globalstruct" " = <unavailable>"
 
-	# We collect the initial sizeof(pointer) bytes of derived_partial
-	# in an attempt of collecting the vptr.  Not portable, but should
-	# work everywhere we need to care.
-	gdb_trace_setactions "define actions" \
-	    "" \
-	    "collect struct_b.struct_a.array\[2\]" "^$" \
-	    "collect struct_b.struct_a.array\[100\]" "^$" \
-	    \
-	    "collect a" "^$" \
-	    "collect c" "^$" \
-	    \
-	    "collect tarray\[0\].a" "^$" \
-	    "collect tarray\[1\].a" "^$" \
-	    "collect tarray\[3\].a" "^$" \
-	    "collect tarray\[3\].b" "^$" \
-	    "collect tarray\[4\].b" "^$" \
-	    "collect tarray\[5\].b" "^$" \
-	    \
-	    "collect g_string_p" "^$" \
-	    "collect g_string_partial\[1\]" "^$" \
-	    "collect g_string_partial\[2\]" "^$" \
-	    \
-	    "collect g_structref_p" "^$" \
-	    \
-	    "collect *((char *)&derived_partial)@sizeof\(void *\)" "^$" \
-	    "collect derived_whole" "^$" \
-	    \
-	    "collect virtual_partial.z" "^$"
+    gdb_test "print globalp == &globalstruct" \
+	"value is not available" \
+	"can't compare using non collected global pointer"
 
-	# Begin the test.
-	run_trace_experiment globals_test_func
+    gdb_test "print globalarr\[1\]" " = <unavailable>"
+    gdb_test "print globalarr\[2\]" " = <unavailable>"
+    gdb_test "print globalarr\[3\]" " = <unavailable>"
 
-	gdb_test "print globalc" " = <unavailable>"
-	gdb_test "print globali" " = <unavailable>"
-	gdb_test "print globalf" " = <unavailable>"
-	gdb_test "print globald" " = <unavailable>"
+    gdb_test "print struct_b" \
+	" = {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>}"
 
-	gdb_test "print globalstruct.memberc" " = <unavailable>"
-	gdb_test "print globalstruct.memberi" " = <unavailable>"
-	gdb_test "print globalstruct.memberf" " = <unavailable>"
-	gdb_test "print globalstruct.memberd" " = <unavailable>"
+    gdb_test "print /x struct_b" \
+	" = {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>}"
 
-	gdb_test "print globalstruct" " = <unavailable>"
+    gdb_test "print /x struct_b.struct_a" \
+	" = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}"
 
-	gdb_test "print globalp == &globalstruct" \
-	    "value is not available" \
-	    "can't compare using non collected global pointer"
+    gdb_test "print /x struct_b.struct_a.array" \
+	" = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}"
 
-	gdb_test "print globalarr\[1\]" " = <unavailable>"
-	gdb_test "print globalarr\[2\]" " = <unavailable>"
-	gdb_test "print globalarr\[3\]" " = <unavailable>"
+    gdb_test "print /x struct_b.struct_a.array\[0\]" " = <unavailable>"
 
-	gdb_test "print struct_b" \
-	    " = {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>}"
+    gdb_test "print /x struct_b.struct_a.array\[2\]" " = 0xaaaaaaaa"
 
-	gdb_test "print /x struct_b" \
-	    " = {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>}"
+    # Check the target doesn't overcollect.  GDB used to merge memory
+    # ranges to collect if they were close enough (collecting the hole
+    # as well), but does not do that anymore.  It's plausible that a
+    # target may do this on its end, but as of this writing, no known
+    # target does it.
+    gdb_test "print {a, b, c}" \
+	" = \\{1, <unavailable>, 3\\}" \
+	"No overcollect of almost but not quite adjacent memory ranges"
 
-	gdb_test "print /x struct_b.struct_a" \
-	    " = {a = <unavailable>, b = <unavailable>, array = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}, ptr = <unavailable>, bitfield = <unavailable>}"
+    # Check <unavailable> isn't confused with 0 in array element repetitions
 
-	gdb_test "print /x struct_b.struct_a.array" \
-	    " = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}"
+    gdb_test_no_output "set print repeat 1"
 
-	gdb_test "print /x struct_b.struct_a.array\[0\]" " = <unavailable>"
+    gdb_test "print /x tarray" \
+	" = \{\{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>\}" \
+	"<unavailable> is not the same as 0 in array element repetitions"
 
-	gdb_test "print /x struct_b.struct_a.array\[2\]" " = 0xaaaaaaaa"
+    gdb_test_no_output "set print repeat 10"
 
-	# Check the target doesn't overcollect.  GDB used to merge memory
-	# ranges to collect if they were close enough (collecting the hole
-	# as well), but does not do that anymore.  It's plausible that a
-	# target may do this on its end, but as of this writing, no known
-	# target does it.
-	gdb_test "print {a, b, c}" \
-	    " = \\{1, <unavailable>, 3\\}" \
-	    "No overcollect of almost but not quite adjacent memory ranges"
+    # Check that value repeat handles unavailable-ness.
+    gdb_test "print *tarray@3" " = \\{\\{a = 0, b = <unavailable>\\}, \\{a = 0, b = <unavailable>\\}, \\{a = <unavailable>, b = <unavailable>\\}\\}"
 
-	# Check <unavailable> isn't confused with 0 in array element repetitions
+    # Static fields
 
-	gdb_test_no_output "set print repeat 1"
+    gdb_test "print struct_b.static_struct_a" " = <unavailable>"
 
-	gdb_test "print /x tarray" \
-	    " = \{\{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>\}" \
-	    "<unavailable> is not the same as 0 in array element repetitions"
+    # Bitfields
 
-	gdb_test_no_output "set print repeat 10"
+    gdb_test "print struct_b.struct_a.bitfield" " = <unavailable>"
 
-	# Check that value repeat handles unavailable-ness.
-	gdb_test "print *tarray@3" " = \\{\\{a = 0, b = <unavailable>\\}, \\{a = 0, b = <unavailable>\\}, \\{a = <unavailable>, b = <unavailable>\\}\\}"
+    # References
 
-	# Static fields
+    gdb_test "print g_int" " = <unavailable>"
 
-	gdb_test "print struct_b.static_struct_a" " = <unavailable>"
+    gdb_test "print g_ref" \
+	"\\(int &\\) @$hex: <unavailable>" \
+	"global reference shows address but not value"
 
-	# Bitfields
+    gdb_test "print *&g_ref" \
+	"\\$\[0-9\]+ = <unavailable>$cr" \
+	"referenced integer was not collected (taking address of reference)"
 
-	gdb_test "print struct_b.struct_a.bitfield" " = <unavailable>"
+    gdb_test "print *g_structref_p" " = <unavailable>"
 
-	# References
+    # Strings
 
-	gdb_test "print g_int" " = <unavailable>"
+    # Const string is always available, even when not collected.
+    gdb_test "print g_const_string" \
+	" = \"hello world\"$cr" \
+	"non collected const string is still printable"
 
-	gdb_test "print g_ref" \
-	    "\\(int &\\) @$hex: <unavailable>" \
-	    "global reference shows address but not value"
+    gdb_test "print g_string_p" \
+	" = $hex <g_const_string> \"hello world\"" \
+	"printing constant string through collected pointer"
 
-	gdb_test "print *&g_ref" \
-	    "\\$\[0-9\]+ = <unavailable>$cr" \
-	    "referenced integer was not collected (taking address of reference)"
+    gdb_test "print g_string_unavail" \
+	" = <unavailable>" \
+	"printing non collected string"
 
-	gdb_test "print *g_structref_p" " = <unavailable>"
+    # Incomplete strings print as an array.
+    gdb_test "print g_string_partial" \
+	"\\$\[0-9\]+ = \{<unavailable>, 101 'e', 108 'l', <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>\}" \
+	"printing partially collected string"
 
-	# Strings
+    # It is important for this test that the last examined value is
+    # <unavailable>, to exercise the case of the $__ convenience
+    # variable being set to <unavailable> without error.
+    set msg "examining partially collected object"
+    gdb_test_multiple "x /10x &struct_b" "$msg" {
+	-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 $" {
+	    pass "$msg"
+	}
+	-re "value is not available" {
+	    fail "$msg"
+	}
+    }
 
-	# Const string is always available, even when not collected.
-	gdb_test "print g_const_string" \
-	    " = \"hello world\"$cr" \
-	    "non collected const string is still printable"
+    gdb_test "p \$__" " = <unavailable>" "last examined value was <unavailable>"
 
-	gdb_test "print g_string_p" \
-	    " = $hex <g_const_string> \"hello world\"" \
-	    "printing constant string through collected pointer"
+    # This tests that building the array does not require accessing
+    # g_int's contents.
+    gdb_test "print { 1, g_int, 3 }" \
+	" = \\{1, <unavailable>, 3\\}" \
+	"build array from unavailable value"
 
-	gdb_test "print g_string_unavail" \
-	    " = <unavailable>" \
-	    "printing non collected string"
+    # Note, depends on previous test.
+    gdb_test "print \$\[1\]" \
+	" = <unavailable>" \
+	"subscript a non-memory rvalue array, accessing an unvailable element"
 
-	# Incomplete strings print as an array.
-	gdb_test "print g_string_partial" \
-	    "\\$\[0-9\]+ = \{<unavailable>, 101 'e', 108 'l', <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>, <unavailable>\}" \
-	    "printing partially collected string"
+    # Access a field of a non-lazy value, making sure the
+    # unavailable-ness is propagated.  History values are easy
+    # non-lazy values, so use those.  The first test just sets up for
+    # the second.
+    gdb_test "print g_smallstruct" " = <unavailable>"
+    gdb_test "print \$.member" " = <unavailable>"
 
-	# It is important for this test that the last examined value is
-	# <unavailable>, to exercise the case of the $__ convenience
-	# variable being set to <unavailable> without error.
-	set msg "examining partially collected object"
-	gdb_test_multiple "x /10x &struct_b" "$msg" {
-	    -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 $" {
-		pass "$msg"
-	    }
-	    -re "value is not available" {
-		fail "$msg"
-	    }
-	}
+    # Cast to baseclass, checking the unavailable-ness is propagated.
+    gdb_test "print (small_struct) g_smallstruct_b" " = <unavailable>"
 
-	gdb_test "p \$__" " = <unavailable>" "last examined value was <unavailable>"
+    # Same cast, but starting from a non-lazy, value.
+    gdb_test "print g_smallstruct_b" " = <unavailable>"
+    gdb_test "print (small_struct) \$" " = <unavailable>"
 
-	# This tests that building the array does not require accessing
-	# g_int's contents.
-	gdb_test "print { 1, g_int, 3 }" \
-	    " = \\{1, <unavailable>, 3\\}" \
-	    "build array from unavailable value"
+    gdb_test_no_output "set print object on"
 
-	# Note, depends on previous test.
-	gdb_test "print \$\[1\]" \
-	    " = <unavailable>" \
-	    "subscript a non-memory rvalue array, accessing an unvailable element"
+    with_test_prefix "print object on" {
+	# With print object on, printing a pointer may need to fetch
+	# the pointed-to object, to check its run-time type.  Make
+	# sure that fails gracefully and transparently when the
+	# pointer itself is unavailable.
+	gdb_test "print virtualp" " = <unavailable>"
 
-	# Access a field of a non-lazy value, making sure the
-	# unavailable-ness is propagated.  History values are easy
-	# non-lazy values, so use those.  The first test just sets up for
-	# the second.
-	gdb_test "print g_smallstruct" " = <unavailable>"
-	gdb_test "print \$.member" " = <unavailable>"
+	# no vtable pointer available
+	gdb_test "print derived_unavail" " = <unavailable>"
 
-	# Cast to baseclass, checking the unavailable-ness is propagated.
-	gdb_test "print (small_struct) g_smallstruct_b" " = <unavailable>"
+	# vtable pointer available, but nothing else
+	gdb_test "print derived_partial" \
+	    " = \\(Derived\\) {<Middle> = {<Base> = <unavailable>, _vptr.Middle = <unavailable>, y = <unavailable>}, _vptr.Derived = $hex <vtable for Derived.*>, z = <unavailable>}"
 
-	# Same cast, but starting from a non-lazy, value.
-	gdb_test "print g_smallstruct_b" " = <unavailable>"
-	gdb_test "print (small_struct) \$" " = <unavailable>"
+	# whole object available
+	gdb_test "print derived_whole" \
+	    " = \\(Derived\\) {<Middle> = {<Base> = {x = 2}, _vptr.Middle = $hex, y = 3}, _vptr.Derived = $hex <vtable for Derived.*>, z = 4}"
+    }
 
-	gdb_test_no_output "set print object on"
+    gdb_test_no_output "set print object off"
 
-	with_test_prefix "print object on" {
-	    # With print object on, printing a pointer may need to fetch
-	    # the pointed-to object, to check its run-time type.  Make
-	    # sure that fails gracefully and transparently when the
-	    # pointer itself is unavailable.
-	    gdb_test "print virtualp" " = <unavailable>"
+    with_test_prefix "print object off" {
+	gdb_test "print virtualp" " = <unavailable>"
 
-	    # no vtable pointer available
-	    gdb_test "print derived_unavail" " = <unavailable>"
+	# no vtable pointer available
+	gdb_test "print derived_unavail" \
+	    " = <unavailable>"
 
-	    # vtable pointer available, but nothing else
-	    gdb_test "print derived_partial" \
-		" = \\(Derived\\) {<Middle> = {<Base> = <unavailable>, _vptr.Middle = <unavailable>, y = <unavailable>}, _vptr.Derived = $hex <vtable for Derived.*>, z = <unavailable>}"
+	# vtable pointer available, but nothing else
+	gdb_test "print derived_partial" \
+	    " = {<Middle> = {<Base> = <unavailable>, _vptr.Middle = <unavailable>, y = <unavailable>}, _vptr.Derived = $hex <vtable for Derived.*>, z = <unavailable>}"
 
-	    # whole object available
-	    gdb_test "print derived_whole" \
-		" = \\(Derived\\) {<Middle> = {<Base> = {x = 2}, _vptr.Middle = $hex, y = 3}, _vptr.Derived = $hex <vtable for Derived.*>, z = 4}"
-	}
+	# whole object available
+	gdb_test "print derived_whole" \
+	    " = {<Middle> = {<Base> = {x = 2}, _vptr.Middle = $hex, y = 3}, _vptr.Derived = $hex <vtable for Derived.*>, z = 4}"
+    }
+
+    # An instance of a virtual class where we collected everything but
+    # the vptr.
+    gdb_test "print virtual_partial" \
+	" = {_vptr.Virtual = <unavailable>, z = 0}"
+}
 
-	gdb_test_no_output "set print object off"
+proc gdb_collect_globals_test { } {
+    with_test_prefix "collect globals" {
+	prepare_for_trace_test
 
-	with_test_prefix "print object off" {
-	    gdb_test "print virtualp" " = <unavailable>"
+	set testline [gdb_get_line_number "set globals_test_func tracepoint here"]
 
-	    # no vtable pointer available
-	    gdb_test "print derived_unavail" \
-		" = <unavailable>"
+	gdb_test "trace $testline" \
+	    "Tracepoint \[0-9\]+ at .*" \
+	    "set tracepoint"
 
-	    # vtable pointer available, but nothing else
-	    gdb_test "print derived_partial" \
-		" = {<Middle> = {<Base> = <unavailable>, _vptr.Middle = <unavailable>, y = <unavailable>}, _vptr.Derived = $hex <vtable for Derived.*>, z = <unavailable>}"
+	# We collect the initial sizeof(pointer) bytes of derived_partial
+	# in an attempt of collecting the vptr.  Not portable, but should
+	# work everywhere we need to care.
+	gdb_trace_setactions "define actions" \
+	    "" \
+	    "collect struct_b.struct_a.array\[2\]" "^$" \
+	    "collect struct_b.struct_a.array\[100\]" "^$" \
+	    \
+	    "collect a" "^$" \
+	    "collect c" "^$" \
+	    \
+	    "collect tarray\[0\].a" "^$" \
+	    "collect tarray\[1\].a" "^$" \
+	    "collect tarray\[3\].a" "^$" \
+	    "collect tarray\[3\].b" "^$" \
+	    "collect tarray\[4\].b" "^$" \
+	    "collect tarray\[5\].b" "^$" \
+	    \
+	    "collect g_string_p" "^$" \
+	    "collect g_string_partial\[1\]" "^$" \
+	    "collect g_string_partial\[2\]" "^$" \
+	    \
+	    "collect g_structref_p" "^$" \
+	    \
+	    "collect *((char *)&derived_partial)@sizeof\(void *\)" "^$" \
+	    "collect derived_whole" "^$" \
+	    \
+	    "collect virtual_partial.z" "^$"
 
-	    # whole object available
-	    gdb_test "print derived_whole" \
-		" = {<Middle> = {<Base> = {x = 2}, _vptr.Middle = $hex, y = 3}, _vptr.Derived = $hex <vtable for Derived.*>, z = 4}"
-	}
+	# Begin the test.
+	run_trace_experiment globals_test_func
 
-	# An instance of a virtual class where we collected everything but
-	# the vptr.
-	gdb_test "print virtual_partial" \
-	    " = {_vptr.Virtual = <unavailable>, z = 0}"
+	gdb_collect_globals_test_1
 
 	gdb_test "tfind none" \
 	    "#0  end .*" \
-- 
1.9.0