binutils/testsuite/binutils-all/objcopy.exp

   1 #   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   2 #   2004, 2006, 2007, 2009
   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 3 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             fail "objcopy ($testname)"
 107         }
 108     }
 109 }
 110
 111 objcopy_test "simple copy" bintest.s
 112
 113 # Test reversing bytes in a section.
 114
 115 set reversed ${tempfile}-reversed
 116 set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -j .data --reverse-bytes=4 $tempfile $reversed"]
 117
 118 if ![string match "" $got] then {
 119     fail "objcopy --reverse-bytes"
 120 } else {
 121     if [is_remote host] {
 122         remote_upload host ${reversed} tmpdir/copy-reversed.o
 123         set reversed tmpdir/copy-reversed.o
 124     }
 125
 126     set origdata [binutils_run $OBJDUMP "$OBJDUMPFLAGS -s -j .data $tempfile"]
 127     set revdata [binutils_run $OBJDUMP "$OBJDUMPFLAGS -s -j .data $reversed"]
 128
 129     set want "^ \[0-9\]+ (\[0-9\]+)"
 130     set found_orig [regexp -lineanchor $want $origdata -> origdata]
 131     set found_rev [regexp -lineanchor $want $revdata -> revdata]
 132
 133     if {$found_orig == 0 || $found_rev == 0} then {
 134         fail "objcopy --reverse-bytes"
 135     } else {
 136         scan $origdata "%2x%2x%2x%2x" b1 b2 b3 b4
 137         scan $revdata "%2x%2x%2x%2x" c4 c3 c2 c1
 138
 139         if {$b1 == $c1 && $b2 == $c2 && $b3 == $c3 && $b4 == $c4} then {
 140             pass "objcopy --reverse-bytes"
 141         } else {
 142             fail "objcopy --reverse-bytes"
 143         }
 144     }
 145 }
 146
 147 # Test generating S records.
 148
 149 # We make the srec filename 8.3 compatible. Note that the header string
 150 # matched against depends on the name of the file. Ugh.
 151
 152 if [is_remote host] {
 153     set srecfile copy.sre
 154     set header_string S00B0000636F70792E737265C1
 155 } else {
 156     set srecfile ${copyfile}.srec
 157     set header_string S0130000746D706469722F636F70792E7372656397
 158 }
 159
 160 set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $tempfile ${srecfile}"]
 161
 162 if ![string match "" $got] then {
 163     fail "objcopy -O srec"
 164 } else {
 165     if [is_remote host] {
 166         remote_upload host ${srecfile} tmpdir/copy.srec
 167         set srecfile tmpdir/copy.srec
 168     }
 169     set file [open ${srecfile} r]
 170
 171     # The first S record is fixed by the file name we are using.
 172     gets $file line
 173     send_log "$line\n"
 174     verbose $line
 175     if ![regexp "$header_string.*" $line] {
 176         send_log "bad header\n"
 177         fail "objcopy -O srec"
 178     } else {
 179         while {[gets $file line] != -1 \
 180                && [regexp "^S\[123\]\[0-9a-fA-F\]+\[\r\n\]*$" $line]} {
 181             send_log "$line\n"
 182             verbose $line
 183             set line "**EOF**"
 184         }
 185         send_log "$line\n"
 186         verbose $line
 187         if ![regexp "^S\[789\]\[0-9a-fA-F\]+\[\r\n\]*$" $line] then {
 188             send_log "bad trailer\n"
 189             fail "objcopy -O srec"
 190         } else {
 191             if {[gets $file line] != -1} then {
 192                 send_log "garbage at end\n"
 193                 send_log "$line\n"
 194                 verbose $line
 195                 fail "objcopy -O srec"
 196             } else {
 197                 set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${srecfile}"]
 198                 if ![regexp "file format srec" $got] then {
 199                     send_log "objdump failed\n"
 200                     fail "objcopy -O srec"
 201                 } else {
 202                     pass "objcopy -O srec"
 203                 }
 204             }
 205         }
 206     }
 207
 208     close $file
 209 }
 210
 211 # Test setting and adjusting the start address.  We only test this
 212 # while generating S records, because we may not be able to set the
 213 # start address for other object file formats, and the S record case
 214 # is the only useful one anyhow.
 215
 216 set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f $tempfile"]
 217 if ![regexp "start address (\[0-9a-fA-FxX\]+)" $got all origstart] then {
 218     perror "objdump can not recognize bintest.o"
 219     set origstart ""
 220 } else {
 221     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --set-start 0x7654 $tempfile ${copyfile}.srec"]
 222     if ![string match "" $got] then {
 223         fail "objcopy --set-start"
 224     } else {
 225         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${copyfile}.srec"]
 226         if ![regexp "file format srec.*start address (\[0-9a-fA-FxX\]+)" $got all srecstart] then {
 227             fail "objcopy --set-start"
 228         } else {
 229             if {$srecstart != 0x7654} then {
 230                 send_log "$srecstart != 0x7654\n"
 231                 fail "objcopy --set-start"
 232             } else {
 233                 pass "objcopy --set-start"
 234             }
 235         }
 236     }
 237
 238     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --adjust-start 0x123 $tempfile ${copyfile}.srec"]
 239     if ![string match "" $got] then {
 240         fail "objcopy --adjust-start"
 241     } else {
 242         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${copyfile}.srec"]
 243         if ![regexp "file format srec.*start address (\[0-9a-fA-FxX\]+)" $got all srecstart] then {
 244             fail "objcopy --adjust-start"
 245         } else {
 246             if {$srecstart != $origstart + 0x123} then {
 247                 send_log "$srecstart != $origstart + 0x123\n"
 248                 fail "objcopy --adjust-start"
 249             } else {
 250                 pass "objcopy --adjust-start"
 251             }
 252         }
 253     }
 254 }
 255
 256 # Test adjusting the overall VMA, and adjusting the VMA of a
 257 # particular section.  We again only test this when generating S
 258 # records.
 259
 260 set low ""
 261 set lowname ""
 262
 263 set headers [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h $tempfile"]
 264
 265 set headers_regexp "\[  0-9\]+(\[^      \]+)\[  \]*(\[0-9a-fA-F\]+)\[   \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)\[   \]+\[0-9a-fA-F\]+\[     \]+2\[*\]\[*\]\[0-9\]+(.*)"
 266
 267 set got $headers
 268 while {[regexp $headers_regexp $got all name size vma rest]} {
 269     set vma 0x$vma
 270     set size 0x$size
 271     if {$size != 0} {
 272         if {$low == "" || $vma < $low} {
 273             set low $vma
 274             set lowname $name
 275         }
 276     }
 277     set got $rest
 278 }
 279
 280 if {$low == "" || $origstart == ""} then {
 281     perror "objdump can not recognize bintest.o"
 282 } else {
 283     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --adjust-vma 0x123 $tempfile ${copyfile}.srec"]
 284     if ![string match "" $got] then {
 285         fail "objcopy --adjust-vma"
 286     } else {
 287         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -fh ${copyfile}.srec"]
 288         set want "file format srec.*start address\[     \]*(\[0-9a-fA-FxX\]+).*sec1\[   \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 289         if ![regexp $want $got all start vma] then {
 290             fail "objcopy --adjust-vma"
 291         } else {
 292             set vma 0x$vma
 293             if {$vma != $low + 0x123} then {
 294                 send_log "$vma != $low + 0x123\n"
 295                 fail "objcopy --adjust-vma"
 296             } else {
 297                 if {$start != $origstart + 0x123} then {
 298                     send_log "$start != $origstart + 0x123\n"
 299                     fail "objcopy --adjust-vma"
 300                 } else {
 301                     pass "objcopy --adjust-vma"
 302                 }
 303             }
 304         }
 305     }
 306
 307     set arg ""
 308     set got $headers
 309     while {[regexp $headers_regexp $got all name size vma rest]} {
 310         set vma 0x$vma
 311         if {$vma == $low} then {
 312             set arg "$arg --adjust-section-vma $name+4"
 313         }
 314         set got $rest
 315     }
 316
 317     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $arg $tempfile ${copyfile}.srec"]
 318     if ![string match "" $got] then {
 319         fail "objcopy --adjust-section-vma +"
 320     } else {
 321         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h ${copyfile}.srec"]
 322         set want "file format srec.*sec1\[      \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 323         if ![regexp $want $got all vma] then {
 324             fail "objcopy --adjust-section-vma +"
 325         } else {
 326             set vma 0x$vma
 327             if {$vma != $low + 4} then {
 328                 send_log "$vma != $low + 4\n"
 329                 fail "objcopy --adjust-section-vma +"
 330             } else {
 331                 pass "objcopy --adjust-section-vma +"
 332             }
 333         }
 334     }
 335
 336     regsub -all "\\+4" $arg "=[expr $low + 4]" argeq
 337     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $argeq $tempfile ${copyfile}.srec"]
 338     if ![string match "" $got] then {
 339         fail "objcopy --adjust-section-vma ="
 340     } else {
 341         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h ${copyfile}.srec"]
 342         set want "file format srec.*sec1\[      \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 343         if ![regexp $want $got all vma] then {
 344             fail "objcopy --adjust-section-vma ="
 345         } else {
 346             set vma 0x$vma
 347             if {$vma != $low + 4} then {
 348                 send_log "$vma != $low + 4\n"
 349                 fail "objcopy --adjust-section-vma ="
 350             } else {
 351                 pass "objcopy --adjust-section-vma ="
 352             }
 353         }
 354     }
 355 }
 356
 357 # Test stripping an object.
 358
 359 proc strip_test { } {
 360     global AR
 361     global CC
 362     global STRIP
 363     global STRIPFLAGS
 364     global NM
 365     global NMFLAGS
 366     global srcdir
 367     global subdir
 368
 369     set test "strip"
 370
 371     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 372         untested $test
 373         return
 374     }
 375
 376     if [is_remote host] {
 377         set archive libstrip.a
 378         set objfile [remote_download host tmpdir/testprog.o]
 379         remote_file host delete $archive
 380     } else {
 381         set archive tmpdir/libstrip.a
 382         set objfile tmpdir/testprog.o
 383     }
 384
 385     remote_file build delete tmpdir/libstrip.a
 386
 387     set exec_output [binutils_run $AR "rc $archive ${objfile}"]
 388     if ![string match "" $exec_output] {
 389         fail $test
 390         return
 391     }
 392
 393     set exec_output [binutils_run $STRIP "-g $archive"]
 394     if ![string match "" $exec_output] {
 395         fail $test
 396         return
 397     }
 398
 399     set exec_output [binutils_run $STRIP "$STRIPFLAGS $archive"]
 400     if ![string match "" $exec_output] {
 401         fail $test
 402         return
 403     }
 404
 405     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 406         untested $test
 407         return
 408     }
 409
 410     if [is_remote host] {
 411         set objfile [remote_download host tmpdir/testprog.o]
 412     } else {
 413         set objfile tmpdir/testprog.o
 414     }
 415
 416     set exec_output [binutils_run $STRIP "$STRIPFLAGS $objfile"]
 417     if ![string match "" $exec_output] {
 418         fail $test
 419         return
 420     }
 421
 422     set exec_output [binutils_run $NM "-a $NMFLAGS $objfile"]
 423     if ![string match "*: no symbols*" $exec_output] {
 424         fail $test
 425         return
 426     }
 427
 428     pass $test
 429 }
 430
 431 strip_test
 432
 433 # Test stripping an object file with saving a symbol
 434
 435 proc strip_test_with_saving_a_symbol { } {
 436     global CC
 437     global STRIP
 438     global STRIPFLAGS
 439     global NM
 440     global NMFLAGS
 441     global srcdir
 442     global subdir
 443
 444     set test "strip with saving a symbol"
 445
 446     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 447         untested $test
 448         return
 449     }
 450
 451     if [is_remote host] {
 452         set objfile [remote_download host tmpdir/testprog.o]
 453     } else {
 454         set objfile tmpdir/testprog.o
 455     }
 456
 457     set exec_output [binutils_run $STRIP "$STRIPFLAGS -K main -K _main $objfile"]
 458     if ![string match "" $exec_output] {
 459         fail $test
 460         return
 461     }
 462
 463     set exec_output [binutils_run $NM "$NMFLAGS $objfile"]
 464     if {![regexp {^([0-9a-fA-F]+)?[ ]+[TD] main} $exec_output] \
 465          && ![regexp {^([0-9a-fA-F]+)?[ ]+T _main} $exec_output]} {
 466         fail $test
 467         return
 468     }
 469
 470     pass $test
 471 }
 472
 473 strip_test_with_saving_a_symbol
 474
 475 # Build a final executable.
 476
 477 if { [istarget *-*-cygwin] || [istarget *-*-mingw*] } {
 478     set test_prog "testprog.exe"
 479 } else {
 480     set test_prog "testprog"
 481 }
 482
 483 proc copy_setup { } {
 484     global srcdir
 485     global subdir
 486     global gcc_gas_flag
 487     global test_prog
 488     global host_triplet
 489
 490     set res [build_wrapper testglue.o]
 491     set flags { debug }
 492
 493     if { [istarget *-*-uclinux*] } {
 494         return 1
 495     }
 496
 497     if { $res != "" } {
 498         lappend flags "additional_flags=[lindex $res 1]"
 499         set add_libs "testglue.o"
 500     } else {
 501         set add_libs ""
 502     }
 503
 504     if { [istarget *-*-linux*] } {
 505         foreach i $gcc_gas_flag {
 506             set flags "additional_flags=$i $flags"
 507         }
 508     }
 509     if { [target_compile "$srcdir/$subdir/testprog.c $add_libs" tmpdir/$test_prog executable $flags]  != "" } {
 510         return 2
 511     }
 512
 513     set result [remote_load target tmpdir/$test_prog]
 514     set status [lindex $result 0]
 515
 516     if { $status != "pass"  } {
 517         send_log "cannot run executable, status = ${status} on ${host_triplet}\n"
 518         if { [istarget $host_triplet] } {
 519           return 3
 520         }
 521       set status "pass"
 522     }
 523
 524     return 0
 525 }
 526
 527 # Test copying an executable.
 528
 529 proc copy_executable { prog flags test1 test2 } {
 530     global test_prog
 531     global host_triplet
 532
 533     if [is_remote host] {
 534         set testfile [remote_download host tmpdir/$test_prog]
 535         set testcopy copyprog
 536     } else {
 537         set testfile tmpdir/$test_prog
 538         set testcopy tmpdir/copyprog
 539     }
 540     remote_file host delete $testcopy
 541
 542     set exec_output [binutils_run $prog "$flags $testfile $testcopy"]
 543
 544     if ![string match "" $exec_output] {
 545         fail $test1
 546         if [string match "" $test2] {
 547             return
 548         }
 549         fail $test2
 550         return
 551     }
 552
 553     if [is_remote host] {
 554         remote_upload host $testcopy tmpdir/copyprog
 555     }
 556
 557     set status [remote_exec build "cmp" "tmpdir/$test_prog tmpdir/copyprog"]
 558     set exec_output [lindex $status 1]
 559
 560     if [string match "" $exec_output] then {
 561         pass $test1
 562     } else {
 563         send_log "$exec_output\n"
 564         verbose "$exec_output"
 565
 566         # This will fail for many reasons.  For example, it will most
 567         # likely fail if a non-GNU linker is used.  Therefore, we do
 568         # not insist that it pass.  If you are using an assembler and
 569         # linker based on the same BFD as objcopy, it is worth
 570         # investigating to see why this failure occurs.  If we are
 571         # cross compiling, we assume that a GNU linker is being used,
 572         # and expect it to succeed.
 573         if {[isnative]} then {
 574             setup_xfail "*-*-*"
 575         }
 576
 577         # This also fails for mips*-*-elf targets.  See elf32-mips.c
 578         # mips_elf_sym_is_global.
 579         setup_xfail "mips*-*-elf"
 580
 581         setup_xfail "*arm*-*-coff"
 582         setup_xfail "xscale-*-coff"
 583         setup_xfail "arm*-*-pe"
 584         setup_xfail "thumb*-*-coff"
 585         setup_xfail "thumb*-*-pe"
 586         setup_xfail "*-*-mingw*"
 587         setup_xfail "*-*-cygwin*"
 588
 589         fail $test1
 590     }
 591
 592     if [string match "" $test2] {
 593         return
 594     }
 595
 596     set output [remote_load target tmpdir/copyprog]
 597     set status [lindex $output 0]
 598     if { ![istarget $host_triplet] } {
 599       set status "pass"
 600     }
 601     if { $status != "pass" } {
 602         fail $test2
 603     } else {
 604         pass $test2
 605     }
 606 }
 607
 608 # Test stripping an executable
 609
 610 proc strip_executable { prog flags test } {
 611     global NM
 612     global NMFLAGS
 613     global host_triplet
 614
 615     remote_file build delete tmpdir/striprog
 616     remote_download build tmpdir/copyprog tmpdir/striprog
 617     if [is_remote host] {
 618         set copyfile [remote_download host tmpdir/striprog]
 619     } else {
 620         set copyfile tmpdir/striprog
 621     }
 622
 623     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 624     if ![string match "" $exec_output] {
 625         fail $test
 626         return
 627     }
 628
 629     if [is_remote host] {
 630         remote_upload host ${copyfile} tmpdir/striprog
 631     }
 632
 633     set result [remote_load target tmpdir/striprog]
 634     set status [lindex $result 0]
 635     if { ![istarget $host_triplet] } {
 636       set status "pass"
 637     }
 638     if { $status != "pass" } {
 639         fail $test
 640         return
 641     }
 642
 643     set exec_output [binutils_run $NM "$NMFLAGS ${copyfile}"]
 644     if ![string match "*: no symbols*" $exec_output] {
 645         fail $test
 646         return
 647     }
 648     pass $test
 649 }
 650
 651 # Test stripping an executable with saving a symbol
 652
 653 proc strip_executable_with_saving_a_symbol { prog flags test } {
 654     global NM
 655     global NMFLAGS
 656     global host_triplet
 657
 658     remote_file build delete tmpdir/striprog
 659     remote_download build tmpdir/copyprog tmpdir/striprog
 660     if [is_remote host] {
 661         set copyfile [remote_download host tmpdir/striprog]
 662     } else {
 663         set copyfile tmpdir/striprog
 664     }
 665
 666     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 667     if ![string match "" $exec_output] {
 668         fail $test
 669         return
 670     }
 671
 672     if [is_remote host] {
 673         remote_upload host ${copyfile} tmpdir/striprog
 674     }
 675
 676     set result [remote_load target tmpdir/striprog]
 677     set status [lindex $result 0]
 678     if { ![istarget $host_triplet] } {
 679       set status "pass"
 680     }
 681     if { $status != "pass" } {
 682         fail $test
 683         return
 684     }
 685
 686     set exec_output [binutils_run $NM "$NMFLAGS ${copyfile}"]
 687     if { [istarget mmix-knuth-mmixware] } {
 688         # Whenever there's a symbol in the mmo format, there's the symbol
 689         # Main, so remove it manually from the expected output for sake of
 690         # this test.
 691
 692         # Using "" not {} to get the \n and \r translated.
 693         regsub "^\[0-9a-fA-F\]+\[ \]+T Main\[\n\r\]+" $exec_output "" exec_output
 694     }
 695
 696     if {![regexp {^([0-9a-fA-F]+)?[ ]+[TD] main} $exec_output] \
 697          && ![regexp {^([0-9a-fA-F]+)?[ ]+[TD] _main} $exec_output]} {
 698         fail $test
 699         return
 700     }
 701     pass $test
 702 }
 703
 704 # Test keeping only debug symbols of an executable
 705
 706 proc keep_debug_symbols_and_test_copy { prog1 flags1 test1 prog2 flags2 test2 } {
 707     global NM
 708     global NMFLAGS
 709
 710     remote_file build delete tmpdir/striprog
 711     remote_download build tmpdir/copyprog tmpdir/striprog
 712     if [is_remote host] {
 713         set copyfile [remote_download host tmpdir/striprog]
 714     } else {
 715         set copyfile tmpdir/striprog
 716     }
 717
 718     set exec_output [binutils_run $prog1 "$flags1 ${copyfile}"]
 719     if ![string match "" $exec_output] {
 720         fail $test1
 721         return
 722     }
 723     pass $test1
 724
 725     set exec_output [binutils_run $prog2 "$flags2 ${copyfile}"]
 726     if ![string match "" $exec_output] {
 727         fail $test2
 728         return
 729     }
 730     pass $test2
 731 }
 732
 733 set test1 "simple objcopy of executable"
 734 set test2 "run objcopy of executable"
 735 set test3 "run stripped executable"
 736 set test4 "run stripped executable with saving a symbol"
 737 set test5 "keep only debug data"
 738 set test6 "simple objcopy of debug data"
 739
 740 switch [copy_setup] {
 741     "1" {
 742         # do nothing
 743     }
 744     "2" {
 745         untested $test1
 746         untested $test2
 747         untested $test3
 748         untested $test4
 749         untested $test5
 750         untested $test6
 751     }
 752     "3" {
 753         copy_executable "$OBJCOPY" "$OBJCOPYFLAGS" "$test1" ""
 754         unsupported $test2
 755         unsupported $test3
 756         unsupported $test4
 757         unsupported $test5
 758         unsupported $test6
 759     }
 760     "0" {
 761         copy_executable "$OBJCOPY" "$OBJCOPYFLAGS" "$test1" "$test2"
 762         strip_executable "$STRIP" "$STRIPFLAGS" "$test3"
 763         strip_executable_with_saving_a_symbol "$STRIP" "-K main -K _main $STRIPFLAGS" "$test4"
 764         keep_debug_symbols_and_test_copy "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test5" \
 765                                          "$OBJCOPY" "$OBJCOPYFLAGS" "$test6"
 766     }
 767 }
 768
 769 proc objcopy_test_readelf {testname srcfile} {
 770     global OBJCOPY
 771     global OBJCOPYFLAGS
 772     global READELF
 773     global srcdir
 774     global subdir
 775
 776     if {![binutils_assemble $srcdir/$subdir/${srcfile} tmpdir/bintest.o]} then {
 777         unresolved "objcopy ($testname)"
 778         return
 779     }
 780
 781     verbose -log "$OBJCOPY $OBJCOPYFLAGS tmpdir/bintest.o tmpdir/copy.o"
 782     set exec_output [remote_exec host "$OBJCOPY $OBJCOPYFLAGS tmpdir/bintest.o tmpdir/copy.o"]
 783     if { [lindex $exec_output 0] != 0
 784          || ![string match "" [lindex $exec_output 1]] } then {
 785         fail "objcopy ($testname)"
 786         return
 787     }
 788
 789     verbose -log "$READELF -a tmpdir/bintest.o > tmpdir/bintest.o.out"
 790     set exec_output [remote_exec host "$READELF -a tmpdir/bintest.o" "" "/dev/null" "tmpdir/bintest.o.out"]
 791     if { [lindex $exec_output 0] != 0 } then {
 792         unresolved "objcopy ($testname)"
 793         return
 794     }
 795     set exec_output [prune_warnings [lindex $exec_output 1]]
 796     if ![string match "" $exec_output] then {
 797         unresolved "objcopy ($testname)"
 798         return
 799     }
 800
 801     verbose -log "$READELF -a tmpdir/copy.o > tmpdir/copy.o.out"
 802     set exec_output [remote_exec host "$READELF -a tmpdir/copy.o" "" "/dev/null" "tmpdir/copy.o.out"]
 803     if { [lindex $exec_output 0] != 0 } then {
 804         unresolved "objcopy ($testname)"
 805         return
 806     }
 807     set exec_output [prune_warnings [lindex $exec_output 1]]
 808     if ![string match "" $exec_output] then {
 809         unresolved "objcopy ($testname)"
 810         return
 811     }
 812
 813     verbose -log "diff tmpdir/bintest.o.out tmpdir/copy.o.out"
 814     catch "exec diff tmpdir/bintest.o.out tmpdir/copy.o.out" exec_output
 815     set exec_output [prune_warnings $exec_output]
 816
 817     if [string match "" $exec_output] then {
 818         pass "objcopy ($testname)"
 819     } else {
 820         fail "objcopy ($testname)"
 821     }
 822 }
 823
 824 # ia64 specific tests
 825 if { ([istarget "ia64-*-elf*"]
 826        || [istarget "ia64-*-linux*"]) } {
 827     objcopy_test "ia64 link order" link-order.s
 828 }
 829
 830 # ELF specific tests
 831 if [is_elf_format] {
 832     objcopy_test "ELF unknown section type" unknown.s
 833     objcopy_test_readelf "ELF group" group.s
 834     objcopy_test_readelf "ELF group" group-2.s
 835     objcopy_test_readelf "ELF group" group-3.s
 836     objcopy_test_readelf "ELF group" group-4.s
 837     run_dump_test "group-5"
 838     run_dump_test "copy-1"
 839     run_dump_test "note-1"
 840 }
 841
 842 run_dump_test "copy-2"
 843 run_dump_test "copy-3"
 844 run_dump_test "copy-4"
 845
 846 if [is_elf_format] {
 847     run_dump_test "strip-1"
 848     run_dump_test "strip-2"
 849     run_dump_test "strip-3"
 850     run_dump_test "strip-4"
 851     run_dump_test "strip-5"
 852     run_dump_test "strip-6"
 853     run_dump_test "strip-7"
 854     run_dump_test "strip-8"
 855     run_dump_test "strip-9"
 856     run_dump_test "strip-10"
 857
 858     if { [istarget "i*86-*"] || [istarget "x86_64-*-*"] } {
 859         # Check to make sure we don't strip a symbol named in relocations.
 860         set test "objcopy keeps symbols needed by relocs"
 861
 862         set srcfile $srcdir/$subdir/needed-by-reloc.s
 863
 864         if {![binutils_assemble $srcfile tmpdir/bintest.o]} then {
 865             unresolved $test
 866         } else {
 867             set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS --strip-symbol=foo tmpdir/bintest.o ${copyfile}.o"]
 868
 869             if [regexp "not stripping symbol `foo' because it is named in a relocation" $got] {
 870                 pass $test
 871             } else {
 872                 fail $test
 873             }
 874         }
 875     }
 876
 877     run_dump_test "localize-hidden-1"
 878     run_dump_test "testranges"
 879     run_dump_test "testranges-ia64"
 880
 881     run_dump_test "add-section"
 882     run_dump_test "add-empty-section"
 883
 884     run_dump_test "exclude-1a"
 885     run_dump_test "exclude-1b"
 886 }
 887 run_dump_test "localize-hidden-2"