binutils/testsuite/binutils-all/objcopy.exp

   1 #   Copyright (C) 1994-2018 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, write to the Free Software
  15 # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  16
  17 # Please email any bugs, comments, and/or additions to this file to:
  18 # bug-dejagnu@prep.ai.mit.edu
  19
  20 # Written by Ian Lance Taylor <ian@cygnus.com>
  21
  22 if ![is_remote host] {
  23     if {[which $OBJCOPY] == 0} then {
  24         perror "$OBJCOPY does not exist"
  25         return
  26     }
  27 }
  28
  29 send_user "Version [binutil_version $OBJCOPY]"
  30
  31 if ![is_remote host] {
  32     set tempfile tmpdir/bintest.o
  33     set copyfile tmpdir/copy
  34 } else {
  35     set tempfile [remote_download host tmpdir/bintest.o]
  36     set copyfile copy
  37 }
  38
  39 # Test that objcopy does not modify a file when copying it.
  40
  41 proc objcopy_test {testname srcfile} {
  42     global OBJCOPY
  43     global OBJCOPYFLAGS
  44     global srcdir
  45     global subdir
  46     global tempfile
  47     global copyfile
  48
  49     if {![binutils_assemble $srcdir/$subdir/${srcfile} $tempfile]} then {
  50         unresolved "objcopy ($testname)"
  51         remote_file host delete $tempfile
  52         return
  53     }
  54
  55     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS $tempfile ${copyfile}.o"]
  56
  57     if ![string equal "" $got] then {
  58         fail "objcopy ($testname)"
  59     } else {
  60         send_log "cmp $tempfile ${copyfile}.o\n"
  61         verbose "cmp $tempfile ${copyfile}.o"
  62         if [is_remote host] {
  63             set src1 tmpdir/bintest.o
  64             set src2 tmpdir/copy.o
  65             remote_upload host $tempfile $src1
  66             remote_upload host ${copyfile}.o $src2
  67         } else {
  68             set src1 ${tempfile}
  69             set src2 ${copyfile}.o
  70         }
  71         set status [remote_exec build cmp "${src1} ${src2}"]
  72         set exec_output [lindex $status 1]
  73         set exec_output [prune_warnings $exec_output]
  74
  75         # On some systems the result of objcopy will not be identical.
  76         # Usually this is just because gas isn't using bfd to write the
  77         # files in the first place, and may order things a little
  78         # differently. Those systems should use setup_xfail here.
  79
  80         setup_xfail "hppa*-*-*"
  81         setup_xfail "m8*-*"
  82         setup_xfail "sh-*-coff*"
  83         setup_xfail "tic80-*-*"
  84
  85         clear_xfail "hppa*64*-*-hpux*" "hppa*-*-linux*" "hppa*-*-lites*"
  86         clear_xfail "hppa*-*-*n*bsd*" "hppa*-*-rtems*" "*-*-*elf*"
  87
  88         if [string equal "" $exec_output] then {
  89             pass "objcopy ($testname)"
  90         } else {
  91             send_log "$exec_output\n"
  92             verbose "$exec_output" 1
  93
  94             # On OSF/1, this succeeds with gas and fails with /bin/as.
  95             setup_xfail "alpha*-*-osf*"
  96
  97             fail "objcopy ($testname)"
  98         }
  99     }
 100 }
 101
 102 objcopy_test "simple copy" bintest.s
 103
 104 if { [file exists $tempfile] } {
 105     # Test reversing bytes in a section.
 106
 107     set reversed ${tempfile}-reversed
 108     set sect_names [get_standard_section_names]
 109     if { $sect_names != "" } {
 110         set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -j [lindex $sect_names 1] --reverse-bytes=4 $tempfile $reversed"]
 111     } else {
 112         set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -j .data --reverse-bytes=4 $tempfile $reversed"]
 113     }
 114
 115     if ![string equal "" $got] then {
 116         fail "objcopy --reverse-bytes"
 117     } else {
 118         if [is_remote host] {
 119             remote_upload host ${reversed} tmpdir/copy-reversed.o
 120             set reversed tmpdir/copy-reversed.o
 121         }
 122
 123         set origdata [binutils_run $OBJDUMP "$OBJDUMPFLAGS -s -j .data $tempfile"]
 124         set  revdata [binutils_run $OBJDUMP "$OBJDUMPFLAGS -s -j .data $reversed"]
 125
 126         set want "^ \[0-9\]+ (\[0-9\]+)"
 127         set found_orig [regexp -lineanchor $want $origdata -> origdata]
 128         set found_rev [regexp -lineanchor $want $revdata -> revdata]
 129
 130         if {$found_orig == 0 || $found_rev == 0} then {
 131             # som doesn't have a .data section
 132             setup_xfail "hppa*-*-hpux*"
 133             clear_xfail "hppa*64*-*-hpux*"
 134
 135             fail "objcopy --reverse-bytes"
 136         } else {
 137             scan $origdata "%2x%2x%2x%2x" b1 b2 b3 b4
 138             scan $revdata "%2x%2x%2x%2x" c4 c3 c2 c1
 139
 140             if {$b1 == $c1 && $b2 == $c2 && $b3 == $c3 && $b4 == $c4} then {
 141                 pass "objcopy --reverse-bytes"
 142             } else {
 143                 fail "objcopy --reverse-bytes"
 144             }
 145         }
 146     }
 147 }
 148
 149 # Test interleaved copy of multiple byte width
 150
 151 set sequence_file sequence_file
 152 set file [open ${sequence_file} w]
 153 puts ${file} "12345678"
 154 close ${file}
 155
 156 if [is_remote host] {
 157     remote_upload host ${sequence_file} tmpdir/sequence_file
 158     set sequence_file tmpdir/sequence_file
 159 }
 160
 161 set got [binutils_run $OBJCOPY "-I binary -i 4 -b 0 --interleave-width 2 ${sequence_file} ${copyfile}"]
 162
 163 if ![string equal "" $got] then {
 164     fail "objcopy -i --interleave-width"
 165 } else {
 166     if [is_remote host] {
 167         remote_upload host ${copyfile} tmpdir/interleave_output
 168         set interleave_output tmpdir/interleave_output
 169     } else {
 170         set interleave_output ${copyfile}
 171     }
 172
 173     set file [open ${interleave_output} r]
 174     gets $file line
 175     send_log "$line\n"
 176     verbose $line
 177
 178     if ![string equal "1256" $line] then {
 179         fail "objcopy -i --interleave-width"
 180     }
 181     pass "objcopy -i --interleave-width"
 182
 183     close $file
 184 }
 185
 186 # Test generating S records.
 187
 188 if { [file exists $tempfile] } {
 189     # We make the srec filename 8.3 compatible. Note that the header string
 190     # matched against depends on the name of the file. Ugh.
 191
 192     if [is_remote host] {
 193         set srecfile copy.sre
 194         set header_string S00B0000636F70792E737265C1
 195     } else {
 196         set srecfile ${copyfile}.srec
 197         set header_string S0130000746D706469722F636F70792E7372656397
 198     }
 199
 200     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $tempfile ${srecfile}"]
 201
 202     if ![string equal "" $got] then {
 203         fail "objcopy -O srec"
 204     } else {
 205         if [is_remote host] {
 206             remote_upload host ${srecfile} tmpdir/copy.srec
 207             set srecfile tmpdir/copy.srec
 208         }
 209         set file [open ${srecfile} r]
 210
 211         # The first S record is fixed by the file name we are using.
 212         gets $file line
 213         send_log "$line\n"
 214         verbose $line
 215         if ![regexp "$header_string.*" $line] {
 216             send_log "bad header\n"
 217             fail "objcopy -O srec"
 218         } else {
 219             while {[gets $file line] != -1 \
 220                        && [regexp "^S\[123\]\[0-9a-fA-F\]+\[\r\n\]*$" $line]} {
 221                 send_log "$line\n"
 222                 verbose $line
 223                 set line "**EOF**"
 224             }
 225             send_log "$line\n"
 226             verbose $line
 227             if ![regexp "^S\[789\]\[0-9a-fA-F\]+\[\r\n\]*$" $line] then {
 228                 send_log "bad trailer\n"
 229                 fail "objcopy -O srec"
 230             } else {
 231                 if {[gets $file line] != -1} then {
 232                     send_log "garbage at end\n"
 233                     send_log "$line\n"
 234                     verbose $line
 235                     fail "objcopy -O srec"
 236                 } else {
 237                     set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${srecfile}"]
 238                     if ![regexp "file format srec" $got] then {
 239                         send_log "objdump failed\n"
 240                         fail "objcopy -O srec"
 241                     } else {
 242                         pass "objcopy -O srec"
 243                     }
 244                 }
 245             }
 246         }
 247
 248         close $file
 249     }
 250 }
 251
 252 # Test setting and adjusting the start address.  We only test this
 253 # while generating S records, because we may not be able to set the
 254 # start address for other object file formats, and the S record case
 255 # is the only useful one anyhow.
 256
 257 set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f $tempfile"]
 258 if ![regexp "start address (\[0-9a-fA-FxX\]+)" $got all origstart] then {
 259     perror "objdump can not recognize bintest.o"
 260     set origstart ""
 261 } else {
 262     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --set-start 0x7654 $tempfile ${copyfile}.srec"]
 263     if ![string equal "" $got] then {
 264         fail "objcopy --set-start"
 265     } else {
 266         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${copyfile}.srec"]
 267         if ![regexp "file format srec.*start address (\[0-9a-fA-FxX\]+)" $got all srecstart] then {
 268             fail "objcopy --set-start"
 269         } else {
 270             if {$srecstart != 0x7654} then {
 271                 send_log "$srecstart != 0x7654\n"
 272                 fail "objcopy --set-start"
 273             } else {
 274                 pass "objcopy --set-start"
 275             }
 276         }
 277     }
 278
 279     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --adjust-start 0x123 $tempfile ${copyfile}.srec"]
 280     if ![string equal "" $got] then {
 281         fail "objcopy --adjust-start"
 282     } else {
 283         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${copyfile}.srec"]
 284         if ![regexp "file format srec.*start address (\[0-9a-fA-FxX\]+)" $got all srecstart] then {
 285             fail "objcopy --adjust-start"
 286         } else {
 287             if {$srecstart != $origstart + 0x123} then {
 288                 send_log "$srecstart != $origstart + 0x123\n"
 289                 fail "objcopy --adjust-start"
 290             } else {
 291                 pass "objcopy --adjust-start"
 292             }
 293         }
 294     }
 295 }
 296
 297 # Test adjusting the overall VMA, and adjusting the VMA of a
 298 # particular section.  We again only test this when generating S
 299 # records.
 300
 301 set low ""
 302 set lowname ""
 303
 304 set headers [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h $tempfile"]
 305
 306 set headers_regexp "\[  0-9\]+(\[^      \]+)\[  \]*(\[0-9a-fA-F\]+)\[   \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)\[   \]+\[0-9a-fA-F\]+\[     \]+2\[*\]\[*\]\[0-9\]+(.*)"
 307
 308 set got $headers
 309 while {[regexp $headers_regexp $got all name size vma rest]} {
 310     set vma 0x$vma
 311     set size 0x$size
 312     if {$size != 0} {
 313         if {$low == "" || $vma < $low} {
 314             set low $vma
 315             set lowname $name
 316         }
 317     }
 318     set got $rest
 319 }
 320
 321 if {$low == "" || $origstart == ""} then {
 322     perror "objdump can not recognize bintest.o"
 323 } else {
 324     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --adjust-vma 0x123 $tempfile ${copyfile}.srec"]
 325     if ![string equal "" $got] then {
 326         fail "objcopy --adjust-vma"
 327     } else {
 328         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -fh ${copyfile}.srec"]
 329         set want "file format srec.*start address\[     \]*(\[0-9a-fA-FxX\]+).*sec1\[   \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 330         if ![regexp $want $got all start vma] then {
 331             fail "objcopy --adjust-vma"
 332         } else {
 333             set vma 0x$vma
 334             if {$vma != $low + 0x123} then {
 335                 send_log "$vma != $low + 0x123\n"
 336                 fail "objcopy --adjust-vma"
 337             } else {
 338                 if {$start != $origstart + 0x123} then {
 339                     send_log "$start != $origstart + 0x123\n"
 340                     fail "objcopy --adjust-vma"
 341                 } else {
 342                     pass "objcopy --adjust-vma"
 343                 }
 344             }
 345         }
 346     }
 347
 348     set arg ""
 349     set got $headers
 350     while {[regexp $headers_regexp $got all name size vma rest]} {
 351         set vma 0x$vma
 352         if {$vma == $low} then {
 353             set arg "$arg --adjust-section-vma $name+4"
 354         }
 355         set got $rest
 356     }
 357
 358     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $arg $tempfile ${copyfile}.srec"]
 359     if ![string equal "" $got] then {
 360         fail "objcopy --adjust-section-vma +"
 361     } else {
 362         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h ${copyfile}.srec"]
 363         set want "file format srec.*sec1\[      \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 364         if ![regexp $want $got all vma] then {
 365             fail "objcopy --adjust-section-vma +"
 366         } else {
 367             set vma 0x$vma
 368             if {$vma != $low + 4} then {
 369                 send_log "$vma != $low + 4\n"
 370                 fail "objcopy --adjust-section-vma +"
 371             } else {
 372                 pass "objcopy --adjust-section-vma +"
 373             }
 374         }
 375     }
 376
 377     regsub -all "\\+4" $arg "=[expr $low + 4]" argeq
 378     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $argeq $tempfile ${copyfile}.srec"]
 379     if ![string equal "" $got] then {
 380         fail "objcopy --adjust-section-vma ="
 381     } else {
 382         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h ${copyfile}.srec"]
 383         set want "file format srec.*sec1\[      \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 384         if ![regexp $want $got all vma] then {
 385             fail "objcopy --adjust-section-vma ="
 386         } else {
 387             set vma 0x$vma
 388             if {$vma != $low + 4} then {
 389                 send_log "$vma != $low + 4\n"
 390                 fail "objcopy --adjust-section-vma ="
 391             } else {
 392                 pass "objcopy --adjust-section-vma ="
 393             }
 394         }
 395     }
 396 }
 397
 398 # Test stripping an object.
 399
 400 proc strip_test { } {
 401     global AR
 402     global CC
 403     global STRIP
 404     global STRIPFLAGS
 405     global NM
 406     global NMFLAGS
 407     global srcdir
 408     global subdir
 409     global READELF
 410
 411     set test "strip"
 412
 413     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 414         untested $test
 415         return
 416     }
 417
 418     set osabi_fail "false"
 419     if [is_elf_format] {
 420         verbose -log "$READELF -a tmpdir/testprog.o > tmpdir/osabi.in"
 421         set exec_output [remote_exec host "$READELF -h tmpdir/testprog.o" "" "/dev/null" "tmpdir/osabi.in"]
 422         if { [lindex $exec_output 0] != 0 } then {
 423             unresolved "$test preserving OS/ABI"
 424             set osabi_fail "true"
 425         } else {
 426             verbose -log "grep OS/ABI tmpdir/osabi.in"
 427             catch "exec grep OS/ABI tmpdir/osabi.in" osabi_in
 428         }
 429     }
 430
 431     if [is_remote host] {
 432         set archive libstrip.a
 433         set objfile [remote_download host tmpdir/testprog.o]
 434         remote_file host delete $archive
 435     } else {
 436         set archive tmpdir/libstrip.a
 437         set objfile tmpdir/testprog.o
 438     }
 439
 440     remote_file build delete tmpdir/libstrip.a
 441
 442     set exec_output [binutils_run $AR "rc $archive ${objfile}"]
 443     if ![string equal "" $exec_output] {
 444         fail $test
 445         unresolved "$test preserving OS/ABI"
 446         return
 447     }
 448
 449     set exec_output [binutils_run $STRIP "-g $archive"]
 450     if ![string equal "" $exec_output] {
 451         fail $test
 452         unresolved "$test preserving OS/ABI"
 453         return
 454     }
 455
 456     set exec_output [binutils_run $STRIP "$STRIPFLAGS $archive"]
 457     if ![string equal "" $exec_output] {
 458         fail $test
 459         unresolved "$test preserving OS/ABI"
 460         return
 461     }
 462
 463     if { $osabi_fail != "true" && [is_elf_format] } {
 464         verbose -log "$READELF -a tmpdir/testprog.o > tmpdir/osabi.out"
 465         set exec_output [remote_exec host "$READELF -h tmpdir/testprog.o" "" "/dev/null" "tmpdir/osabi.out"]
 466         if { [lindex $exec_output 0] != 0 } then {
 467             unresolved "$test preserving OS/ABI"
 468         } else {
 469             verbose -log "grep OS/ABI tmpdir/osabi.out"
 470             catch "exec grep OS/ABI tmpdir/osabi.out" osabi_out
 471             if { "$osabi_in" == "$osabi_out" } {
 472                 pass "$test preserving OS/ABI"
 473             } else {
 474                 fail "$test preserving OS/ABI"
 475             }
 476         }
 477     }
 478
 479     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 480         untested $test
 481         return
 482     }
 483
 484     if [is_remote host] {
 485         set objfile [remote_download host tmpdir/testprog.o]
 486     } else {
 487         set objfile tmpdir/testprog.o
 488     }
 489
 490     set exec_output [binutils_run $STRIP "$STRIPFLAGS $objfile"]
 491     if ![string equal "" $exec_output] {
 492         fail $test
 493         return
 494     }
 495
 496     set exec_output [binutils_run $NM "-a $NMFLAGS $objfile"]
 497     if ![string match "*: no symbols*" $exec_output] {
 498         fail $test
 499         return
 500     }
 501
 502     pass $test
 503 }
 504
 505 strip_test
 506
 507 # Test stripping an object file with saving a symbol
 508
 509 proc strip_test_with_saving_a_symbol { } {
 510     global CC
 511     global STRIP
 512     global STRIPFLAGS
 513     global NM
 514     global NMFLAGS
 515     global srcdir
 516     global subdir
 517
 518     set test "strip with saving a symbol"
 519
 520     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 521         untested $test
 522         return
 523     }
 524
 525     if [is_remote host] {
 526         set objfile [remote_download host tmpdir/testprog.o]
 527     } else {
 528         set objfile tmpdir/testprog.o
 529     }
 530
 531     set exec_output [binutils_run $STRIP "$STRIPFLAGS -K main -K _main $objfile"]
 532     if ![string equal "" $exec_output] {
 533         fail $test
 534         return
 535     }
 536
 537     set exec_output [binutils_run $NM "$NMFLAGS $objfile"]
 538     if {![regexp {^([0-9a-fA-F]+)?[ ]+[TD] main} $exec_output] \
 539          && ![regexp {^([0-9a-fA-F]+)?[ ]+T _main} $exec_output]} {
 540         fail $test
 541         return
 542     }
 543
 544     pass $test
 545 }
 546
 547 strip_test_with_saving_a_symbol
 548
 549 # Build a final executable.
 550
 551 if { [istarget *-*-cygwin] || [istarget *-*-mingw*] } {
 552     set test_prog "testprog.exe"
 553 } else {
 554     set test_prog "testprog"
 555 }
 556
 557 proc copy_setup { } {
 558     global srcdir
 559     global subdir
 560     global gcc_gas_flag
 561     global test_prog
 562     global host_triplet
 563
 564     set res [build_wrapper testglue.o]
 565     set flags { debug }
 566
 567     if { [istarget *-*-uclinux*] && ![istarget tic6x-*-*] && ![istarget arm*-*-uclinuxfdpiceabi] } {
 568         return 1
 569     }
 570
 571     if { $res != "" } {
 572         lappend flags "additional_flags=[lindex $res 1]"
 573         set add_libs "testglue.o"
 574     } else {
 575         set add_libs ""
 576     }
 577
 578     if { [istarget *-*-linux*]
 579          || [istarget *-*-gnu*] } {
 580         foreach i $gcc_gas_flag {
 581             set flags "additional_flags=$i $flags"
 582         }
 583     }
 584     if { [target_compile "$srcdir/$subdir/testprog.c $add_libs" tmpdir/$test_prog executable $flags]  != "" } {
 585         return 2
 586     }
 587
 588     set result [remote_load target tmpdir/$test_prog]
 589     set status [lindex $result 0]
 590
 591     if { $status != "pass"  } {
 592         send_log "cannot run executable, status = ${status} on ${host_triplet}\n"
 593         return 3
 594     }
 595
 596     return 0
 597 }
 598
 599 # Test copying an executable.
 600
 601 proc copy_executable { prog flags test1 test2 } {
 602     global test_prog
 603
 604     if [is_remote host] {
 605         set testfile [remote_download host tmpdir/$test_prog]
 606         set testcopy copyprog
 607     } else {
 608         set testfile tmpdir/$test_prog
 609         set testcopy tmpdir/copyprog
 610     }
 611     remote_file host delete $testcopy
 612
 613     set exec_output [binutils_run $prog "$flags $testfile $testcopy"]
 614
 615     if ![string equal "" $exec_output] {
 616         fail $test1
 617         if [string equal "" $test2] {
 618             return
 619         }
 620         fail $test2
 621         return
 622     }
 623
 624     if [is_remote host] {
 625         remote_upload host $testcopy tmpdir/copyprog
 626     }
 627
 628     set status [remote_exec build "cmp" "tmpdir/$test_prog tmpdir/copyprog"]
 629     set exec_output [lindex $status 1]
 630
 631     if [string equal "" $exec_output] then {
 632         pass $test1
 633     } else {
 634         send_log "$exec_output\n"
 635         verbose "$exec_output"
 636
 637         # This will fail for many reasons.  For example, it will most
 638         # likely fail if a non-GNU linker is used.  Therefore, we do
 639         # not insist that it pass.  If you are using an assembler and
 640         # linker based on the same BFD as objcopy, it is worth
 641         # investigating to see why this failure occurs.  If we are
 642         # cross compiling, we assume that a GNU linker is being used,
 643         # and expect it to succeed.
 644         if {[isnative]} then {
 645             setup_xfail "*-*-*"
 646         }
 647
 648         # This also fails for some mips targets.  See elf32-mips.c
 649         # mips_elf_sym_is_global.
 650         if { [is_bad_symtab] } then {
 651             setup_xfail "*-*-*"
 652         }
 653
 654         setup_xfail "arm*-*-pe"
 655         setup_xfail "*-*-mingw*"
 656         setup_xfail "*-*-cygwin*"
 657
 658         fail $test1
 659     }
 660
 661     if [string equal "" $test2] {
 662         return
 663     }
 664
 665     set output [remote_load target tmpdir/copyprog]
 666     set status [lindex $output 0]
 667     if { $status != "pass" } {
 668         fail $test2
 669     } else {
 670         pass $test2
 671     }
 672 }
 673
 674 # Test stripping an executable
 675
 676 proc strip_executable { prog flags test1 test2 } {
 677     global NM
 678     global NMFLAGS
 679     global READELF
 680
 681     remote_file build delete tmpdir/striprog
 682     remote_download build tmpdir/copyprog tmpdir/striprog
 683     if [is_remote host] {
 684         set copyfile [remote_download host tmpdir/striprog]
 685     } else {
 686         set copyfile tmpdir/striprog
 687     }
 688
 689     set osabi_fail "false"
 690     if [is_elf_format] {
 691         verbose -log "$READELF -a ${copyfile} > tmpdir/osabi.in"
 692         set exec_output [remote_exec host "$READELF -h ${copyfile}" "" "/dev/null" "tmpdir/osabi.in"]
 693         if { [lindex $exec_output 0] != 0 } then {
 694             unresolved "$test1 preserving OS/ABI"
 695             set osabi_fail "true"
 696         } else {
 697             verbose -log "grep OS/ABI tmpdir/osabi.in"
 698             catch "exec grep OS/ABI tmpdir/osabi.in" osabi_in
 699         }
 700      }
 701
 702     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 703     if ![string equal "" $exec_output] {
 704         fail $test1
 705         if [string equal "" $test2] {
 706             return
 707         }
 708         fail $test2
 709         return
 710     }
 711
 712     if [is_remote host] {
 713         remote_upload host ${copyfile} tmpdir/striprog
 714     }
 715
 716     if { $osabi_fail != "true" && [is_elf_format] } {
 717         verbose -log "$READELF -a ${copyfile} > tmpdir/osabi.out"
 718         set exec_output [remote_exec host "$READELF -h ${copyfile}" "" "/dev/null" "tmpdir/osabi.out"]
 719         if { [lindex $exec_output 0] != 0 } then {
 720             unresolved "$test1 preserving OS/ABI"
 721         } else {
 722             verbose -log "grep OS/ABI tmpdir/osabi.out"
 723             catch "exec grep OS/ABI tmpdir/osabi.out" osabi_out
 724             if { "$osabi_in" == "$osabi_out" } {
 725                 pass "$test1 preserving OS/ABI"
 726             } else {
 727                 fail "$test1 preserving OS/ABI"
 728             }
 729         }
 730     }
 731
 732     set exec_output [binutils_run $NM "$NMFLAGS ${copyfile}"]
 733     if ![string match "*: no symbols*" $exec_output] {
 734         fail $test1
 735         return
 736     }
 737
 738     if [string equal "" $test2] {
 739         return
 740     }
 741
 742     set result [remote_load target tmpdir/striprog]
 743     set status [lindex $result 0]
 744     if { $status != "pass" } {
 745         fail $test2
 746         return
 747     }
 748
 749     pass $test2
 750 }
 751
 752 # Test stripping an executable with saving a symbol
 753
 754 proc strip_executable_with_saving_a_symbol { prog flags test1 test2 } {
 755     global NM
 756     global NMFLAGS
 757
 758     remote_file build delete tmpdir/striprog
 759     remote_download build tmpdir/copyprog tmpdir/striprog
 760     if [is_remote host] {
 761         set copyfile [remote_download host tmpdir/striprog]
 762     } else {
 763         set copyfile tmpdir/striprog
 764     }
 765
 766     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 767     if ![string equal "" $exec_output] {
 768         fail $test1
 769         if [string equal "" $test2] {
 770             return
 771         }
 772         fail $test2
 773         return
 774     }
 775
 776     set exec_output [binutils_run $NM "$NMFLAGS ${copyfile}"]
 777     if { [istarget mmix-knuth-mmixware] } {
 778         # Whenever there's a symbol in the mmo format, there's the symbol
 779         # Main, so remove it manually from the expected output for sake of
 780         # this test.
 781
 782         # Using "" not {} to get the \n and \r translated.
 783         regsub "^\[0-9a-fA-F\]+\[ \]+T Main\[\n\r\]+" $exec_output "" exec_output
 784     }
 785
 786     if {![regexp {^([0-9a-fA-F]+)?[ ]+[TD] main} $exec_output] \
 787          && ![regexp {^([0-9a-fA-F]+)?[ ]+[TD] _main} $exec_output]} {
 788         fail $test1
 789         return
 790     }
 791
 792     if [string equal "" $test2] {
 793         return
 794     }
 795
 796     if [is_remote host] {
 797         remote_upload host ${copyfile} tmpdir/striprog
 798     }
 799
 800     set result [remote_load target tmpdir/striprog]
 801     set status [lindex $result 0]
 802     if { $status != "pass" } {
 803         fail $test2
 804         return
 805     }
 806
 807     pass $test2
 808 }
 809
 810 # Test keeping only debug symbols of an executable
 811
 812 proc keep_debug_symbols_and_test_copy { prog1 flags1 test1 prog2 flags2 test2 } {
 813     remote_file build delete tmpdir/striprog
 814     remote_download build tmpdir/copyprog tmpdir/striprog
 815     if [is_remote host] {
 816         set copyfile [remote_download host tmpdir/striprog]
 817     } else {
 818         set copyfile tmpdir/striprog
 819     }
 820
 821     set exec_output [binutils_run $prog1 "$flags1 ${copyfile}"]
 822     if ![string equal "" $exec_output] {
 823         fail $test1
 824         return
 825     }
 826     pass $test1
 827
 828     set exec_output [binutils_run $prog2 "$flags2 ${copyfile}"]
 829     if ![string equal "" $exec_output] {
 830         fail $test2
 831         return
 832     }
 833     pass $test2
 834 }
 835
 836 # Tests that in a debug only copy of a file the sections
 837 # headers whose types have been changed to NOBITS still
 838 # retain their sh_link fields.
 839
 840 proc keep_debug_symbols_and_check_links { prog flags test } {
 841     global READELF
 842
 843     remote_file build delete tmpdir/striprog
 844     remote_download build tmpdir/copyprog tmpdir/striprog
 845     if [is_remote host] {
 846         set copyfile [remote_download host tmpdir/striprog]
 847     } else {
 848         set copyfile tmpdir/striprog
 849     }
 850
 851     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 852     if ![string equal "" $exec_output] {
 853         fail $test
 854         return
 855     }
 856
 857     set got [binutils_run $READELF "-S --wide ${copyfile}"]
 858
 859     set fails 0
 860     # Regexp to match a section with NOBITS type and extract its name and sh_link fields
 861     while {[regexp \
 862                 {[^a-zA-Z]+([a-zA-Z0-9_\.]+)[   ]+NOBITS[       ]+[0-9a-fA-F]+ [0-9a-fA-F]+ [0-9a-fA-F]+ [0-9]+[ A]+([0-9]+)(.*)} \
 863                 $got all name link rest]} {
 864         set sh_link 0x$link
 865         if {$sh_link == 0} {
 866             # Only some NOBITS sections should have a non-zero sh_link field.
 867             # Look for them by name.
 868             verbose "NOBITS section .$name has a 0 sh_link field\n"
 869             switch $name {
 870                 "rela.*"        { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 871                 "rel.*"         { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 872                 "hash"          { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 873                 "gnu_version"   { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 874                 "dynsym"        { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 875                 "gnu.version_r" { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 876                 "dynamic"       { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 877                 "symtab"        { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 878             }
 879         }
 880         set got $rest
 881     }
 882
 883     if {$fails == 0} {
 884         pass $test
 885     } else {
 886         fail $test
 887     }
 888 }
 889
 890
 891 set test1 "simple objcopy of executable"
 892 set test1r "run objcopy of executable"
 893 set test2 "strip executable"
 894 set test2r "run stripped executable"
 895 set test3 "strip executable with saving a symbol"
 896 set test3r "run stripped executable with saving a symbol"
 897 set test4 "keep only debug data"
 898 set test5 "simple objcopy of debug data"
 899 if [is_elf_format] {
 900     set test6 "NOBITS sections retain sh_link field"
 901 }
 902
 903 switch [copy_setup] {
 904     "1" {
 905         # do nothing
 906     }
 907     "2" {
 908         untested $test1
 909         untested $test1r
 910         untested $test2
 911         untested $test2r
 912         untested $test3
 913         untested $test3r
 914         untested $test4
 915         untested $test5
 916         if [is_elf_format] {
 917             untested $test6
 918         }
 919     }
 920     "3" {
 921         copy_executable "$OBJCOPY" "$OBJCOPYFLAGS" "$test1" ""
 922         unsupported $test1r
 923         strip_executable "$STRIP" "$STRIPFLAGS" "$test2" ""
 924         unsupported $test2r
 925         strip_executable_with_saving_a_symbol "$STRIP" "-K main -K _main $STRIPFLAGS" "$test3" ""
 926         unsupported $test3r
 927         keep_debug_symbols_and_test_copy "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test4" \
 928                                          "$OBJCOPY" "$OBJCOPYFLAGS" "$test5"
 929         if [is_elf_format] {
 930             keep_debug_symbols_and_check_links "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test6"
 931         }
 932     }
 933     "0" {
 934         copy_executable "$OBJCOPY" "$OBJCOPYFLAGS" "$test1" "$test1r"
 935         strip_executable "$STRIP" "$STRIPFLAGS" "$test2" "$test2r"
 936         strip_executable_with_saving_a_symbol "$STRIP" "-K main -K _main $STRIPFLAGS" "$test3" "$test3r"
 937         keep_debug_symbols_and_test_copy "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test4" \
 938                                          "$OBJCOPY" "$OBJCOPYFLAGS" "$test5"
 939         if [is_elf_format] {
 940             keep_debug_symbols_and_check_links "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test6"
 941         }
 942     }
 943 }
 944
 945 proc objcopy_test_readelf {testname srcfile} {
 946     global OBJCOPY
 947     global OBJCOPYFLAGS
 948     global READELF
 949     global srcdir
 950     global subdir
 951
 952     if {![binutils_assemble $srcdir/$subdir/${srcfile} tmpdir/bintest.o]} then {
 953         unresolved "objcopy ($testname)"
 954         return
 955     }
 956
 957     verbose -log "$OBJCOPY $OBJCOPYFLAGS tmpdir/bintest.o tmpdir/copy.o"
 958     set exec_output [remote_exec host "$OBJCOPY $OBJCOPYFLAGS tmpdir/bintest.o tmpdir/copy.o"]
 959     if { [lindex $exec_output 0] != 0
 960          || ![string equal "" [lindex $exec_output 1]] } then {
 961         fail "objcopy ($testname)"
 962         return
 963     }
 964
 965     verbose -log "$READELF -a tmpdir/bintest.o > tmpdir/bintest.o.out"
 966     set exec_output [remote_exec host "$READELF -a tmpdir/bintest.o" "" "/dev/null" "tmpdir/bintest.o.out"]
 967     if { [lindex $exec_output 0] != 0 } then {
 968         unresolved "objcopy ($testname)"
 969         return
 970     }
 971     set exec_output [prune_warnings [lindex $exec_output 1]]
 972     if ![string equal "" $exec_output] then {
 973         unresolved "objcopy ($testname)"
 974         return
 975     }
 976
 977     verbose -log "$READELF -a tmpdir/copy.o > tmpdir/copy.o.out"
 978     set exec_output [remote_exec host "$READELF -a tmpdir/copy.o" "" "/dev/null" "tmpdir/copy.o.out"]
 979     if { [lindex $exec_output 0] != 0 } then {
 980         unresolved "objcopy ($testname)"
 981         return
 982     }
 983     set exec_output [prune_warnings [lindex $exec_output 1]]
 984     if ![string equal "" $exec_output] then {
 985         unresolved "objcopy ($testname)"
 986         return
 987     }
 988
 989     verbose -log "diff tmpdir/bintest.o.out tmpdir/copy.o.out"
 990     catch "exec diff tmpdir/bintest.o.out tmpdir/copy.o.out" exec_output
 991     set exec_output [prune_warnings $exec_output]
 992
 993     if [string equal "" $exec_output] then {
 994         pass "objcopy ($testname)"
 995     } else {
 996         fail "objcopy ($testname)"
 997     }
 998 }
 999
1000 proc objcopy_test_symbol_manipulation {} {
1001     global srcdir
1002     global subdir
1003
1004     set test_list [lsort [glob -nocomplain $srcdir/$subdir/symbols-*.d]]
1005     foreach t $test_list {
1006         # We need to strip the ".d", but can leave the dirname.
1007         verbose [file rootname $t]
1008         run_dump_test [file rootname $t]
1009     }
1010 }
1011
1012 proc objcopy_test_elf_common_symbols {} {
1013     global srcdir
1014     global subdir
1015
1016     # hpux has a non-standard common directive.
1017     if { [istarget "*-*-hpux*"] } then {
1018         return
1019     }
1020
1021     set test_list [lsort [glob -nocomplain $srcdir/$subdir/common-*.d]]
1022     foreach t $test_list {
1023         # We need to strip the ".d", but can leave the dirname.
1024         verbose [file rootname $t]
1025         run_dump_test [file rootname $t]
1026     }
1027 }
1028
1029 # ia64 specific tests
1030 if { ([istarget "ia64-*-elf*"]
1031        || [istarget "ia64-*-linux*"]) } {
1032     objcopy_test "ia64 link order" link-order.s
1033 }
1034
1035 # ELF specific tests
1036 if [is_elf_format] {
1037     objcopy_test_symbol_manipulation
1038     objcopy_test_elf_common_symbols
1039     objcopy_test "ELF unknown section type" unknown.s
1040     objcopy_test_readelf "ELF group" group.s
1041     objcopy_test_readelf "ELF group" group-2.s
1042     objcopy_test_readelf "ELF group" group-3.s
1043     objcopy_test_readelf "ELF group" group-4.s
1044     objcopy_test_readelf "GNU_MBIND section" mbind1.s
1045     run_dump_test "group-5"
1046     run_dump_test "group-6"
1047     run_dump_test "group-7a"
1048     run_dump_test "group-7b"
1049     run_dump_test "group-7c"
1050     run_dump_test "copy-1"
1051     run_dump_test "note-1"
1052     if [is_elf64 tmpdir/bintest.o] {
1053         run_dump_test "note-2-64"
1054         run_dump_test "note-3-64"
1055         run_dump_test "note-4-64"
1056     } else {
1057         run_dump_test "note-2-32"
1058         run_dump_test "note-3-32"
1059         run_dump_test "note-4-32"
1060     }
1061     run_dump_test "note-5"
1062 }
1063
1064 run_dump_test "copy-2"
1065 run_dump_test "copy-3"
1066 run_dump_test "copy-4"
1067 run_dump_test "pr19020a"
1068 run_dump_test "pr19020b"
1069
1070 if [is_elf_format] {
1071     run_dump_test "strip-1"
1072     run_dump_test "strip-2"
1073     run_dump_test "strip-3"
1074     run_dump_test "strip-4"
1075     run_dump_test "strip-5"
1076     run_dump_test "strip-6"
1077     run_dump_test "strip-7"
1078     run_dump_test "strip-8"
1079     run_dump_test "strip-9"
1080     run_dump_test "strip-12"
1081
1082     if { [istarget "mips64*-*-openbsd*"] } {
1083         set reloc_format mips64
1084     } elseif { ([istarget "arm*-*"] \
1085                 && ![istarget "*-*-vxworks"] \
1086                 && ![istarget "*-*-windiss"]) \
1087                || [istarget "d10v-*"] \
1088                || [istarget "dlx-*"] \
1089                || [istarget "i*86-*"] \
1090                || [istarget "m681*-*"] \
1091                || [istarget "m68hc1*-*"] \
1092                || ([istarget "mips*-*"] \
1093                    && ![istarget "mips64*-ps2-elf*"] \
1094                    && ![istarget "*-*-irix6*"] \
1095                    && ![istarget "mips64*-*-freebsd*"] \
1096                    && ![istarget "mips64*-*-kfreebsd*-gnu"] \
1097                    && ![istarget "mips64*-*-linux*"]) \
1098                || [istarget "score*-*"] \
1099                || [istarget "xgate-*"] } {
1100         set reloc_format rel
1101     } else {
1102         set reloc_format rela
1103     }
1104     run_dump_test "strip-13" [list [list source strip-13${reloc_format}.s]]
1105     # Select a relocation number that corresponds to one actually
1106     # supported by the target and ABI being tested.
1107     if { [istarget "aarch64*-*"] } {
1108         set reloc 259
1109     } elseif { [istarget "ia64*-*"] \
1110                || [istarget "m32r*-*"] \
1111                || [istarget "nds32*-*"] \
1112                || [istarget "v850*-*"] } {
1113         set reloc 50
1114     } elseif { [istarget "pru-*"] } {
1115         set reloc 11
1116     } else {
1117         set reloc 1
1118     }
1119     run_dump_test "strip-14" [list \
1120                                 [list source strip-14${reloc_format}.s] \
1121                                 [list as "--defsym RELOC=${reloc}"] \
1122                                 [list as [expr {[is_elf64 tmpdir/bintest.o] \
1123                                     ? "--defsym ELF64=1" : ""}]]]
1124     run_dump_test "strip-15" [list \
1125                                 [list source strip-15${reloc_format}.s] \
1126                                 [list as "--defsym RELOC=${reloc}"] \
1127                                 [list as [expr {[is_elf64 tmpdir/bintest.o] \
1128                                     ? "--defsym ELF64=1" : ""}]]]
1129
1130     # This requires STB_GNU_UNIQUE support with OSABI set to GNU.
1131     if { [supports_gnu_unique] } {
1132         run_dump_test "strip-10"
1133     }
1134     run_dump_test "strip-11"
1135
1136     if { [istarget "i*86-*"] || [istarget "x86_64-*-*"] } {
1137         # Check to make sure we don't strip a symbol named in relocations.
1138         set test "objcopy keeps symbols needed by relocs"
1139
1140         set srcfile $srcdir/$subdir/needed-by-reloc.s
1141
1142         if {![binutils_assemble $srcfile tmpdir/bintest.o]} then {
1143             unresolved $test
1144         } else {
1145             set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS --strip-symbol=foo tmpdir/bintest.o ${copyfile}.o"]
1146
1147             if [regexp "not stripping symbol `foo' because it is named in a relocation" $got] {
1148                 pass $test
1149             } else {
1150                 fail $test
1151             }
1152         }
1153     }
1154
1155     # The symbol table for some MIPS targets is sorted differently than
1156     # the ELF canonical order, so the regexps in localize-hidden-1.d fail
1157     # to match.
1158     if { [is_bad_symtab] } then {
1159         setup_xfail "*-*-*"
1160     }
1161     run_dump_test "localize-hidden-1"
1162     run_dump_test "testranges"
1163     run_dump_test "testranges-ia64"
1164
1165     run_dump_test "add-section"
1166     run_dump_test "add-symbol"
1167     run_dump_test "add-empty-section"
1168
1169     run_dump_test "exclude-1a"
1170     run_dump_test "exclude-1b"
1171
1172     run_dump_test "only-section-01"
1173     run_dump_test "remove-section-01"
1174
1175     # Test the remove relocation functionality
1176     set test_list [lsort [glob -nocomplain $srcdir/$subdir/remove-relocs-*.d]]
1177     foreach t $test_list {
1178         # We need to strip the ".d", but can leave the dirname.
1179         verbose [file rootname $t]
1180         run_dump_test [file rootname $t]
1181     }
1182 }
1183 run_dump_test "localize-hidden-2"
1184
1185 # Test objcopying an object file without global symbol
1186
1187 proc objcopy_test_without_global_symbol { } {
1188     global OBJCOPY
1189     global OBJCOPYFLAGS
1190     global OBJDUMP
1191     global OBJDUMPFLAGS
1192     global srcdir
1193     global subdir
1194
1195     set test "strip without global symbol "
1196
1197     if { [target_compile $srcdir/$subdir/pr19547.c tmpdir/pr19547.o object debug] != "" } {
1198         untested $test
1199         return
1200     }
1201
1202     if [is_remote host] {
1203         set objfile [remote_download host tmpdir/pr19547.o]
1204     } else {
1205         set objfile tmpdir/pr19547.o
1206     }
1207
1208     set exec_output [binutils_run $OBJCOPY "$OBJCOPYFLAGS --strip-unneeded $objfile"]
1209     if ![string equal "" $exec_output] {
1210         fail $test
1211         return
1212     }
1213
1214     set exec_output [binutils_run $OBJDUMP "$OBJDUMPFLAGS -t $objfile"]
1215     if {![regexp "no symbols" $exec_output]} {
1216         fail $test
1217         return
1218     }
1219
1220     pass $test
1221 }
1222
1223 # The AArch64 and ARM targets preserve mapping symbols
1224 # in object files, so they will fail this test.
1225 setup_xfail aarch64*-*-* arm*-*-*
1226
1227 objcopy_test_without_global_symbol