1 # Copyright 2002-2016 Free Software Foundation, Inc.
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.
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.
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/>.
16 # This file was written by Michael Snyder (msnyder@redhat.com)
17 # This is a test for the gdb command "dump".
27 if [istarget "alpha*-*-*"] then {
28 # SREC etc cannot handle 64-bit addresses. Force the test
29 # program into the low 31 bits of the address space.
30 lappend options "additional_flags=-Wl,-taso"
33 if {[istarget "spu*-*-*"]} then {
34 # The internal address format used for the combined Cell/B.E.
35 # debugger requires 64-bit.
39 if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable ${options}] != "" } {
40 untested "failed to compile"
44 # Start with a fresh gdb.
48 gdb_reinitialize_dir $srcdir/$subdir
50 gdb_test "dump mem /dev/null 0x10 0x20" "Cannot access memory at address 0x10" \
51 "inaccessible memory is reported"
55 # Check the address of a variable. If it is bigger than 32-bit,
56 # assume our target has 64-bit addresses that are not supported by SREC,
57 # IHEX and TEKHEX. We skip those tests then.
58 set max_32bit_address "0xffffffff"
59 set data_address [get_hexadecimal_valueof "&intarray" 0x100000000]
60 if {${data_address} > ${max_32bit_address}} then {
64 # Clean up any stale output files from previous test runs
68 intarr1.bin intarr1b.bin intarr1.ihex
69 intarr1.srec intarr1.tekhex intarr1.verilog
70 intarr2.bin intarr2b.bin intarr2.ihex
71 intarr2.srec intarr2.tekhex intarr2.verilog
72 intstr1.bin intstr1b.bin intstr1.ihex
73 intstr1.srec intstr1.tekhex intstr1.verilog
74 intstr2.bin intstr2b.bin intstr2.ihex
75 intstr2.srec intstr2.tekhex intstr2.verilog
79 # This loop sets variables dynamically -- each name listed in
80 # $ALL_FILES is both a file name and a variable name.
81 foreach file $all_files {
82 if {[is_remote host]} {
85 set this_name [standard_output_file $file]
88 lappend filenames [set ${file} $this_name]
91 remote_exec host "rm -f $filenames"
95 # Run target program until data structs are initialized.
97 if { ! [ runto checkpoint1 ] } then {
98 untested "couldn't run to checkpoint"
102 # Get the endianness for the later use with endianless formats.
104 gdb_test_multiple "show endian" "show endian" {
105 -re ".* (big|little) endian.*$gdb_prompt $" {
106 set endian $expect_out(1,string)
107 pass "endianness: $endian"
111 # Now generate some dump files.
113 proc make_dump_file { command msg } {
116 gdb_test_multiple "${command}" "$msg" {
117 -re ".*\[Ee\]rror.*$gdb_prompt $" { fail $msg }
118 -re ".*\[Ww\]arning.*$gdb_prompt $" { fail $msg }
119 -re ".*\[Uu\]ndefined .*$gdb_prompt $" { fail $msg }
120 -re ".*$gdb_prompt $" { pass $msg }
124 make_dump_file "dump val [set intarr1.bin] intarray" \
125 "dump array as value, default"
127 make_dump_file "dump val [set intstr1.bin] intstruct" \
128 "dump struct as value, default"
130 make_dump_file "dump bin val [set intarr1b.bin] intarray" \
131 "dump array as value, binary"
133 make_dump_file "dump bin val [set intstr1b.bin] intstruct" \
134 "dump struct as value, binary"
136 make_dump_file "dump srec val [set intarr1.srec] intarray" \
137 "dump array as value, srec"
139 make_dump_file "dump srec val [set intstr1.srec] intstruct" \
140 "dump struct as value, srec"
142 make_dump_file "dump ihex val [set intarr1.ihex] intarray" \
143 "dump array as value, intel hex"
145 make_dump_file "dump ihex val [set intstr1.ihex] intstruct" \
146 "dump struct as value, intel hex"
148 make_dump_file "dump tekhex val [set intarr1.tekhex] intarray" \
149 "dump array as value, tekhex"
151 make_dump_file "dump tekhex val [set intstr1.tekhex] intstruct" \
152 "dump struct as value, tekhex"
154 make_dump_file "dump verilog val [set intarr1.verilog] intarray" \
155 "dump array as value, verilog"
157 make_dump_file "dump verilog val [set intstr1.verilog] intstruct" \
158 "dump struct as value, verilog"
160 proc capture_value { expression args } {
165 if {[llength $args] > 0} {
166 # Convert $args into a simple string and don't use EXPRESSION
168 set test "[join $args]; capture"
170 set test "capture $expression"
172 gdb_test_multiple "print ${expression}" "$test" {
173 -re "\\$\[0-9\]+ = (\[^\r\n\]+).*$gdb_prompt $" {
174 set output_string "$expect_out(1,string)"
177 -re "(Cannot access memory at address \[^\r\n\]+).*$gdb_prompt $" {
178 # Even a failed value is valid
179 set output_string "$expect_out(1,string)"
183 return $output_string
186 # POINTER is a pointer and this proc captures the value of POINTER along
187 # with POINTER's type. For example, POINTER is "&intarray", this proc will
188 # call "p &intarray", capture "(int (*)[32]) 0x804a0e0", and return this
191 proc capture_pointer_with_type { pointer } {
195 set test "capture type of pointer $pointer"
197 gdb_test_multiple "p ${pointer}" $test {
198 -re "\\$\[0-9\]+ = .*$gdb_prompt $" {
199 # Expected output of "p ${pointer}" is like "$7 = (int (*)[32]) 0x804a0e0",
200 # and we want to extract "(int (*)[32]) 0x804a0e0" from it via
202 if [regexp " \\(.*\\).* 0x\[0-9a-fA-F\]+" $expect_out(0,string) output_string] {
203 # OUTPUT_STRING is expected to be like "(int (*)[32]) 0x804a0e0".
211 return $output_string
214 set array_start [capture_value "/x &intarray\[0\]"]
215 set array_end [capture_value "/x &intarray\[32\]"]
216 set struct_start [capture_value "/x &intstruct"]
217 set struct_end [capture_value "/x &intstruct + 1"]
219 set array_val [capture_value "intarray"]
220 set struct_val [capture_value "intstruct"]
222 set array_ptr_type [capture_pointer_with_type "&intarray"]
223 set struct_ptr_type [capture_pointer_with_type "&intstruct"]
225 make_dump_file "dump mem [set intarr2.bin] $array_start $array_end" \
226 "dump array as memory, default"
228 make_dump_file "dump mem [set intstr2.bin] $struct_start $struct_end" \
229 "dump struct as memory, default"
231 make_dump_file "dump bin mem [set intarr2b.bin] $array_start $array_end" \
232 "dump array as memory, binary"
234 make_dump_file "dump bin mem [set intstr2b.bin] $struct_start $struct_end" \
235 "dump struct as memory, binary"
237 make_dump_file "dump srec mem [set intarr2.srec] $array_start $array_end" \
238 "dump array as memory, srec"
240 make_dump_file "dump srec mem [set intstr2.srec] $struct_start $struct_end" \
241 "dump struct as memory, srec"
243 make_dump_file "dump ihex mem [set intarr2.ihex] $array_start $array_end" \
244 "dump array as memory, ihex"
246 make_dump_file "dump ihex mem [set intstr2.ihex] $struct_start $struct_end" \
247 "dump struct as memory, ihex"
249 make_dump_file "dump tekhex mem [set intarr2.tekhex] $array_start $array_end" \
250 "dump array as memory, tekhex"
252 make_dump_file "dump tekhex mem [set intstr2.tekhex] $struct_start $struct_end" \
253 "dump struct as memory, tekhex"
255 make_dump_file "dump verilog mem [set intarr2.verilog] $array_start $array_end" \
256 "dump array as memory, verilog"
258 make_dump_file "dump verilog mem [set intstr2.verilog] $struct_start $struct_end" \
259 "dump struct as memory, verilog"
261 # test complex expressions
263 "dump srec mem [set intarr3.srec] &intarray \(char *\) &intarray + sizeof intarray" \
264 "dump array as mem, srec, expressions"
266 proc test_restore_saved_value { restore_args msg oldval newval } {
269 gdb_test "restore $restore_args" \
271 "$msg; file restored ok"
272 if { ![string compare $oldval \
273 [capture_value $newval "$msg"]] } then {
274 pass "$msg; value restored ok"
276 fail "$msg; value restored ok"
280 if ![string compare $is64bitonly "no"] then {
282 gdb_test "print zero_all ()" ".*"
284 test_restore_saved_value "[set intarr1.srec]" "array as value, srec" \
285 $array_val "intarray"
287 test_restore_saved_value "[set intstr1.srec]" "struct as value, srec" \
288 $struct_val "intstruct"
290 gdb_test "print zero_all ()" "void" "zero all"
292 test_restore_saved_value "[set intarr2.srec]" "array as memory, srec" \
293 $array_val "intarray"
295 test_restore_saved_value "[set intstr2.srec]" "struct as memory, srec" \
296 $struct_val "intstruct"
298 gdb_test "print zero_all ()" ".*"
300 test_restore_saved_value "[set intarr1.ihex]" "array as value, ihex" \
301 $array_val "intarray"
303 test_restore_saved_value "[set intstr1.ihex]" "struct as value, ihex" \
304 $struct_val "intstruct"
306 gdb_test "print zero_all ()" ".*"
308 test_restore_saved_value "[set intarr2.ihex]" "array as memory, ihex" \
309 $array_val "intarray"
311 test_restore_saved_value "[set intstr2.ihex]" "struct as memory, ihex" \
312 $struct_val "intstruct"
314 gdb_test "print zero_all ()" ".*"
316 test_restore_saved_value "[set intarr1.tekhex]" "array as value, tekhex" \
317 $array_val "intarray"
319 test_restore_saved_value "[set intstr1.tekhex]" "struct as value, tekhex" \
320 $struct_val "intstruct"
322 gdb_test "print zero_all ()" ".*"
324 test_restore_saved_value "[set intarr2.tekhex]" "array as memory, tekhex" \
325 $array_val "intarray"
327 test_restore_saved_value "[set intstr2.tekhex]" "struct as memory, tekhex" \
328 $struct_val "intstruct"
331 gdb_test "print zero_all ()" ".*"
333 test_restore_saved_value "[set intarr1.bin] binary $array_start" \
334 "array as value, binary" \
335 $array_val "intarray"
337 test_restore_saved_value "[set intstr1.bin] binary $struct_start" \
338 "struct as value, binary" \
339 $struct_val "intstruct"
341 gdb_test "print zero_all ()" ".*"
343 test_restore_saved_value "[set intarr2.bin] binary $array_start" \
344 "array as memory, binary" \
345 $array_val "intarray"
347 test_restore_saved_value "[set intstr2.bin] binary $struct_start" \
348 "struct as memory, binary" \
349 $struct_val "intstruct"
351 # test restore with offset.
353 set array2_start [capture_value "/x &intarray2\[0\]"]
354 set struct2_start [capture_value "/x &intstruct2"]
356 [capture_value "(char *) &intarray2 - (char *) &intarray"]
358 [capture_value "(char *) &intstruct2 - (char *) &intstruct"]
360 gdb_test "print zero_all ()" ".*"
363 if ![string compare $is64bitonly "no"] then {
364 test_restore_saved_value "[set intarr1.srec] $array2_offset" \
366 $array_val "intarray2"
368 test_restore_saved_value "[set intstr1.srec] $struct2_offset" \
369 "struct copy, srec" \
370 $struct_val "intstruct2"
372 gdb_test "print zero_all ()" ".*"
374 test_restore_saved_value "[set intarr1.ihex] $array2_offset" \
376 $array_val "intarray2"
378 test_restore_saved_value "[set intstr1.ihex] $struct2_offset" \
379 "struct copy, ihex" \
380 $struct_val "intstruct2"
382 gdb_test "print zero_all ()" ".*"
384 test_restore_saved_value "[set intarr1.tekhex] $array2_offset" \
385 "array copy, tekhex" \
386 $array_val "intarray2"
388 test_restore_saved_value "[set intstr1.tekhex] $struct2_offset" \
389 "struct copy, tekhex" \
390 $struct_val "intstruct2"
393 gdb_test "print zero_all ()" ".*"
395 test_restore_saved_value "[set intarr1.bin] binary $array2_start" \
396 "array copy, binary" \
397 $array_val "intarray2"
399 test_restore_saved_value "[set intstr1.bin] binary $struct2_start" \
400 "struct copy, binary" \
401 $struct_val "intstruct2"
404 # test restore with start/stop addresses.
406 # For this purpose, we will restore just the third element of the array,
407 # and check to see that adjacent elements are not modified.
409 # We will need the address and offset of the third and fourth elements.
412 set element3_start [capture_value "/x &intarray\[3\]"]
413 set element4_start [capture_value "/x &intarray\[4\]"]
414 set element3_offset \
415 [capture_value "/x (char *) &intarray\[3\] - (char *) &intarray\[0\]"]
416 set element4_offset \
417 [capture_value "/x (char *) &intarray\[4\] - (char *) &intarray\[0\]"]
419 if ![string compare $is64bitonly "no"] then {
420 gdb_test "print zero_all ()" ".*"
422 test_restore_saved_value "[set intarr1.srec] 0 $element3_start $element4_start" \
423 "array partial, srec" 4 "intarray\[3\]"
425 gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 1"
426 gdb_test "print intarray\[4\] == 0" " = 1" "element 4 not changed - 1"
428 gdb_test "print zero_all ()" ".*"
430 test_restore_saved_value "[set intarr1.ihex] 0 $element3_start $element4_start" \
431 "array partial, ihex" 4 "intarray\[3\]"
433 gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 2"
434 gdb_test "print intarray\[4\] == 0" " = 1" "element 4 not changed - 2"
436 gdb_test "print zero_all ()" ".*"
438 test_restore_saved_value "[set intarr1.tekhex] 0 $element3_start $element4_start" \
439 "array partial, tekhex" 4 "intarray\[3\]"
441 gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 3"
442 gdb_test "print intarray\[4\] == 0" " = 1" "element 4 not changed - 3"
445 gdb_test "print zero_all ()" ".*"
447 test_restore_saved_value \
448 "[set intarr1.bin] binary $array_start $element3_offset $element4_offset" \
449 "array partial, binary" 4 "intarray\[3\]"
451 gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 4"
452 gdb_test "print intarray\[4\] == 0" " = 1" "element 4 not changed - 4"
454 if ![string compare $is64bitonly "no"] then {
455 gdb_test "print zero_all ()" ".*" ""
457 # restore with expressions
458 test_restore_saved_value \
459 "[set intarr3.srec] (char*)${array2_start}-(char*)${array_start} &intarray\[3\] &intarray\[4\]" \
460 "array partial with expressions" 4 "intarray2\[3\]"
462 gdb_test "print intarray2\[2\] == 0" " = 1" "element 2 not changed, == 4"
463 gdb_test "print intarray2\[4\] == 0" " = 1" "element 4 not changed, == 4"
467 # Now start a fresh gdb session, and reload the saved value files.
471 gdb_file_cmd ${binfile}
473 # Now fix the endianness at the correct state.
475 gdb_test_multiple "set endian $endian" "set endianness" {
476 -re ".* (big|little) endian.*$gdb_prompt $" {
477 pass "setting $endian endianness"
481 # Reload saved values one by one, and compare.
483 if { ![string compare $array_val \
484 [capture_value "intarray" "file binfile; intarray"]] } then {
485 fail "start with intarray un-initialized"
487 pass "start with intarray un-initialized"
490 if { ![string compare $struct_val \
491 [capture_value "intstruct" "file binfile; intstruct"]] } then {
492 fail "start with intstruct un-initialized"
494 pass "start with intstruct un-initialized"
497 proc test_reload_saved_value { filename msg oldval newval } {
500 gdb_file_cmd $filename
501 if { ![string compare $oldval \
502 [capture_value $newval "$msg"]] } then {
503 pass "$msg; value restored ok"
505 fail "$msg; value restored ok"
509 # srec format can not be loaded for 64-bit-only platforms
510 if ![string compare $is64bitonly "no"] then {
511 test_reload_saved_value "[set intarr1.srec]" "reload array as value, srec" \
512 $array_val "\*$array_ptr_type"
513 test_reload_saved_value "[set intstr1.srec]" "reload struct as value, srec" \
514 $struct_val "\*$struct_ptr_type"
515 test_reload_saved_value "[set intarr2.srec]" "reload array as memory, srec" \
516 $array_val "\*$array_ptr_type"
517 test_reload_saved_value "[set intstr2.srec]" "reload struct as memory, srec" \
518 $struct_val "\*$struct_ptr_type"
521 # ihex format can not be loaded for 64-bit-only platforms
522 if ![string compare $is64bitonly "no"] then {
524 test_reload_saved_value "[set intarr1.ihex]" \
525 "reload array as value, intel hex" \
526 $array_val "\*$array_ptr_type"
527 test_reload_saved_value "[set intstr1.ihex]" \
528 "reload struct as value, intel hex" \
529 $struct_val "\*$struct_ptr_type"
530 test_reload_saved_value "[set intarr2.ihex]" \
531 "reload array as memory, intel hex" \
532 $array_val "\*$array_ptr_type"
533 test_reload_saved_value "[set intstr2.ihex]" \
534 "reload struct as memory, intel hex" \
535 $struct_val "\*$struct_ptr_type"
538 # tekhex format can not be loaded for 64-bit-only platforms
539 if ![string compare $is64bitonly "no"] then {
540 test_reload_saved_value "[set intarr1.tekhex]" \
541 "reload array as value, tekhex" \
542 $array_val "\*$array_ptr_type"
543 test_reload_saved_value "[set intstr1.tekhex]" \
544 "reload struct as value, tekhex" \
545 $struct_val "\*$struct_ptr_type"
546 test_reload_saved_value "[set intarr2.tekhex]" \
547 "reload array as memory, tekhex" \
548 $array_val "\*$array_ptr_type"
549 test_reload_saved_value "[set intstr2.tekhex]" \
550 "reload struct as memory, tekhex" \
551 $struct_val "\*$struct_ptr_type"
556 remote_exec host "rm -f $filenames"