Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(153)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: gdb/testsuite/gdb.trace/unavailable.exp

Issue 124383005: GDB 7.6.50 (Closed) Base URL: http://git.chromium.org/native_client/nacl-gdb.git@upstream
Patch Set: Created 6 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « gdb/testsuite/gdb.trace/unavailable.cc ('k') | gdb/testsuite/gdb.trace/while-dyn.exp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: gdb/testsuite/gdb.trace/unavailable.exp
diff --git a/gdb/testsuite/gdb.trace/unavailable.exp b/gdb/testsuite/gdb.trace/unavailable.exp
index 1fb75ebb3a00da939799450a690ab7a7d348438b..40319d58c4b15f572b74c402e35ad070863c4d7e 100644
--- a/gdb/testsuite/gdb.trace/unavailable.exp
+++ b/gdb/testsuite/gdb.trace/unavailable.exp
@@ -1,4 +1,4 @@
-# Copyright 1998, 2005, 2007-2012 Free Software Foundation, Inc.
+# Copyright 1998-2013 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
@@ -133,174 +133,179 @@ 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 {} {
+ with_test_prefix "unavailable arguments" {
+ global cr
+ global gdb_prompt
- prepare_for_trace_test
+ prepare_for_trace_test
- gdb_test "trace args_test_func" \
- "Tracepoint \[0-9\]+ at .*" \
- "set tracepoint"
+ gdb_test "trace args_test_func" \
+ "Tracepoint \[0-9\]+ at .*" \
+ "set tracepoint"
- # Begin the test.
- run_trace_experiment args_test_func
+ # Begin the test.
+ run_trace_experiment args_test_func
- # 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.
+ # 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 argc" " = <unavailable>"
- gdb_test "print &argc" \
- "Can't take address of \"argc\" 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 argi" " = <unavailable>"
- gdb_test "print &argi" \
- "Can't take address of \"argi\" 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\."
- gdb_test "print argf" " = <unavailable>"
- gdb_test "print &argf" \
- "Can't take address of \"argf\" which isn't an lvalue\."
+ gdb_test "print argf" " = <unavailable>"
+ gdb_test "print &argf" \
+ "Can't take address of \"argf\" 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 argd" " = <unavailable>"
+ gdb_test "print &argd" \
+ "Can't take address of \"argd\" which isn't an lvalue\."
- # struct arg as one of several args (near end of list)
+ # struct arg as one of several args (near end of list)
- gdb_test "print argstruct" \
- " = \{memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>\}"
+ gdb_test "print argstruct" " = <unavailable>"
- 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 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" " = \\(int \\*\\) <unavailable>"
+ gdb_test "print argarray" " = <unavailable>"
- gdb_test "print &argarray" \
- "Can't take address of \"argarray\" which isn't an lvalue\."
+ gdb_test "print &argarray" \
+ "Can't take address of \"argarray\" which isn't an lvalue\."
- gdb_test "print argarray\[0\]" "value is not available"
+ gdb_test "print argarray\[0\]" "value is not available"
- # 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 = {memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>}${cr}"
- set r "${r}argarray = <unavailable>${cr}"
- gdb_test "info args" "$r" "info args"
+ # 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"
- test_maybe_regvar_display "argc"
+ test_maybe_regvar_display "argc"
- gdb_test "tfind none" \
- "#0 end .*" \
- "cease trace debugging"
-}}
+ gdb_test "tfind none" \
+ "#0 end .*" \
+ "cease trace debugging"
+ }
+}
-proc gdb_collect_locals_test { func msg } { with_test_prefix "unavailable locals: $msg" {
- global cr
- global gdb_prompt
+proc gdb_collect_locals_test { func msg } {
+ with_test_prefix "unavailable locals: $msg" {
+ global cr
+ global gdb_prompt
- prepare_for_trace_test
+ prepare_for_trace_test
- set testline [gdb_get_line_number "set $func tracepoint here"]
+ set testline [gdb_get_line_number "set $func tracepoint here"]
- gdb_test "trace $testline" \
+ gdb_test "trace $testline" \
"Tracepoint \[0-9\]+ at .*" \
"set tracepoint"
- # 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 = {memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>}${cr}"
- set r "${r}locar = {<unavailable>, <unavailable>, <unavailable>, <unavailable>}${cr}"
- set r "${r}i = <unavailable>${cr}"
- if { $func == "local_test_func" } {
- set r "${r}locdefst = {<No data fields>}${cr}"
- }
- set r "${r}locc = <unavailable>${cr}"
- set r "${r}loci = <unavailable>${cr}"
- gdb_test "info locals" "$r" "info locals"
+ # 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"
+ test_maybe_regvar_display "loci"
- gdb_test "tfind none" \
- "#0 end .*" \
- "cease trace debugging"
-}}
+ gdb_test "tfind none" \
+ "#0 end .*" \
+ "cease trace debugging"
+ }
+}
-proc gdb_unavailable_registers_test { } { with_test_prefix "unavailable registers" {
- global gdb_prompt
- global spreg
- global pcreg
+proc gdb_unavailable_registers_test { } {
+ with_test_prefix "unavailable registers" {
+ global gdb_prompt
+ global spreg
+ global pcreg
- prepare_for_trace_test
+ prepare_for_trace_test
- # We'll simply re-use the globals_test_function for this test
- gdb_test "trace globals_test_func" \
+ # We'll simply re-use the globals_test_function for this test
+ gdb_test "trace globals_test_func" \
"Tracepoint \[0-9\]+ at .*" \
"set tracepoint"
- # Collect nothing.
-
- # 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"
- }
+ # Collect nothing.
- # 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"
+ # Begin the test.
+ run_trace_experiment globals_test_func
- gdb_test "info registers" \
- "\\*value not available\\*.*\\*value not available\\*" \
- "info registers, multiple registers not available"
+ # 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 \$$spreg" \
- "\\*value not available\\*" \
- "info registers \$$spreg reports not available"
+ gdb_test "info registers" \
+ "<unavailable>.*<unavailable>" \
+ "info registers, multiple registers not available"
- gdb_test "tfind none" "#0 end .*" "cease trace debugging"
-}}
+ gdb_test "info registers \$$spreg" \
+ "<unavailable>" \
+ "info registers \$$spreg reports not available"
+
+ gdb_test "tfind none" "#0 end .*" "cease trace debugging"
+ }
+}
proc gdb_unavailable_floats { } {
global gdb_prompt
@@ -335,244 +340,242 @@ proc gdb_unavailable_floats { } {
}
}
-proc gdb_collect_globals_test { } { with_test_prefix "collect globals" {
- global ws
- global cr
- global gdb_prompt
- global hex
+proc gdb_collect_globals_test { } {
+ with_test_prefix "collect globals" {
+ global ws
+ global cr
+ global gdb_prompt
+ global hex
- prepare_for_trace_test
+ prepare_for_trace_test
- set testline [gdb_get_line_number "set globals_test_func tracepoint here"]
+ set testline [gdb_get_line_number "set globals_test_func tracepoint here"]
- gdb_test "trace $testline" \
+ gdb_test "trace $testline" \
"Tracepoint \[0-9\]+ at .*" \
"set tracepoint"
- # 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" "^$"
-
- # Begin the test.
- run_trace_experiment globals_test_func
-
- gdb_test "print globalc" " = <unavailable>"
- gdb_test "print globali" " = <unavailable>"
- gdb_test "print globalf" " = <unavailable>"
- gdb_test "print globald" " = <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 globalstruct" \
- " = {memberc = <unavailable>, memberi = <unavailable>, memberf = <unavailable>, memberd = <unavailable>}"
-
- gdb_test "print globalp == &globalstruct" \
+ # 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" "^$"
+
+ # Begin the test.
+ run_trace_experiment globals_test_func
+
+ gdb_test "print globalc" " = <unavailable>"
+ gdb_test "print globali" " = <unavailable>"
+ gdb_test "print globalf" " = <unavailable>"
+ gdb_test "print globald" " = <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 globalstruct" " = <unavailable>"
+
+ gdb_test "print globalp == &globalstruct" \
"value is not available" \
"can't compare using non collected global pointer"
- gdb_test "print globalarr\[1\]" " = <unavailable>"
- gdb_test "print globalarr\[2\]" " = <unavailable>"
- gdb_test "print globalarr\[3\]" " = <unavailable>"
+ gdb_test "print globalarr\[1\]" " = <unavailable>"
+ gdb_test "print globalarr\[2\]" " = <unavailable>"
+ gdb_test "print globalarr\[3\]" " = <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 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" \
- " = {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 /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 /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 /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 /x struct_b.struct_a.array" \
- " = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}"
+ gdb_test "print /x struct_b.struct_a.array" \
+ " = {<unavailable>, <unavailable>, 0xaaaaaaaa, <unavailable> <repeats 97 times>, 0xaaaaaaaa, <unavailable> <repeats 9899 times>}"
- gdb_test "print /x struct_b.struct_a.array\[0\]" " = <unavailable>"
+ gdb_test "print /x struct_b.struct_a.array\[0\]" " = <unavailable>"
- gdb_test "print /x struct_b.struct_a.array\[2\]" " = 0xaaaaaaaa"
+ gdb_test "print /x struct_b.struct_a.array\[2\]" " = 0xaaaaaaaa"
- # 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 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 <unavailable> isn't confused with 0 in array element repetitions
+ # Check <unavailable> isn't confused with 0 in array element repetitions
- gdb_test_no_output "set print repeat 1"
+ gdb_test_no_output "set print repeat 1"
- 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 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_no_output "set print repeat 10"
+ gdb_test_no_output "set print repeat 10"
- # 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 that value repeat handles unavailable-ness.
+ gdb_test "print *tarray@3" " = \\{\\{a = 0, b = <unavailable>\\}, \\{a = 0, b = <unavailable>\\}, \\{a = <unavailable>, b = <unavailable>\\}\\}"
- # Static fields
+ # Static fields
- gdb_test "print struct_b.static_struct_a" \
- " = {a = <unavailable>, b = <unavailable>, array = {<unavailable> <repeats 10000 times>}, ptr = <unavailable>, bitfield = <unavailable>}"
+ gdb_test "print struct_b.static_struct_a" " = <unavailable>"
- # Bitfields
+ # Bitfields
- gdb_test "print struct_b.struct_a.bitfield" " = <unavailable>"
+ gdb_test "print struct_b.struct_a.bitfield" " = <unavailable>"
- # References
+ # References
- gdb_test "print g_int" " = <unavailable>"
+ gdb_test "print g_int" " = <unavailable>"
- gdb_test "print g_ref" \
- "\\(int &\\) @$hex: <unavailable>" \
- "global reference shows address but not value"
+ gdb_test "print g_ref" \
+ "\\(int &\\) @$hex: <unavailable>" \
+ "global reference shows address but not value"
- gdb_test "print *&g_ref" \
- "\\$\[0-9\]+ = <unavailable>$cr" \
- "referenced integer was not collected (taking address of reference)"
+ gdb_test "print *&g_ref" \
+ "\\$\[0-9\]+ = <unavailable>$cr" \
+ "referenced integer was not collected (taking address of reference)"
- gdb_test "print *g_structref_p" \
- " = {d = <unavailable>, ref = <unavailable>}"
+ gdb_test "print *g_structref_p" " = <unavailable>"
- # Strings
+ # Strings
- # 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"
+ # 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_string_p" \
- " = $hex <g_const_string> \"hello world\"" \
- "printing constant string through collected pointer"
+ gdb_test "print g_string_p" \
+ " = $hex <g_const_string> \"hello world\"" \
+ "printing constant string through collected pointer"
- gdb_test "print g_string_unavail" \
- " = \{<unavailable> <repeats 12 times>\}" \
- "printing non collected string"
+ gdb_test "print g_string_unavail" \
+ " = <unavailable>" \
+ "printing non collected string"
- # 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"
+ # 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"
- # 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"
+ # 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"
+ }
}
- }
- gdb_test "p \$__" " = <unavailable>" "last examined value was <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"
-
- # Note, depends on previous test.
- gdb_test "print \$\[1\]" \
- " = <unavailable>" \
- "subscript a non-memory rvalue array, accessing an unvailable element"
-
- # 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" " = \\{member = <unavailable>\\}"
- gdb_test "print \$.member" " = <unavailable>"
-
- # Cast to baseclass, checking the unavailable-ness is propagated.
- gdb_test "print (small_struct) g_smallstruct_b" " = \\{member = <unavailable>\\}"
-
- # Same cast, but starting from a non-lazy, value.
- gdb_test "print g_smallstruct_b" " = \\{<small_struct> = \\{member = <unavailable>\\}, <No data fields>\\}"
- gdb_test "print (small_struct) \$" " = \\{member = <unavailable>\\}"
-
- gdb_test_no_output "set print object on"
-
- 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" " = \\(Virtual \\*\\) <unavailable>"
-
- # no vtable pointer available
- gdb_test "print derived_unavail" \
- " = {<Middle> = <unavailable>, _vptr.Derived = <unavailable>, z = <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>}"
-
- # 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 "p \$__" " = <unavailable>" "last examined value was <unavailable>"
- gdb_test_no_output "set print object off"
+ # 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"
- with_test_prefix "print object off" {
- gdb_test "print virtualp" " = \\(Virtual \\*\\) <unavailable>"
+ # Note, depends on previous test.
+ gdb_test "print \$\[1\]" \
+ " = <unavailable>" \
+ "subscript a non-memory rvalue array, accessing an unvailable element"
- # no vtable pointer available
- gdb_test "print derived_unavail" \
- " = {<Middle> = <unavailable>, _vptr.Derived = <unavailable>, z = <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>"
- # 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>}"
+ # Cast to baseclass, checking the unavailable-ness is propagated.
+ gdb_test "print (small_struct) g_smallstruct_b" " = <unavailable>"
- # 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}"
- }
+ # Same cast, but starting from a non-lazy, value.
+ gdb_test "print g_smallstruct_b" " = <unavailable>"
+ gdb_test "print (small_struct) \$" " = <unavailable>"
+
+ gdb_test_no_output "set print object on"
+
+ 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>"
+
+ # 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>}"
+
+ # 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 off"
- # An instance of a virtual class where we collected everything but
- # the vptr.
- gdb_test "print virtual_partial" \
- " = {_vptr.Virtual = <unavailable>, z = 0}"
+ with_test_prefix "print object off" {
+ gdb_test "print virtualp" " = <unavailable>"
- gdb_test "tfind none" \
- "#0 end .*" \
- "cease trace debugging"
-}}
+ # no vtable pointer available
+ gdb_test "print derived_unavail" \
+ " = <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" \
+ " = {<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 "tfind none" \
+ "#0 end .*" \
+ "cease trace debugging"
+ }
+}
proc gdb_trace_collection_test {} {
gdb_collect_globals_test
@@ -589,7 +592,7 @@ runto_main
if { ![gdb_target_supports_trace] } then {
unsupported "Current target does not support trace"
- return 1;
+ return 1
}
# Body of test encased in a proc so we can return prematurely.
« no previous file with comments | « gdb/testsuite/gdb.trace/unavailable.cc ('k') | gdb/testsuite/gdb.trace/while-dyn.exp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698