| 1 | # Copyright 2002-2019 Free Software Foundation, Inc. |
| 2 | |
| 3 | # This program is free software; you can redistribute it and/or modify |
| 4 | # it under the terms of the GNU General Public License as published by |
| 5 | # the Free Software Foundation; either version 3 of the License, or |
| 6 | # (at your option) any later version. |
| 7 | # |
| 8 | # This program is distributed in the hope that it will be useful, |
| 9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 11 | # GNU General Public License for more details. |
| 12 | # |
| 13 | # You should have received a copy of the GNU General Public License |
| 14 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 15 | |
| 16 | # This file was written by Michael Snyder (msnyder@redhat.com) |
| 17 | # This is a test for the gdb command "dump". |
| 18 | |
| 19 | |
| 20 | standard_testfile |
| 21 | |
| 22 | set options {debug} |
| 23 | |
| 24 | set is64bitonly "no" |
| 25 | set endian "auto" |
| 26 | |
| 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" |
| 31 | } |
| 32 | |
| 33 | # Debian9/Ubuntu16.10 onwards default to PIE enabled. Ensure it is disabled as |
| 34 | # this causes addresses to be out of range for IHEX. |
| 35 | lappend options {nopie} |
| 36 | |
| 37 | if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable ${options}] != "" } { |
| 38 | untested "failed to compile" |
| 39 | return -1 |
| 40 | } |
| 41 | |
| 42 | # Start with a fresh gdb. |
| 43 | |
| 44 | gdb_exit |
| 45 | gdb_start |
| 46 | gdb_reinitialize_dir $srcdir/$subdir |
| 47 | |
| 48 | gdb_test "dump mem /dev/null 0x10 0x20" "Cannot access memory at address 0x10" \ |
| 49 | "inaccessible memory is reported" |
| 50 | |
| 51 | gdb_load ${binfile} |
| 52 | |
| 53 | # Check the address of a variable. If it is bigger than 32-bit, |
| 54 | # assume our target has 64-bit addresses that are not supported by SREC, |
| 55 | # IHEX and TEKHEX. We skip those tests then. |
| 56 | set max_32bit_address "0xffffffff" |
| 57 | set data_address [get_hexadecimal_valueof "&intarray" 0x100000000] |
| 58 | if {${data_address} > ${max_32bit_address}} then { |
| 59 | set is64bitonly "yes" |
| 60 | } |
| 61 | |
| 62 | # Clean up any stale output files from previous test runs |
| 63 | |
| 64 | set filenames {} |
| 65 | set all_files { |
| 66 | intarr1.bin intarr1b.bin intarr1.ihex |
| 67 | intarr1.srec intarr1.tekhex intarr1.verilog |
| 68 | intarr2.bin intarr2b.bin intarr2.ihex |
| 69 | intarr2.srec intarr2.tekhex intarr2.verilog |
| 70 | intstr1.bin intstr1b.bin intstr1.ihex |
| 71 | intstr1.srec intstr1.tekhex intstr1.verilog |
| 72 | intstr2.bin intstr2b.bin intstr2.ihex |
| 73 | intstr2.srec intstr2.tekhex intstr2.verilog |
| 74 | intarr3.srec |
| 75 | } |
| 76 | |
| 77 | # This loop sets variables dynamically -- each name listed in |
| 78 | # $ALL_FILES is both a file name and a variable name. |
| 79 | foreach file $all_files { |
| 80 | if {[is_remote host]} { |
| 81 | set this_name $file |
| 82 | } else { |
| 83 | set this_name [standard_output_file $file] |
| 84 | } |
| 85 | |
| 86 | lappend filenames [set ${file} $this_name] |
| 87 | } |
| 88 | |
| 89 | remote_exec host "rm -f $filenames" |
| 90 | |
| 91 | # Test help (FIXME:) |
| 92 | |
| 93 | # Run target program until data structs are initialized. |
| 94 | |
| 95 | if { ! [ runto checkpoint1 ] } then { |
| 96 | untested "couldn't run to checkpoint" |
| 97 | return -1 |
| 98 | } |
| 99 | |
| 100 | # Get the endianness for the later use with endianless formats. |
| 101 | |
| 102 | set endian [get_endianness] |
| 103 | |
| 104 | # Now generate some dump files. |
| 105 | |
| 106 | proc make_dump_file { command msg } { |
| 107 | global gdb_prompt |
| 108 | |
| 109 | gdb_test_multiple "${command}" "$msg" { |
| 110 | -re ".*\[Ee\]rror.*$gdb_prompt $" { fail $msg } |
| 111 | -re ".*\[Ww\]arning.*$gdb_prompt $" { fail $msg } |
| 112 | -re ".*\[Uu\]ndefined .*$gdb_prompt $" { fail $msg } |
| 113 | -re ".*$gdb_prompt $" { pass $msg } |
| 114 | } |
| 115 | } |
| 116 | |
| 117 | make_dump_file "dump val [set intarr1.bin] intarray" \ |
| 118 | "dump array as value, default" |
| 119 | |
| 120 | make_dump_file "dump val [set intstr1.bin] intstruct" \ |
| 121 | "dump struct as value, default" |
| 122 | |
| 123 | make_dump_file "dump bin val [set intarr1b.bin] intarray" \ |
| 124 | "dump array as value, binary" |
| 125 | |
| 126 | make_dump_file "dump bin val [set intstr1b.bin] intstruct" \ |
| 127 | "dump struct as value, binary" |
| 128 | |
| 129 | make_dump_file "dump srec val [set intarr1.srec] intarray" \ |
| 130 | "dump array as value, srec" |
| 131 | |
| 132 | make_dump_file "dump srec val [set intstr1.srec] intstruct" \ |
| 133 | "dump struct as value, srec" |
| 134 | |
| 135 | make_dump_file "dump ihex val [set intarr1.ihex] intarray" \ |
| 136 | "dump array as value, intel hex" |
| 137 | |
| 138 | make_dump_file "dump ihex val [set intstr1.ihex] intstruct" \ |
| 139 | "dump struct as value, intel hex" |
| 140 | |
| 141 | make_dump_file "dump tekhex val [set intarr1.tekhex] intarray" \ |
| 142 | "dump array as value, tekhex" |
| 143 | |
| 144 | make_dump_file "dump tekhex val [set intstr1.tekhex] intstruct" \ |
| 145 | "dump struct as value, tekhex" |
| 146 | |
| 147 | make_dump_file "dump verilog val [set intarr1.verilog] intarray" \ |
| 148 | "dump array as value, verilog" |
| 149 | |
| 150 | make_dump_file "dump verilog val [set intstr1.verilog] intstruct" \ |
| 151 | "dump struct as value, verilog" |
| 152 | |
| 153 | proc capture_value { expression args } { |
| 154 | global gdb_prompt |
| 155 | global expect_out |
| 156 | |
| 157 | set output_string "" |
| 158 | if {[llength $args] > 0} { |
| 159 | # Convert $args into a simple string and don't use EXPRESSION |
| 160 | # in the test name. |
| 161 | set test "[join $args]; capture" |
| 162 | } { |
| 163 | set test "capture $expression" |
| 164 | } |
| 165 | gdb_test_multiple "print ${expression}" "$test" { |
| 166 | -re "\\$\[0-9\]+ = (\[^\r\n\]+).*$gdb_prompt $" { |
| 167 | set output_string "$expect_out(1,string)" |
| 168 | pass "$test" |
| 169 | } |
| 170 | -re "(Cannot access memory at address \[^\r\n\]+).*$gdb_prompt $" { |
| 171 | # Even a failed value is valid |
| 172 | set output_string "$expect_out(1,string)" |
| 173 | pass "$test" |
| 174 | } |
| 175 | } |
| 176 | return $output_string |
| 177 | } |
| 178 | |
| 179 | # POINTER is a pointer and this proc captures the value of POINTER along |
| 180 | # with POINTER's type. For example, POINTER is "&intarray", this proc will |
| 181 | # call "p &intarray", capture "(int (*)[32]) 0x804a0e0", and return this |
| 182 | # string. |
| 183 | |
| 184 | proc capture_pointer_with_type { pointer } { |
| 185 | global gdb_prompt |
| 186 | global expect_out |
| 187 | |
| 188 | set test "capture type of pointer $pointer" |
| 189 | set output_string "" |
| 190 | gdb_test_multiple "p ${pointer}" $test { |
| 191 | -re "\\$\[0-9\]+ = .*$gdb_prompt $" { |
| 192 | # Expected output of "p ${pointer}" is like "$7 = (int (*)[32]) 0x804a0e0", |
| 193 | # and we want to extract "(int (*)[32]) 0x804a0e0" from it via |
| 194 | # following regexp. |
| 195 | if [regexp " \\(.*\\).* 0x\[0-9a-fA-F\]+" $expect_out(0,string) output_string] { |
| 196 | # OUTPUT_STRING is expected to be like "(int (*)[32]) 0x804a0e0". |
| 197 | pass "$test" |
| 198 | } else { |
| 199 | fail "$test" |
| 200 | } |
| 201 | } |
| 202 | } |
| 203 | |
| 204 | return $output_string |
| 205 | } |
| 206 | |
| 207 | set array_start [capture_value "/x &intarray\[0\]"] |
| 208 | set array_end [capture_value "/x &intarray\[32\]"] |
| 209 | set struct_start [capture_value "/x &intstruct"] |
| 210 | set struct_end [capture_value "/x &intstruct + 1"] |
| 211 | |
| 212 | set array_val [capture_value "intarray"] |
| 213 | set struct_val [capture_value "intstruct"] |
| 214 | |
| 215 | set array_ptr_type [capture_pointer_with_type "&intarray"] |
| 216 | set struct_ptr_type [capture_pointer_with_type "&intstruct"] |
| 217 | |
| 218 | make_dump_file "dump mem [set intarr2.bin] $array_start $array_end" \ |
| 219 | "dump array as memory, default" |
| 220 | |
| 221 | make_dump_file "dump mem [set intstr2.bin] $struct_start $struct_end" \ |
| 222 | "dump struct as memory, default" |
| 223 | |
| 224 | make_dump_file "dump bin mem [set intarr2b.bin] $array_start $array_end" \ |
| 225 | "dump array as memory, binary" |
| 226 | |
| 227 | make_dump_file "dump bin mem [set intstr2b.bin] $struct_start $struct_end" \ |
| 228 | "dump struct as memory, binary" |
| 229 | |
| 230 | make_dump_file "dump srec mem [set intarr2.srec] $array_start $array_end" \ |
| 231 | "dump array as memory, srec" |
| 232 | |
| 233 | make_dump_file "dump srec mem [set intstr2.srec] $struct_start $struct_end" \ |
| 234 | "dump struct as memory, srec" |
| 235 | |
| 236 | make_dump_file "dump ihex mem [set intarr2.ihex] $array_start $array_end" \ |
| 237 | "dump array as memory, ihex" |
| 238 | |
| 239 | make_dump_file "dump ihex mem [set intstr2.ihex] $struct_start $struct_end" \ |
| 240 | "dump struct as memory, ihex" |
| 241 | |
| 242 | make_dump_file "dump tekhex mem [set intarr2.tekhex] $array_start $array_end" \ |
| 243 | "dump array as memory, tekhex" |
| 244 | |
| 245 | make_dump_file "dump tekhex mem [set intstr2.tekhex] $struct_start $struct_end" \ |
| 246 | "dump struct as memory, tekhex" |
| 247 | |
| 248 | make_dump_file "dump verilog mem [set intarr2.verilog] $array_start $array_end" \ |
| 249 | "dump array as memory, verilog" |
| 250 | |
| 251 | make_dump_file "dump verilog mem [set intstr2.verilog] $struct_start $struct_end" \ |
| 252 | "dump struct as memory, verilog" |
| 253 | |
| 254 | # test complex expressions |
| 255 | make_dump_file \ |
| 256 | "dump srec mem [set intarr3.srec] &intarray \(char *\) &intarray + sizeof intarray" \ |
| 257 | "dump array as mem, srec, expressions" |
| 258 | |
| 259 | proc test_restore_saved_value { restore_args msg oldval newval } { |
| 260 | global gdb_prompt |
| 261 | |
| 262 | gdb_test "restore $restore_args" \ |
| 263 | "Restoring .*" \ |
| 264 | "$msg; file restored ok" |
| 265 | if { ![string compare $oldval \ |
| 266 | [capture_value $newval "$msg"]] } then { |
| 267 | pass "$msg; value restored ok" |
| 268 | } else { |
| 269 | fail "$msg; value restored ok" |
| 270 | } |
| 271 | } |
| 272 | |
| 273 | if ![string compare $is64bitonly "no"] then { |
| 274 | |
| 275 | gdb_test "print zero_all ()" ".*" |
| 276 | |
| 277 | test_restore_saved_value "[set intarr1.srec]" "array as value, srec" \ |
| 278 | $array_val "intarray" |
| 279 | |
| 280 | test_restore_saved_value "[set intstr1.srec]" "struct as value, srec" \ |
| 281 | $struct_val "intstruct" |
| 282 | |
| 283 | gdb_test "print zero_all ()" "void" "zero all" |
| 284 | |
| 285 | test_restore_saved_value "[set intarr2.srec]" "array as memory, srec" \ |
| 286 | $array_val "intarray" |
| 287 | |
| 288 | test_restore_saved_value "[set intstr2.srec]" "struct as memory, srec" \ |
| 289 | $struct_val "intstruct" |
| 290 | |
| 291 | gdb_test "print zero_all ()" ".*" |
| 292 | |
| 293 | test_restore_saved_value "[set intarr1.ihex]" "array as value, ihex" \ |
| 294 | $array_val "intarray" |
| 295 | |
| 296 | test_restore_saved_value "[set intstr1.ihex]" "struct as value, ihex" \ |
| 297 | $struct_val "intstruct" |
| 298 | |
| 299 | gdb_test "print zero_all ()" ".*" |
| 300 | |
| 301 | test_restore_saved_value "[set intarr2.ihex]" "array as memory, ihex" \ |
| 302 | $array_val "intarray" |
| 303 | |
| 304 | test_restore_saved_value "[set intstr2.ihex]" "struct as memory, ihex" \ |
| 305 | $struct_val "intstruct" |
| 306 | |
| 307 | gdb_test "print zero_all ()" ".*" |
| 308 | |
| 309 | test_restore_saved_value "[set intarr1.tekhex]" "array as value, tekhex" \ |
| 310 | $array_val "intarray" |
| 311 | |
| 312 | test_restore_saved_value "[set intstr1.tekhex]" "struct as value, tekhex" \ |
| 313 | $struct_val "intstruct" |
| 314 | |
| 315 | gdb_test "print zero_all ()" ".*" |
| 316 | |
| 317 | test_restore_saved_value "[set intarr2.tekhex]" "array as memory, tekhex" \ |
| 318 | $array_val "intarray" |
| 319 | |
| 320 | test_restore_saved_value "[set intstr2.tekhex]" "struct as memory, tekhex" \ |
| 321 | $struct_val "intstruct" |
| 322 | } |
| 323 | |
| 324 | gdb_test "print zero_all ()" ".*" |
| 325 | |
| 326 | test_restore_saved_value "[set intarr1.bin] binary $array_start" \ |
| 327 | "array as value, binary" \ |
| 328 | $array_val "intarray" |
| 329 | |
| 330 | test_restore_saved_value "[set intstr1.bin] binary $struct_start" \ |
| 331 | "struct as value, binary" \ |
| 332 | $struct_val "intstruct" |
| 333 | |
| 334 | gdb_test "print zero_all ()" ".*" |
| 335 | |
| 336 | test_restore_saved_value "[set intarr2.bin] binary $array_start" \ |
| 337 | "array as memory, binary" \ |
| 338 | $array_val "intarray" |
| 339 | |
| 340 | test_restore_saved_value "[set intstr2.bin] binary $struct_start" \ |
| 341 | "struct as memory, binary" \ |
| 342 | $struct_val "intstruct" |
| 343 | |
| 344 | # test restore with offset. |
| 345 | |
| 346 | set array2_start [capture_value "/x &intarray2\[0\]"] |
| 347 | set struct2_start [capture_value "/x &intstruct2"] |
| 348 | set array2_offset \ |
| 349 | [capture_value "(char *) &intarray2 - (char *) &intarray"] |
| 350 | set struct2_offset \ |
| 351 | [capture_value "(char *) &intstruct2 - (char *) &intstruct"] |
| 352 | |
| 353 | gdb_test "print zero_all ()" ".*" |
| 354 | |
| 355 | |
| 356 | if ![string compare $is64bitonly "no"] then { |
| 357 | test_restore_saved_value "[set intarr1.srec] $array2_offset" \ |
| 358 | "array copy, srec" \ |
| 359 | $array_val "intarray2" |
| 360 | |
| 361 | test_restore_saved_value "[set intstr1.srec] $struct2_offset" \ |
| 362 | "struct copy, srec" \ |
| 363 | $struct_val "intstruct2" |
| 364 | |
| 365 | gdb_test "print zero_all ()" ".*" |
| 366 | |
| 367 | test_restore_saved_value "[set intarr1.ihex] $array2_offset" \ |
| 368 | "array copy, ihex" \ |
| 369 | $array_val "intarray2" |
| 370 | |
| 371 | test_restore_saved_value "[set intstr1.ihex] $struct2_offset" \ |
| 372 | "struct copy, ihex" \ |
| 373 | $struct_val "intstruct2" |
| 374 | |
| 375 | gdb_test "print zero_all ()" ".*" |
| 376 | |
| 377 | test_restore_saved_value "[set intarr1.tekhex] $array2_offset" \ |
| 378 | "array copy, tekhex" \ |
| 379 | $array_val "intarray2" |
| 380 | |
| 381 | test_restore_saved_value "[set intstr1.tekhex] $struct2_offset" \ |
| 382 | "struct copy, tekhex" \ |
| 383 | $struct_val "intstruct2" |
| 384 | } |
| 385 | |
| 386 | gdb_test "print zero_all ()" ".*" |
| 387 | |
| 388 | test_restore_saved_value "[set intarr1.bin] binary $array2_start" \ |
| 389 | "array copy, binary" \ |
| 390 | $array_val "intarray2" |
| 391 | |
| 392 | test_restore_saved_value "[set intstr1.bin] binary $struct2_start" \ |
| 393 | "struct copy, binary" \ |
| 394 | $struct_val "intstruct2" |
| 395 | |
| 396 | # |
| 397 | # test restore with start/stop addresses. |
| 398 | # |
| 399 | # For this purpose, we will restore just the third element of the array, |
| 400 | # and check to see that adjacent elements are not modified. |
| 401 | # |
| 402 | # We will need the address and offset of the third and fourth elements. |
| 403 | # |
| 404 | |
| 405 | set element3_start [capture_value "/x &intarray\[3\]"] |
| 406 | set element4_start [capture_value "/x &intarray\[4\]"] |
| 407 | set element3_offset \ |
| 408 | [capture_value "/x (char *) &intarray\[3\] - (char *) &intarray\[0\]"] |
| 409 | set element4_offset \ |
| 410 | [capture_value "/x (char *) &intarray\[4\] - (char *) &intarray\[0\]"] |
| 411 | |
| 412 | if ![string compare $is64bitonly "no"] then { |
| 413 | gdb_test "print zero_all ()" ".*" |
| 414 | |
| 415 | test_restore_saved_value "[set intarr1.srec] 0 $element3_start $element4_start" \ |
| 416 | "array partial, srec" 4 "intarray\[3\]" |
| 417 | |
| 418 | gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 1" |
| 419 | gdb_test "print intarray\[4\] == 0" " = 1" "element 4 not changed - 1" |
| 420 | |
| 421 | gdb_test "print zero_all ()" ".*" |
| 422 | |
| 423 | test_restore_saved_value "[set intarr1.ihex] 0 $element3_start $element4_start" \ |
| 424 | "array partial, ihex" 4 "intarray\[3\]" |
| 425 | |
| 426 | gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 2" |
| 427 | gdb_test "print intarray\[4\] == 0" " = 1" "element 4 not changed - 2" |
| 428 | |
| 429 | gdb_test "print zero_all ()" ".*" |
| 430 | |
| 431 | test_restore_saved_value "[set intarr1.tekhex] 0 $element3_start $element4_start" \ |
| 432 | "array partial, tekhex" 4 "intarray\[3\]" |
| 433 | |
| 434 | gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 3" |
| 435 | gdb_test "print intarray\[4\] == 0" " = 1" "element 4 not changed - 3" |
| 436 | } |
| 437 | |
| 438 | gdb_test "print zero_all ()" ".*" |
| 439 | |
| 440 | test_restore_saved_value \ |
| 441 | "[set intarr1.bin] binary $array_start $element3_offset $element4_offset" \ |
| 442 | "array partial, binary" 4 "intarray\[3\]" |
| 443 | |
| 444 | gdb_test "print intarray\[2\] == 0" " = 1" "element 2 not changed - 4" |
| 445 | gdb_test "print intarray\[4\] == 0" " = 1" "element 4 not changed - 4" |
| 446 | |
| 447 | if ![string compare $is64bitonly "no"] then { |
| 448 | gdb_test "print zero_all ()" ".*" "" |
| 449 | |
| 450 | # restore with expressions |
| 451 | test_restore_saved_value \ |
| 452 | "[set intarr3.srec] (char*)${array2_start}-(char*)${array_start} &intarray\[3\] &intarray\[4\]" \ |
| 453 | "array partial with expressions" 4 "intarray2\[3\]" |
| 454 | |
| 455 | gdb_test "print intarray2\[2\] == 0" " = 1" "element 2 not changed, == 4" |
| 456 | gdb_test "print intarray2\[4\] == 0" " = 1" "element 4 not changed, == 4" |
| 457 | } |
| 458 | |
| 459 | |
| 460 | # Now start a fresh gdb session, and reload the saved value files. |
| 461 | |
| 462 | gdb_exit |
| 463 | gdb_start |
| 464 | gdb_file_cmd ${binfile} |
| 465 | |
| 466 | # Now fix the endianness at the correct state. |
| 467 | |
| 468 | gdb_test_multiple "set endian $endian" "set endianness" { |
| 469 | -re ".* (big|little) endian.*$gdb_prompt $" { |
| 470 | pass "setting $endian endianness" |
| 471 | } |
| 472 | } |
| 473 | |
| 474 | # Reload saved values one by one, and compare. |
| 475 | |
| 476 | if { ![string compare $array_val \ |
| 477 | [capture_value "intarray" "file binfile; intarray"]] } then { |
| 478 | fail "start with intarray un-initialized" |
| 479 | } else { |
| 480 | pass "start with intarray un-initialized" |
| 481 | } |
| 482 | |
| 483 | if { ![string compare $struct_val \ |
| 484 | [capture_value "intstruct" "file binfile; intstruct"]] } then { |
| 485 | fail "start with intstruct un-initialized" |
| 486 | } else { |
| 487 | pass "start with intstruct un-initialized" |
| 488 | } |
| 489 | |
| 490 | proc test_reload_saved_value { filename msg oldval newval } { |
| 491 | global gdb_prompt |
| 492 | |
| 493 | gdb_file_cmd $filename |
| 494 | if { ![string compare $oldval \ |
| 495 | [capture_value $newval "$msg"]] } then { |
| 496 | pass "$msg; value restored ok" |
| 497 | } else { |
| 498 | fail "$msg; value restored ok" |
| 499 | } |
| 500 | } |
| 501 | |
| 502 | # srec format can not be loaded for 64-bit-only platforms |
| 503 | if ![string compare $is64bitonly "no"] then { |
| 504 | test_reload_saved_value "[set intarr1.srec]" "reload array as value, srec" \ |
| 505 | $array_val "\*$array_ptr_type" |
| 506 | test_reload_saved_value "[set intstr1.srec]" "reload struct as value, srec" \ |
| 507 | $struct_val "\*$struct_ptr_type" |
| 508 | test_reload_saved_value "[set intarr2.srec]" "reload array as memory, srec" \ |
| 509 | $array_val "\*$array_ptr_type" |
| 510 | test_reload_saved_value "[set intstr2.srec]" "reload struct as memory, srec" \ |
| 511 | $struct_val "\*$struct_ptr_type" |
| 512 | } |
| 513 | |
| 514 | # ihex format can not be loaded for 64-bit-only platforms |
| 515 | if ![string compare $is64bitonly "no"] then { |
| 516 | |
| 517 | test_reload_saved_value "[set intarr1.ihex]" \ |
| 518 | "reload array as value, intel hex" \ |
| 519 | $array_val "\*$array_ptr_type" |
| 520 | test_reload_saved_value "[set intstr1.ihex]" \ |
| 521 | "reload struct as value, intel hex" \ |
| 522 | $struct_val "\*$struct_ptr_type" |
| 523 | test_reload_saved_value "[set intarr2.ihex]" \ |
| 524 | "reload array as memory, intel hex" \ |
| 525 | $array_val "\*$array_ptr_type" |
| 526 | test_reload_saved_value "[set intstr2.ihex]" \ |
| 527 | "reload struct as memory, intel hex" \ |
| 528 | $struct_val "\*$struct_ptr_type" |
| 529 | } |
| 530 | |
| 531 | # tekhex format can not be loaded for 64-bit-only platforms |
| 532 | if ![string compare $is64bitonly "no"] then { |
| 533 | test_reload_saved_value "[set intarr1.tekhex]" \ |
| 534 | "reload array as value, tekhex" \ |
| 535 | $array_val "\*$array_ptr_type" |
| 536 | test_reload_saved_value "[set intstr1.tekhex]" \ |
| 537 | "reload struct as value, tekhex" \ |
| 538 | $struct_val "\*$struct_ptr_type" |
| 539 | test_reload_saved_value "[set intarr2.tekhex]" \ |
| 540 | "reload array as memory, tekhex" \ |
| 541 | $array_val "\*$array_ptr_type" |
| 542 | test_reload_saved_value "[set intstr2.tekhex]" \ |
| 543 | "reload struct as memory, tekhex" \ |
| 544 | $struct_val "\*$struct_ptr_type" |
| 545 | } |
| 546 | |
| 547 | # clean up files |
| 548 | |
| 549 | remote_exec host "rm -f $filenames" |