binutils/testsuite/binutils-all/objcopy.exp

   1 #   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   2 #   2004, 2006
   3 #   Free Software Foundation, Inc.
   4
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 2 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  18
  19 # Please email any bugs, comments, and/or additions to this file to:
  20 # bug-dejagnu@prep.ai.mit.edu
  21
  22 # Written by Ian Lance Taylor <ian@cygnus.com>
  23
  24 if ![is_remote host] {
  25     if {[which $OBJCOPY] == 0} then {
  26         perror "$OBJCOPY does not exist"
  27         return
  28     }
  29 }
  30
  31 send_user "Version [binutil_version $OBJCOPY]"
  32
  33 if ![is_remote host] {
  34     set tempfile tmpdir/bintest.o
  35     set copyfile tmpdir/copy
  36 } else {
  37     set tempfile [remote_download host tmpdir/bintest.o]
  38     set copyfile copy
  39 }
  40
  41 # Test that objcopy does not modify a file when copying it.
  42
  43 proc objcopy_test {testname srcfile} {
  44     global OBJCOPY
  45     global OBJCOPYFLAGS
  46     global srcdir
  47     global subdir
  48     global tempfile
  49     global copyfile
  50
  51     if {![binutils_assemble $srcdir/$subdir/${srcfile} tmpdir/bintest.o]} then {
  52         perror "unresolved $testname"
  53         unresolved "objcopy ($testname)"
  54         return
  55     }
  56
  57     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS $tempfile ${copyfile}.o"]
  58
  59     if ![string match "" $got] then {
  60         fail "objcopy ($testname)"
  61     } else {
  62         send_log "cmp $tempfile ${copyfile}.o\n"
  63         verbose "cmp $tempfile ${copyfile}.o"
  64         if [is_remote host] {
  65             set src1 tmpdir/bintest.o
  66             set src2 tmpdir/copy.o
  67             remote_upload host $tempfile $src1
  68             remote_upload host ${copyfile}.o $src2
  69         } else {
  70             set src1 ${tempfile}
  71             set src2 ${copyfile}.o
  72         }
  73         set status [remote_exec build cmp "${src1} ${src2}"]
  74         set exec_output [lindex $status 1]
  75         set exec_output [prune_warnings $exec_output]
  76
  77         # On some systems the result of objcopy will not be identical.
  78         # Usually this is just because gas isn't using bfd to write the
  79         # files in the first place, and may order things a little
  80         # differently. Those systems should use setup_xfail here.
  81
  82         setup_xfail "h8300-*-rtems*" "h8300-*-coff"
  83         setup_xfail "h8500-*-rtems*" "h8500-*-coff"
  84         setup_xfail "hppa*-*-*"
  85         setup_xfail "i960-*"
  86         setup_xfail "m68*-*-*coff" "m68*-*-hpux*" "m68*-*-lynxos*"
  87         setup_xfail "m68*-*-sysv*" "m68*-apple-aux*"
  88         setup_xfail "m8*-*"
  89         setup_xfail "or32-*-rtems*" "or32-*-coff"
  90         setup_xfail "sh-*-coff*" "sh-*-rtems*"
  91         setup_xfail "tic4x-*-*" "tic80-*-*" "w65-*"
  92
  93         clear_xfail "hppa*64*-*-hpux*" "hppa*-*-linux*" "hppa*-*-lites*"
  94         clear_xfail "hppa*-*-*n*bsd*" "hppa*-*-rtems*" "*-*-*elf*"
  95         clear_xfail "m68*-*-sysv4*"
  96
  97         if [string match "" $exec_output] then {
  98             pass "objcopy ($testname)"
  99         } else {
 100             send_log "$exec_output\n"
 101             verbose "$exec_output" 1
 102
 103             # On OSF/1, this succeeds with gas and fails with /bin/as.
 104             setup_xfail "alpha*-*-osf*"
 105
 106             # This fails for COFF i960-vxworks targets.
 107             setup_xfail "i960-*-vxworks*"
 108
 109             fail "objcopy ($testname)"
 110         }
 111     }
 112 }
 113
 114 objcopy_test "simple copy" bintest.s
 115
 116 # Test generating S records.
 117
 118 # We make the srec filename 8.3 compatible. Note that the header string
 119 # matched against depends on the name of the file. Ugh.
 120
 121 if [is_remote host] {
 122     set srecfile copy.sre
 123     set header_string S00B0000636F70792E737265C1
 124 } else {
 125     set srecfile ${copyfile}.srec
 126     set header_string S0130000746D706469722F636F70792E7372656397
 127 }
 128
 129 set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $tempfile ${srecfile}"]
 130
 131 if ![string match "" $got] then {
 132     fail "objcopy -O srec"
 133 } else {
 134     if [is_remote host] {
 135         remote_upload host ${srecfile} tmpdir/copy.srec
 136         set srecfile tmpdir/copy.srec
 137     }
 138     set file [open ${srecfile} r]
 139
 140     # The first S record is fixed by the file name we are using.
 141     gets $file line
 142     send_log "$line\n"
 143     verbose $line
 144     if ![regexp "$header_string.*" $line] {
 145         send_log "bad header\n"
 146         fail "objcopy -O srec"
 147     } else {
 148         while {[gets $file line] != -1 \
 149                && [regexp "^S\[123\]\[0-9a-fA-F\]+\[\r\n\]*$" $line]} {
 150             send_log "$line\n"
 151             verbose $line
 152             set line "**EOF**"
 153         }
 154         send_log "$line\n"
 155         verbose $line
 156         if ![regexp "^S\[789\]\[0-9a-fA-F\]+\[\r\n\]*$" $line] then {
 157             send_log "bad trailer\n"
 158             fail "objcopy -O srec"
 159         } else {
 160             if {[gets $file line] != -1} then {
 161                 send_log "garbage at end\n"
 162                 send_log "$line\n"
 163                 verbose $line
 164                 fail "objcopy -O srec"
 165             } else {
 166                 set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${copyfile}.srec"]
 167                 if ![regexp "file format srec" $got] then {
 168                     send_log "objdump failed\n"
 169                     fail "objcopy -O srec"
 170                 } else {
 171                     pass "objcopy -O srec"
 172                 }
 173             }
 174         }
 175     }
 176
 177     close $file
 178 }
 179
 180 # Test setting and adjusting the start address.  We only test this
 181 # while generating S records, because we may not be able to set the
 182 # start address for other object file formats, and the S record case
 183 # is the only useful one anyhow.
 184
 185 set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f $tempfile"]
 186 if ![regexp "start address (\[0-9a-fA-FxX\]+)" $got all origstart] then {
 187     perror "objdump can not recognize bintest.o"
 188     set origstart ""
 189 } else {
 190     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --set-start 0x7654 $tempfile ${copyfile}.srec"]
 191     if ![string match "" $got] then {
 192         fail "objcopy --set-start"
 193     } else {
 194         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${copyfile}.srec"]
 195         if ![regexp "file format srec.*start address (\[0-9a-fA-FxX\]+)" $got all srecstart] then {
 196             fail "objcopy --set-start"
 197         } else {
 198             if {$srecstart != 0x7654} then {
 199                 send_log "$srecstart != 0x7654\n"
 200                 fail "objcopy --set-start"
 201             } else {
 202                 pass "objcopy --set-start"
 203             }
 204         }
 205     }
 206
 207     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --adjust-start 0x123 $tempfile ${copyfile}.srec"]
 208     if ![string match "" $got] then {
 209         fail "objcopy --adjust-start"
 210     } else {
 211         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${copyfile}.srec"]
 212         if ![regexp "file format srec.*start address (\[0-9a-fA-FxX\]+)" $got all srecstart] then {
 213             fail "objcopy --adjust-start"
 214         } else {
 215             if {$srecstart != $origstart + 0x123} then {
 216                 send_log "$srecstart != $origstart + 0x123\n"
 217                 fail "objcopy --adjust-start"
 218             } else {
 219                 pass "objcopy --adjust-start"
 220             }
 221         }
 222     }
 223 }
 224
 225 # Test adjusting the overall VMA, and adjusting the VMA of a
 226 # particular section.  We again only test this when generating S
 227 # records.
 228
 229 set low ""
 230 set lowname ""
 231
 232 set headers [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h $tempfile"]
 233
 234 set headers_regexp "\[  0-9\]+(\[^      \]+)\[  \]*(\[0-9a-fA-F\]+)\[   \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)\[   \]+\[0-9a-fA-F\]+\[     \]+2\[*\]\[*\]\[0-9\]+(.*)"
 235
 236 set got $headers
 237 while {[regexp $headers_regexp $got all name size vma rest]} {
 238     set vma 0x$vma
 239     set size 0x$size
 240     if {$size != 0} {
 241         if {$low == "" || $vma < $low} {
 242             set low $vma
 243             set lowname $name
 244         }
 245     }
 246     set got $rest
 247 }
 248
 249 if {$low == "" || $origstart == ""} then {
 250     perror "objdump can not recognize bintest.o"
 251 } else {
 252     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --adjust-vma 0x123 $tempfile ${copyfile}.srec"]
 253     if ![string match "" $got] then {
 254         fail "objcopy --adjust-vma"
 255     } else {
 256         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -fh ${copyfile}.srec"]
 257         set want "file format srec.*start address\[     \]*(\[0-9a-fA-FxX\]+).*sec1\[   \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 258         if ![regexp $want $got all start vma] then {
 259             fail "objcopy --adjust-vma"
 260         } else {
 261             set vma 0x$vma
 262             if {$vma != $low + 0x123} then {
 263                 send_log "$vma != $low + 0x123\n"
 264                 fail "objcopy --adjust-vma"
 265             } else {
 266                 if {$start != $origstart + 0x123} then {
 267                     send_log "$start != $origstart + 0x123\n"
 268                     fail "objcopy --adjust-vma"
 269                 } else {
 270                     pass "objcopy --adjust-vma"
 271                 }
 272             }
 273         }
 274     }
 275
 276     set arg ""
 277     set got $headers
 278     while {[regexp $headers_regexp $got all name size vma rest]} {
 279         set vma 0x$vma
 280         if {$vma == $low} then {
 281             set arg "$arg --adjust-section-vma $name+4"
 282         }
 283         set got $rest
 284     }
 285
 286     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $arg $tempfile ${copyfile}.srec"]
 287     if ![string match "" $got] then {
 288         fail "objcopy --adjust-section-vma +"
 289     } else {
 290         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h ${copyfile}.srec"]
 291         set want "file format srec.*sec1\[      \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 292         if ![regexp $want $got all vma] then {
 293             fail "objcopy --adjust-section-vma +"
 294         } else {
 295             set vma 0x$vma
 296             if {$vma != $low + 4} then {
 297                 send_log "$vma != $low + 4\n"
 298                 fail "objcopy --adjust-section-vma +"
 299             } else {
 300                 pass "objcopy --adjust-section-vma +"
 301             }
 302         }
 303     }
 304
 305     regsub -all "\\+4" $arg "=[expr $low + 4]" argeq
 306     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $argeq $tempfile ${copyfile}.srec"]
 307     if ![string match "" $got] then {
 308         fail "objcopy --adjust-section-vma ="
 309     } else {
 310         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h ${copyfile}.srec"]
 311         set want "file format srec.*sec1\[      \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 312         if ![regexp $want $got all vma] then {
 313             fail "objcopy --adjust-section-vma ="
 314         } else {
 315             set vma 0x$vma
 316             if {$vma != $low + 4} then {
 317                 send_log "$vma != $low + 4\n"
 318                 fail "objcopy --adjust-section-vma ="
 319             } else {
 320                 pass "objcopy --adjust-section-vma ="
 321             }
 322         }
 323     }
 324 }
 325
 326 # Test stripping an object.
 327
 328 proc strip_test { } {
 329     global AR
 330     global CC
 331     global STRIP
 332     global STRIPFLAGS
 333     global NM
 334     global NMFLAGS
 335     global srcdir
 336     global subdir
 337
 338     set test "strip"
 339
 340     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 341         untested $test
 342         return
 343     }
 344
 345     if [is_remote host] {
 346         set archive libstrip.a
 347         set objfile [remote_download host tmpdir/testprog.o]
 348         remote_file host delete $archive
 349     } else {
 350         set archive tmpdir/libstrip.a
 351         set objfile tmpdir/testprog.o
 352     }
 353
 354     remote_file build delete tmpdir/libstrip.a
 355
 356     set exec_output [binutils_run $AR "rc $archive ${objfile}"]
 357     if ![string match "" $exec_output] {
 358         fail $test
 359         return
 360     }
 361
 362     set exec_output [binutils_run $STRIP "-g $archive"]
 363     if ![string match "" $exec_output] {
 364         fail $test
 365         return
 366     }
 367
 368     set exec_output [binutils_run $STRIP "$STRIPFLAGS $archive"]
 369     if ![string match "" $exec_output] {
 370         fail $test
 371         return
 372     }
 373
 374     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 375         untested $test
 376         return
 377     }
 378
 379     if [is_remote host] {
 380         set objfile [remote_download host tmpdir/testprog.o]
 381     } else {
 382         set objfile tmpdir/testprog.o
 383     }
 384
 385     set exec_output [binutils_run $STRIP "$STRIPFLAGS $objfile"]
 386     if ![string match "" $exec_output] {
 387         fail $test
 388         return
 389     }
 390
 391     set exec_output [binutils_run $NM "-a $NMFLAGS $objfile"]
 392     if ![string match "*: no symbols*" $exec_output] {
 393         fail $test
 394         return
 395     }
 396
 397     pass $test
 398 }
 399
 400 strip_test
 401
 402 # Test stripping an object file with saving a symbol
 403
 404 proc strip_test_with_saving_a_symbol { } {
 405     global CC
 406     global STRIP
 407     global STRIPFLAGS
 408     global NM
 409     global NMFLAGS
 410     global srcdir
 411     global subdir
 412
 413     set test "strip with saving a symbol"
 414
 415     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 416         untested $test
 417         return
 418     }
 419
 420     if [is_remote host] {
 421         set objfile [remote_download host tmpdir/testprog.o]
 422     } else {
 423         set objfile tmpdir/testprog.o
 424     }
 425
 426     set exec_output [binutils_run $STRIP "$STRIPFLAGS -K main -K _main $objfile"]
 427     if ![string match "" $exec_output] {
 428         fail $test
 429         return
 430     }
 431
 432     set exec_output [binutils_run $NM "$NMFLAGS $objfile"]
 433     if {![regexp {^([0-9a-fA-F]+)?[ ]+[TD] main} $exec_output] \
 434          && ![regexp {^([0-9a-fA-F]+)?[ ]+T _main} $exec_output]} {
 435         fail $test
 436         return
 437     }
 438
 439     pass $test
 440 }
 441
 442 strip_test_with_saving_a_symbol
 443
 444 # Build a final executable.
 445
 446 if { [istarget *-*-cygwin] || [istarget *-*-mingw*] } {
 447     set test_prog "testprog.exe"
 448 } else {
 449     set test_prog "testprog"
 450 }
 451
 452 proc copy_setup { } {
 453     global srcdir
 454     global subdir
 455     global gcc_gas_flag
 456     global test_prog
 457
 458     set res [build_wrapper testglue.o]
 459     set flags { debug }
 460
 461     if { $res != "" } {
 462         lappend flags "additional_flags=[lindex $res 1]"
 463         set add_libs "testglue.o"
 464     } else {
 465         set add_libs ""
 466     }
 467
 468     if { [istarget *-*-linux*] } {
 469         foreach i $gcc_gas_flag {
 470             set flags "additional_flags=$i $flags"
 471         }
 472     }
 473     if { [target_compile "$srcdir/$subdir/testprog.c $add_libs" tmpdir/$test_prog executable $flags]  != "" } {
 474         return 2
 475     }
 476
 477     set result [remote_load target tmpdir/$test_prog]
 478     set status [lindex $result 0]
 479
 480     if { $status != "pass"  } {
 481         perror "unresolved setup, status = $status"
 482         return 3
 483     }
 484
 485     return 0
 486 }
 487
 488 # Test copying an executable.
 489
 490 proc copy_executable { prog flags test1 test2 } {
 491     global test_prog
 492
 493     if [is_remote host] {
 494         set testfile [remote_download host tmpdir/$test_prog]
 495         set testcopy copyprog
 496     } else {
 497         set testfile tmpdir/$test_prog
 498         set testcopy tmpdir/copyprog
 499     }
 500     remote_file host delete $testcopy
 501
 502     set exec_output [binutils_run $prog "$flags $testfile $testcopy"]
 503
 504     if ![string match "" $exec_output] {
 505         fail $test1
 506         fail $test2
 507         return
 508     }
 509
 510     if [is_remote host] {
 511         remote_upload host $testcopy tmpdir/copyprog
 512     }
 513
 514     set status [remote_exec build "cmp" "tmpdir/$test_prog tmpdir/copyprog"]
 515     set exec_output [lindex $status 1]
 516
 517     if [string match "" $exec_output] then {
 518         pass $test1
 519     } else {
 520         send_log "$exec_output\n"
 521         verbose "$exec_output"
 522
 523         # This will fail for many reasons.  For example, it will most
 524         # likely fail if a non-GNU linker is used.  Therefore, we do
 525         # not insist that it pass.  If you are using an assembler and
 526         # linker based on the same BFD as objcopy, it is worth
 527         # investigating to see why this failure occurs.  If we are
 528         # cross compiling, we assume that a GNU linker is being used,
 529         # and expect it to succeed.
 530         if {[isnative]} then {
 531             setup_xfail "*-*-*"
 532         }
 533
 534         # This also fails for mips*-*-elf targets.  See elf32-mips.c
 535         # mips_elf_sym_is_global.
 536         setup_xfail "mips*-*-elf"
 537
 538         setup_xfail "*arm*-*-coff"
 539         setup_xfail "xscale-*-coff"
 540         setup_xfail "arm*-*-pe"
 541         setup_xfail "thumb*-*-coff"
 542         setup_xfail "thumb*-*-pe"
 543
 544         fail $test1
 545     }
 546
 547     set output [remote_load target tmpdir/copyprog]
 548     set status [lindex $output 0]
 549     if { $status != "pass" } {
 550         fail $test2
 551     } else {
 552         pass $test2
 553     }
 554 }
 555
 556 # Test stripping an executable
 557
 558 proc strip_executable { prog flags test } {
 559     global NM
 560     global NMFLAGS
 561
 562     remote_download build tmpdir/copyprog tmpdir/striprog
 563     if [is_remote host] {
 564         set copyfile [remote_download host tmpdir/striprog]
 565     } else {
 566         set copyfile tmpdir/striprog
 567     }
 568
 569     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 570     if ![string match "" $exec_output] {
 571         fail $test
 572         return
 573     }
 574
 575     if [is_remote host] {
 576         remote_upload host ${copyfile} tmpdir/striprog
 577     }
 578
 579     set result [remote_load target tmpdir/striprog]
 580     set status [lindex $result 0]
 581     if { $status != "pass" } {
 582         fail $test
 583         return
 584     }
 585
 586     set exec_output [binutils_run $NM "$NMFLAGS ${copyfile}"]
 587     if ![string match "*: no symbols*" $exec_output] {
 588         fail $test
 589         return
 590     }
 591     pass $test
 592 }
 593
 594 # Test stripping an executable with saving a symbol
 595
 596 proc strip_executable_with_saving_a_symbol { prog flags test } {
 597     global NM
 598     global NMFLAGS
 599
 600     remote_download build tmpdir/copyprog tmpdir/striprog
 601     if [is_remote host] {
 602         set copyfile [remote_download host tmpdir/striprog]
 603     } else {
 604         set copyfile tmpdir/striprog
 605     }
 606
 607     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 608     if ![string match "" $exec_output] {
 609         fail $test
 610         return
 611     }
 612
 613     if [is_remote host] {
 614         remote_upload host ${copyfile} tmpdir/striprog
 615     }
 616
 617     set result [remote_load target tmpdir/striprog]
 618     set status [lindex $result 0]
 619     if { $status != "pass" } {
 620         fail $test
 621         return
 622     }
 623
 624     set exec_output [binutils_run $NM "$NMFLAGS ${copyfile}"]
 625     if { [istarget mmix-knuth-mmixware] } {
 626         # Whenever there's a symbol in the mmo format, there's the symbol
 627         # Main, so remove it manually from the expected output for sake of
 628         # this test.
 629
 630         # Using "" not {} to get the \n and \r translated.
 631         regsub "^\[0-9a-fA-F\]+\[ \]+T Main\[\n\r\]+" $exec_output "" exec_output
 632     }
 633
 634     if {![regexp {^([0-9a-fA-F]+)?[ ]+[TD] main} $exec_output] \
 635          && ![regexp {^([0-9a-fA-F]+)?[ ]+[TD] _main} $exec_output]} {
 636         fail $test
 637         return
 638     }
 639     pass $test
 640 }
 641
 642 set test1 "simple objcopy of executable"
 643 set test2 "run objcopy of executable"
 644 set test3 "run stripped executable"
 645 set test4 "run stripped executable with saving a symbol"
 646
 647 switch [copy_setup] {
 648     "1" {
 649         # do nothing
 650     }
 651     "2" {
 652         untested $test1
 653         untested $test2
 654         untested $test3
 655         untested $test4
 656     }
 657     "3" {
 658         unresolved $test1
 659         unresolved $test2
 660         unresolved $test3
 661         unresolved $test4
 662     }
 663     "0" {
 664         copy_executable "$OBJCOPY" "$OBJCOPYFLAGS" "$test1" "$test2"
 665         strip_executable "$STRIP" "$STRIPFLAGS" "$test3"
 666         strip_executable_with_saving_a_symbol "$STRIP" "-K main -K _main $STRIPFLAGS" "$test4"
 667     }
 668 }
 669
 670 proc objcopy_test_readelf {testname srcfile} {
 671     global OBJCOPY
 672     global OBJCOPYFLAGS
 673     global READELF
 674     global srcdir
 675     global subdir
 676
 677     if {![binutils_assemble $srcdir/$subdir/${srcfile} tmpdir/bintest.o]} then {
 678         unresolved "objcopy ($testname)"
 679         return
 680     }
 681
 682     verbose -log "$OBJCOPY $OBJCOPYFLAGS tmpdir/bintest.o tmpdir/copy.o"
 683     catch "exec $OBJCOPY $OBJCOPYFLAGS tmpdir/bintest.o tmpdir/copy.o" exec_output
 684     if ![string match "" $exec_output] then {
 685         fail "objcopy ($testname)"
 686         return
 687     }
 688
 689     verbose -log "$READELF -a tmpdir/bintest.o > tmpdir/bintest.o.out"
 690     catch "exec $READELF -a tmpdir/bintest.o > tmpdir/bintest.o.out" exec_output
 691     set exec_output [prune_warnings $exec_output]
 692     if ![string match "" $exec_output] then {
 693         unresolved "objcopy ($testname)"
 694         return
 695     }
 696
 697     verbose -log "$READELF -a tmpdir/copy.o > tmpdir/copy.o.out"
 698     catch "exec $READELF -a tmpdir/copy.o > tmpdir/copy.o.out" exec_output
 699     set exec_output [prune_warnings $exec_output]
 700     if ![string match "" $exec_output] then {
 701         unresolved "objcopy ($testname)"
 702         return
 703     }
 704
 705     verbose -log "diff tmpdir/bintest.o.out tmpdir/copy.o.out"
 706     catch "exec diff tmpdir/bintest.o.out tmpdir/copy.o.out" exec_output
 707     set exec_output [prune_warnings $exec_output]
 708
 709     if [string match "" $exec_output] then {
 710         pass "objcopy ($testname)"
 711     } else {
 712         fail "objcopy ($testname)"
 713     }
 714 }
 715
 716 # ia64 specific tests
 717 if { ([istarget "ia64-*-elf*"]
 718        || [istarget "ia64-*-linux*"]) } {
 719     objcopy_test "ia64 link order" link-order.s
 720 }
 721
 722 # ELF specific tests
 723 if [is_elf_format] {
 724     objcopy_test "ELF unknown section type" unknown.s
 725     objcopy_test_readelf "ELF group" group.s
 726     run_dump_test "copy-1"
 727 }
 728
 729 run_dump_test "copy-2"
 730 run_dump_test "copy-3"
 731
 732 if [is_elf_format] {
 733     run_dump_test "localize-hidden-1"
 734     run_dump_test "strip-1"
 735     run_dump_test "strip-2"
 736 }
 737 run_dump_test "localize-hidden-2"