binutils/testsuite/binutils-all/objcopy.exp

   1 #   Copyright (C) 1994-2024 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 # "object" or "executable" values for type are supported.
  41
  42 proc objcopy_test {testname srcfile type asflags ldflags} {
  43     global OBJCOPY
  44     global OBJCOPYFLAGS
  45     global srcdir
  46     global subdir
  47     global tempfile
  48     global copyfile
  49     set t_tempfile $tempfile
  50     set t_copyfile ${copyfile}.o
  51
  52     if { $type != "object" && $type != "executable" } {
  53         error "objcopy_test accepts only \"object\" or \"executable\" values for type"
  54     }
  55
  56     if {![binutils_assemble_flags $srcdir/$subdir/${srcfile} $t_tempfile "$asflags"]} then {
  57         unsupported "objcopy $type ($testname)"
  58         remote_file host delete $t_tempfile
  59         return
  60     }
  61
  62     set xflags ""
  63     if { $type == "executable" } {
  64         global LD
  65         # Check that LD exists
  66         if {[which $LD] == 0} then {
  67             untested "objcopy $type ($testname)"
  68             return
  69         }
  70
  71         # Use tempfile and copyfile without the .o extension for executable files
  72         set t_tempfile [string range $tempfile 0 end-2]
  73         set t_copyfile $copyfile
  74         set got [binutils_run $LD "$tempfile -o $t_tempfile $ldflags"]
  75         if { ![string equal "" $got] } then {
  76             unsupported "objcopy $type ($testname)"
  77             return
  78         }
  79         set xflags "--preserve-dates"
  80         sleep 1
  81     }
  82
  83     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS $xflags $t_tempfile $t_copyfile"]
  84
  85     if ![string equal "" $got] then {
  86         send_log "$got\n"
  87         fail "objcopy $type ($testname)"
  88     } else {
  89         send_log "cmp $t_tempfile $t_copyfile\n"
  90         verbose "cmp $t_tempfile $t_copyfile"
  91         if [is_remote host] {
  92             set src1 tmpdir/bintest
  93             set src2 tmpdir/copy
  94             remote_upload host $t_tempfile $src1
  95             remote_upload host $t_copyfile $src2
  96         } else {
  97             set src1 $t_tempfile
  98             set src2 $t_copyfile
  99         }
 100         set status [remote_exec build cmp "${src1} ${src2}"]
 101         set exec_output [lindex $status 1]
 102         set exec_output [prune_warnings $exec_output]
 103
 104         if [string equal "" $exec_output] then {
 105             pass "objcopy $type ($testname)"
 106             if { $type == "executable" } {
 107                 set dir [file dirname $t_copyfile]
 108                 set f2 [file tail $t_copyfile]
 109                 set status [remote_exec host find "$dir -name $f2 -newer $t_tempfile -print"]
 110                 set exec_output [lindex $status 1]
 111                 if [string equal "" $exec_output] then {
 112                     pass "objcopy $type ($testname) timestamp"
 113                 } else {
 114                     fail "objcopy $type ($testname) timestamp"
 115                 }
 116             }
 117         } else {
 118             send_log "$exec_output\n"
 119             verbose "$exec_output" 1
 120
 121             # On OSF/1, this succeeds with gas and fails with /bin/as.
 122             setup_xfail "alpha*-*-osf*"
 123
 124             fail "objcopy $type ($testname)"
 125         }
 126     }
 127 }
 128
 129 setup_xfail "hppa*-*-*"
 130 setup_xfail "tic54x-*-*"
 131 clear_xfail "hppa*64*-*-hpux*" "hppa*-*-linux*" "hppa*-*-lites*"
 132 clear_xfail "hppa*-*-*n*bsd*" "hppa*-*-*elf*"
 133 objcopy_test "simple copy" bintest.s object "" ""
 134
 135 # Test verilog data width
 136 proc objcopy_test_verilog {testname} {
 137     global OBJCOPY
 138     global OBJCOPYFLAGS
 139     global srcdir
 140     global subdir
 141     global copyfile
 142     set binfile tmpdir/verilogtest.o
 143     set verilog tmpdir/verilog
 144
 145     set got [binutils_assemble $srcdir/$subdir/verilogtest.s $binfile]
 146     if {![binutils_assemble $srcdir/$subdir/verilogtest.s $binfile]} then {
 147         unsupported "objcopy ($testname)"
 148         return
 149     }
 150
 151     set got [binutils_run $OBJCOPY "-O verilog $binfile $verilog"]
 152     if ![string equal "" $got] then {
 153         fail "objcopy ($testname)"
 154     }
 155
 156     set got [binutils_run $OBJCOPY "-O verilog --verilog-data-width 0 $binfile $verilog-0.hex"]
 157     if ![regexp "error: verilog data width must be 1, 2, 4, 8 or 16" $got] then {
 158         fail "objcopy ($testname 0) {$got}"
 159     } else {
 160         pass "objcopy ($testname 0)"
 161     }
 162
 163     foreach width {1 2} {
 164         set got [binutils_run $OBJCOPY "-O verilog --verilog-data-width $width $binfile $verilog-$width.hex"]
 165         if ![string equal "" $got] then {
 166             fail "objcopy ($testname $width)"
 167         }
 168         send_log "regexp_diff $verilog-$width.hex $srcdir/$subdir/verilog-$width.hex\n"
 169         if {! [regexp_diff "$verilog-$width.hex" "$srcdir/$subdir/verilog-$width.hex"]} {
 170             pass "objcopy ($testname $width)"
 171         } else {
 172             fail "objcopy ($testname $width)"
 173         }
 174     }
 175
 176     # 16-bit little-endian targets fail the following tests because the
 177     # verilog backend does not convert from 16-bits to 32-bits before it
 178     # converts from internal format to little endian format.
 179     if { [istarget tic54*-*-*] || [istarget pdp11-*-*] } {
 180         untested "verilog width-4 and width-8 tests"
 181         return
 182     }
 183
 184     foreach width {4 8} {
 185         set got [binutils_run $OBJCOPY "-O verilog --verilog-data-width $width $binfile $verilog-$width.hex"]
 186         if ![string equal "" $got] then {
 187             fail "objcopy ($testname $width)"
 188         }
 189         send_log "regexp_diff $verilog-$width.hex $srcdir/$subdir/verilog-$width.hex\n"
 190         if {! [regexp_diff "$verilog-$width.hex" "$srcdir/$subdir/verilog-$width.hex"]} {
 191             pass "objcopy ($testname $width)"
 192         } else {
 193             fail "objcopy ($testname $width)"
 194         }
 195     }
 196
 197     # Test generating endian correct output.
 198     set testname "objcopy (verilog output endian-ness == input endian-ness)"
 199     set got [binutils_run $OBJCOPY "-O verilog --verilog-data-width 4 $binfile $verilog-I4.hex"]
 200     if ![string equal "" $got] then {
 201         fail $testname
 202     }
 203     send_log "regexp_diff $verilog-I4.hex $srcdir/$subdir/verilog-I4.hex\n"
 204     if {! [regexp_diff "$verilog-I4.hex" "$srcdir/$subdir/verilog-I4.hex"]} {
 205         pass $testname
 206     } else {
 207         fail $testname
 208     }
 209 }
 210
 211 objcopy_test_verilog "verilog data width"
 212
 213 if { [file exists $tempfile] } {
 214     # Test reversing bytes in a section.
 215
 216     set reversed ${tempfile}-reversed
 217     set sect_names [get_standard_section_names]
 218     if { $sect_names != "" } {
 219         if { [istarget hppa*-*-hpux*] } {
 220             set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -j \$PRIVATE\$ -j [lindex $sect_names 1] --reverse-bytes=4 $tempfile $reversed"]
 221         } else {
 222             set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -j [lindex $sect_names 1] --reverse-bytes=4 $tempfile $reversed"]
 223         }
 224     } else {
 225         set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -j .data --reverse-bytes=4 $tempfile $reversed"]
 226     }
 227
 228     if ![string equal "" $got] then {
 229         fail "objcopy --reverse-bytes"
 230     } else {
 231         if [is_remote host] {
 232             remote_upload host ${reversed} tmpdir/copy-reversed.o
 233             set reversed tmpdir/copy-reversed.o
 234         }
 235
 236         set origdata [binutils_run $OBJDUMP "$OBJDUMPFLAGS -s -j .data $tempfile"]
 237         set  revdata [binutils_run $OBJDUMP "$OBJDUMPFLAGS -s -j .data $reversed"]
 238
 239         set want "^ \[0-9\]+ (\[0-9\]+)"
 240         set found_orig [regexp -lineanchor $want $origdata -> origdata]
 241         set found_rev [regexp -lineanchor $want $revdata -> revdata]
 242
 243         if {$found_orig == 0 || $found_rev == 0} then {
 244             fail "objcopy --reverse-bytes"
 245         } else {
 246             scan $origdata "%2x%2x%2x%2x" b1 b2 b3 b4
 247             scan $revdata "%2x%2x%2x%2x" c4 c3 c2 c1
 248
 249             if {$b1 == $c1 && $b2 == $c2 && $b3 == $c3 && $b4 == $c4} then {
 250                 pass "objcopy --reverse-bytes"
 251             } else {
 252                 fail "objcopy --reverse-bytes"
 253             }
 254         }
 255     }
 256 }
 257
 258 # Test interleaved copy of multiple byte width
 259
 260 set sequence_file sequence_file
 261 set file [open ${sequence_file} w]
 262 puts ${file} "12345678"
 263 close ${file}
 264
 265 if [is_remote host] {
 266     remote_upload host ${sequence_file} tmpdir/sequence_file
 267     set sequence_file tmpdir/sequence_file
 268 }
 269
 270 set got [binutils_run $OBJCOPY "-I binary -i 4 -b 0 --interleave-width 2 ${sequence_file} ${copyfile}"]
 271
 272 if ![string equal "" $got] then {
 273     fail "objcopy -i --interleave-width"
 274 } else {
 275     if [is_remote host] {
 276         remote_upload host ${copyfile} tmpdir/interleave_output
 277         set interleave_output tmpdir/interleave_output
 278     } else {
 279         set interleave_output ${copyfile}
 280     }
 281
 282     set file [open ${interleave_output} r]
 283     gets $file line
 284     send_log "$line\n"
 285     verbose $line
 286
 287     if ![string equal "1256" $line] then {
 288         fail "objcopy -i --interleave-width"
 289     }
 290     pass "objcopy -i --interleave-width"
 291
 292     close $file
 293 }
 294
 295 # Test generating S records.
 296
 297 if { [file exists $tempfile] } {
 298     # We make the srec filename 8.3 compatible. Note that the header string
 299     # matched against depends on the name of the file. Ugh.
 300
 301     if [is_remote host] {
 302         set srecfile copy.sre
 303         set header_string S00B0000636F70792E737265C1
 304     } else {
 305         set srecfile ${copyfile}.srec
 306         set header_string S0130000746D706469722F636F70792E7372656397
 307     }
 308
 309     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $tempfile ${srecfile}"]
 310
 311     if ![string equal "" $got] then {
 312         fail "objcopy -O srec"
 313     } else {
 314         if [is_remote host] {
 315             remote_upload host ${srecfile} tmpdir/copy.srec
 316             set srecfile tmpdir/copy.srec
 317         }
 318         set file [open ${srecfile} r]
 319
 320         # The first S record is fixed by the file name we are using.
 321         gets $file line
 322         send_log "$line\n"
 323         verbose $line
 324         if ![regexp "$header_string.*" $line] {
 325             send_log "bad header\n"
 326             fail "objcopy -O srec"
 327         } else {
 328             while {[gets $file line] != -1 \
 329                        && [regexp "^S\[123\]\[0-9a-fA-F\]+\[\r\n\]*$" $line]} {
 330                 send_log "$line\n"
 331                 verbose $line
 332                 set line "**EOF**"
 333             }
 334             send_log "$line\n"
 335             verbose $line
 336             if ![regexp "^S\[789\]\[0-9a-fA-F\]+\[\r\n\]*$" $line] then {
 337                 send_log "bad trailer\n"
 338                 fail "objcopy -O srec"
 339             } else {
 340                 if {[gets $file line] != -1} then {
 341                     send_log "garbage at end\n"
 342                     send_log "$line\n"
 343                     verbose $line
 344                     fail "objcopy -O srec"
 345                 } else {
 346                     set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${srecfile}"]
 347                     if ![regexp "file format srec" $got] then {
 348                         send_log "objdump failed\n"
 349                         fail "objcopy -O srec"
 350                     } else {
 351                         pass "objcopy -O srec"
 352                     }
 353                 }
 354             }
 355         }
 356
 357         close $file
 358     }
 359 }
 360
 361 # Test setting and adjusting the start address.  We only test this
 362 # while generating S records, because we may not be able to set the
 363 # start address for other object file formats, and the S record case
 364 # is the only useful one anyhow.
 365
 366 set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f $tempfile"]
 367 if ![regexp "start address (\[0-9a-fA-FxX\]+)" $got all origstart] then {
 368     perror "objdump can not recognize bintest.o"
 369     set origstart ""
 370 } else {
 371     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --set-start 0x7654 $tempfile ${copyfile}.srec"]
 372     if ![string equal "" $got] then {
 373         fail "objcopy --set-start"
 374     } else {
 375         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${copyfile}.srec"]
 376         if ![regexp "file format srec.*start address (\[0-9a-fA-FxX\]+)" $got all srecstart] then {
 377             fail "objcopy --set-start"
 378         } else {
 379             if {$srecstart != 0x7654} then {
 380                 send_log "$srecstart != 0x7654\n"
 381                 fail "objcopy --set-start"
 382             } else {
 383                 pass "objcopy --set-start"
 384             }
 385         }
 386     }
 387
 388     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --adjust-start 0x123 $tempfile ${copyfile}.srec"]
 389     if ![string equal "" $got] then {
 390         fail "objcopy --adjust-start"
 391     } else {
 392         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -f ${copyfile}.srec"]
 393         if ![regexp "file format srec.*start address (\[0-9a-fA-FxX\]+)" $got all srecstart] then {
 394             fail "objcopy --adjust-start"
 395         } else {
 396             if {$srecstart != $origstart + 0x123} then {
 397                 send_log "$srecstart != $origstart + 0x123\n"
 398                 fail "objcopy --adjust-start"
 399             } else {
 400                 pass "objcopy --adjust-start"
 401             }
 402         }
 403     }
 404 }
 405
 406 # Test adjusting the overall VMA, and adjusting the VMA of a
 407 # particular section.  We again only test this when generating S
 408 # records.
 409
 410 set low ""
 411 set lowname ""
 412
 413 set headers [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h $tempfile"]
 414
 415 set headers_regexp "\[  0-9\]+(\[^      \]+)\[  \]*(\[0-9a-fA-F\]+)\[   \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)\[   \]+\[0-9a-fA-F\]+\[     \]+2\[*\]\[*\]\[0-9\]+(.*)"
 416
 417 set got $headers
 418 while {[regexp $headers_regexp $got all name size vma rest]} {
 419     set vma 0x$vma
 420     set size 0x$size
 421     if {$size != 0} {
 422         if {$low == "" || $vma < $low} {
 423             set low $vma
 424             set lowname $name
 425         }
 426     }
 427     set got $rest
 428 }
 429
 430 if {$low == "" || $origstart == ""} then {
 431     perror "objdump can not recognize bintest.o"
 432 } else {
 433     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec --adjust-vma 0x123 $tempfile ${copyfile}.srec"]
 434     if ![string equal "" $got] then {
 435         fail "objcopy --adjust-vma"
 436     } else {
 437         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -fh ${copyfile}.srec"]
 438         set want "file format srec.*start address\[     \]*(\[0-9a-fA-FxX\]+).*sec1\[   \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 439         if ![regexp $want $got all start vma] then {
 440             fail "objcopy --adjust-vma"
 441         } else {
 442             set vma 0x$vma
 443             if {$vma != $low + 0x123} then {
 444                 send_log "$vma != $low + 0x123\n"
 445                 fail "objcopy --adjust-vma"
 446             } else {
 447                 if {$start != $origstart + 0x123} then {
 448                     send_log "$start != $origstart + 0x123\n"
 449                     fail "objcopy --adjust-vma"
 450                 } else {
 451                     pass "objcopy --adjust-vma"
 452                 }
 453             }
 454         }
 455     }
 456
 457     set arg ""
 458     set got $headers
 459     while {[regexp $headers_regexp $got all name size vma rest]} {
 460         set vma 0x$vma
 461         if {$vma == $low} then {
 462             set arg "$arg --adjust-section-vma $name+4"
 463         }
 464         set got $rest
 465     }
 466
 467     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $arg $tempfile ${copyfile}.srec"]
 468     if ![string equal "" $got] then {
 469         fail "objcopy --adjust-section-vma +"
 470     } else {
 471         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h ${copyfile}.srec"]
 472         set want "file format srec.*sec1\[      \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 473         if ![regexp $want $got all vma] then {
 474             fail "objcopy --adjust-section-vma +"
 475         } else {
 476             set vma 0x$vma
 477             if {$vma != $low + 4} then {
 478                 send_log "$vma != $low + 4\n"
 479                 fail "objcopy --adjust-section-vma +"
 480             } else {
 481                 pass "objcopy --adjust-section-vma +"
 482             }
 483         }
 484     }
 485
 486     regsub -all "\\+4" $arg "=[expr $low + 4]" argeq
 487     set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS -O srec $argeq $tempfile ${copyfile}.srec"]
 488     if ![string equal "" $got] then {
 489         fail "objcopy --adjust-section-vma ="
 490     } else {
 491         set got [binutils_run $OBJDUMP "$OBJDUMPFLAGS -h ${copyfile}.srec"]
 492         set want "file format srec.*sec1\[      \]+\[0-9a-fA-F\]+\[     \]+(\[0-9a-fA-F\]+)"
 493         if ![regexp $want $got all vma] then {
 494             fail "objcopy --adjust-section-vma ="
 495         } else {
 496             set vma 0x$vma
 497             if {$vma != $low + 4} then {
 498                 send_log "$vma != $low + 4\n"
 499                 fail "objcopy --adjust-section-vma ="
 500             } else {
 501                 pass "objcopy --adjust-section-vma ="
 502             }
 503         }
 504     }
 505 }
 506
 507 # Test stripping an object.
 508
 509 proc strip_test { } {
 510     global AR
 511     global CC
 512     global STRIP
 513     global STRIPFLAGS
 514     global NM
 515     global NMFLAGS
 516     global srcdir
 517     global subdir
 518     global READELF
 519
 520     set test "strip"
 521
 522     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 523         untested $test
 524         return
 525     }
 526
 527     set osabi_fail "false"
 528     if [is_elf_format] {
 529         verbose -log "$READELF -a tmpdir/testprog.o > tmpdir/osabi.in"
 530         set exec_output [remote_exec host "$READELF -h tmpdir/testprog.o" "" "/dev/null" "tmpdir/osabi.in"]
 531         if { [lindex $exec_output 0] != 0 } then {
 532             fail "$test preserving OS/ABI"
 533             set osabi_fail "true"
 534         } else {
 535             verbose -log "grep OS/ABI tmpdir/osabi.in"
 536             catch "exec grep OS/ABI tmpdir/osabi.in" osabi_in
 537         }
 538     }
 539
 540     if [is_remote host] {
 541         set archive libstrip.a
 542         set objfile [remote_download host tmpdir/testprog.o]
 543         remote_file host delete $archive
 544     } else {
 545         set archive tmpdir/libstrip.a
 546         set objfile tmpdir/testprog.o
 547     }
 548
 549     remote_file build delete tmpdir/libstrip.a
 550
 551     set exec_output [binutils_run $AR "rc $archive ${objfile}"]
 552     set exec_output [prune_warnings $exec_output]
 553     if ![string equal "" $exec_output] {
 554         fail $test
 555         unresolved "$test preserving OS/ABI"
 556         return
 557     }
 558
 559     set exec_output [binutils_run $STRIP "-g $archive"]
 560     set exec_output [prune_warnings $exec_output]
 561     if ![string equal "" $exec_output] {
 562         fail $test
 563         unresolved "$test preserving OS/ABI"
 564         return
 565     }
 566
 567     set exec_output [binutils_run $STRIP "$STRIPFLAGS $archive"]
 568     set exec_output [prune_warnings $exec_output]
 569     if ![string equal "" $exec_output] {
 570         fail $test
 571         unresolved "$test preserving OS/ABI"
 572         return
 573     }
 574
 575     if { $osabi_fail != "true" && [is_elf_format] } {
 576         verbose -log "$READELF -a tmpdir/testprog.o > tmpdir/osabi.out"
 577         set exec_output [remote_exec host "$READELF -h tmpdir/testprog.o" "" "/dev/null" "tmpdir/osabi.out"]
 578         if { [lindex $exec_output 0] != 0 } then {
 579             fail "$test preserving OS/ABI"
 580         } else {
 581             verbose -log "grep OS/ABI tmpdir/osabi.out"
 582             catch "exec grep OS/ABI tmpdir/osabi.out" osabi_out
 583             if { "$osabi_in" == "$osabi_out" } {
 584                 pass "$test preserving OS/ABI"
 585             } else {
 586                 fail "$test preserving OS/ABI"
 587             }
 588         }
 589     }
 590
 591     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 592         untested $test
 593         return
 594     }
 595
 596     if [is_remote host] {
 597         set objfile [remote_download host tmpdir/testprog.o]
 598     } else {
 599         set objfile tmpdir/testprog.o
 600     }
 601
 602     set exec_output [binutils_run $STRIP "$STRIPFLAGS $objfile"]
 603     set exec_output [prune_warnings $exec_output]
 604     if ![string equal "" $exec_output] {
 605         fail $test
 606         return
 607     }
 608
 609     set exec_output [binutils_run $NM "-a $NMFLAGS $objfile"]
 610     set exec_output [prune_warnings $exec_output]
 611     if ![string match "*: no symbols*" $exec_output] {
 612         fail $test
 613         return
 614     }
 615
 616     pass $test
 617 }
 618
 619 strip_test
 620
 621 # Test stripping an object file with saving a symbol
 622
 623 proc strip_test_with_saving_a_symbol { } {
 624     global CC
 625     global STRIP
 626     global STRIPFLAGS
 627     global NM
 628     global NMFLAGS
 629     global srcdir
 630     global subdir
 631
 632     set test "strip with saving a symbol"
 633
 634     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
 635         untested $test
 636         return
 637     }
 638
 639     if [is_remote host] {
 640         set objfile [remote_download host tmpdir/testprog.o]
 641     } else {
 642         set objfile tmpdir/testprog.o
 643     }
 644
 645     set exec_output [binutils_run $STRIP "$STRIPFLAGS -K main -K _main $objfile"]
 646     set exec_output [prune_warnings $exec_output]
 647     if ![string equal "" $exec_output] {
 648         fail $test
 649         return
 650     }
 651
 652     set exec_output [binutils_run $NM "$NMFLAGS $objfile"]
 653     set exec_output [prune_warnings $exec_output]
 654     if {![regexp {^([0-9a-fA-F]+)?[ ]+[TtDd] _?main} $exec_output]} {
 655         fail $test
 656         return
 657     }
 658
 659     pass $test
 660 }
 661
 662 strip_test_with_saving_a_symbol
 663
 664 # Build a final executable.
 665
 666 set exe [exeext]
 667 set test_prog "testprog${exe}"
 668
 669 proc copy_setup { } {
 670     global srcdir
 671     global subdir
 672     global gcc_gas_flag
 673     global test_prog
 674     global host_triplet
 675
 676     if {[target_info exists needs_status_wrapper] && \
 677             [target_info needs_status_wrapper] != "0"} {
 678         set res [build_wrapper testglue.o]
 679     } else {
 680         set res ""
 681     }
 682     set flags { debug }
 683
 684     if { [istarget *-*-uclinux*] && ![istarget tic6x-*-*] && ![istarget arm*-*-uclinuxfdpiceabi] } {
 685         return 1
 686     }
 687
 688     if { $res != "" } {
 689         lappend flags "additional_flags=[lindex $res 1]"
 690         set add_libs "testglue.o"
 691     } else {
 692         set add_libs ""
 693     }
 694
 695     if { [istarget *-*-linux*]
 696          || [istarget kvx-*-*]
 697          || [istarget *-*-gnu*] } {
 698         foreach i $gcc_gas_flag {
 699             set flags "additional_flags=$i $flags"
 700         }
 701     }
 702     if { [target_compile "$srcdir/$subdir/testprog.c $add_libs" tmpdir/$test_prog executable $flags]  != "" } {
 703         return 2
 704     }
 705
 706     set result [remote_load target tmpdir/$test_prog]
 707     set status [lindex $result 0]
 708
 709     if { $status != "pass"  } {
 710         send_log "cannot run executable, status = ${status} on ${host_triplet}\n"
 711         return 3
 712     }
 713
 714     return 0
 715 }
 716
 717 # Test copying an executable.
 718
 719 proc copy_executable { prog flags test1 test2 } {
 720     global test_prog
 721
 722     if [is_remote host] {
 723         set testfile [remote_download host tmpdir/$test_prog]
 724         set testcopy copyprog
 725     } else {
 726         set testfile tmpdir/$test_prog
 727         set testcopy tmpdir/copyprog
 728     }
 729     remote_file host delete $testcopy
 730
 731     set exec_output [binutils_run $prog "$flags $testfile $testcopy"]
 732
 733     if ![string equal "" $exec_output] {
 734         fail $test1
 735         if [string equal "" $test2] {
 736             return
 737         }
 738         fail $test2
 739         return
 740     }
 741
 742     if [is_remote host] {
 743         remote_upload host $testcopy tmpdir/copyprog
 744     }
 745
 746     set status [remote_exec build "cmp" "tmpdir/$test_prog tmpdir/copyprog"]
 747     set exec_output [lindex $status 1]
 748
 749     if [string equal "" $exec_output] then {
 750         pass $test1
 751     } else {
 752         send_log "$exec_output\n"
 753         verbose "$exec_output"
 754
 755         # This will fail for many reasons.  For example, it will most
 756         # likely fail if a non-GNU linker is used.  Therefore, we do
 757         # not insist that it pass.  If you are using an assembler and
 758         # linker based on the same BFD as objcopy, it is worth
 759         # investigating to see why this failure occurs.  If we are
 760         # cross compiling, we assume that a GNU linker is being used,
 761         # and expect it to succeed.
 762         if {[isnative]} then {
 763             setup_xfail "*-*-*"
 764         }
 765
 766         # This also fails for some mips targets.  See elf32-mips.c
 767         # mips_elf_sym_is_global.
 768         if { [is_bad_symtab] } then {
 769             setup_xfail "*-*-*"
 770         }
 771
 772         setup_xfail "arm*-*-pe"
 773         setup_xfail "*-*-mingw*"
 774         setup_xfail "*-*-cygwin*"
 775
 776         fail $test1
 777     }
 778
 779     if [string equal "" $test2] {
 780         return
 781     }
 782
 783     set output [remote_load target tmpdir/copyprog]
 784     set status [lindex $output 0]
 785     if { $status != "pass" } {
 786         fail $test2
 787     } else {
 788         pass $test2
 789     }
 790 }
 791
 792 # Test stripping an executable
 793
 794 proc strip_executable { prog flags test1 test2 } {
 795     global NM
 796     global NMFLAGS
 797     global READELF
 798
 799     remote_file build delete tmpdir/striprog
 800     remote_download build tmpdir/copyprog tmpdir/striprog
 801     if [is_remote host] {
 802         set copyfile [remote_download host tmpdir/striprog]
 803     } else {
 804         set copyfile tmpdir/striprog
 805     }
 806
 807     set osabi_fail "false"
 808     if [is_elf_format] {
 809         verbose -log "$READELF -a ${copyfile} > tmpdir/osabi.in"
 810         set exec_output [remote_exec host "$READELF -h ${copyfile}" "" "/dev/null" "tmpdir/osabi.in"]
 811         if { [lindex $exec_output 0] != 0 } then {
 812             fail "$test1 preserving OS/ABI"
 813             set osabi_fail "true"
 814         } else {
 815             verbose -log "grep OS/ABI tmpdir/osabi.in"
 816             catch "exec grep OS/ABI tmpdir/osabi.in" osabi_in
 817         }
 818      }
 819
 820     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 821     if ![string equal "" $exec_output] {
 822         fail $test1
 823         if [string equal "" $test2] {
 824             return
 825         }
 826         fail $test2
 827         return
 828     }
 829
 830     if [is_remote host] {
 831         remote_upload host ${copyfile} tmpdir/striprog
 832     }
 833
 834     if { $osabi_fail != "true" && [is_elf_format] } {
 835         verbose -log "$READELF -a ${copyfile} > tmpdir/osabi.out"
 836         set exec_output [remote_exec host "$READELF -h ${copyfile}" "" "/dev/null" "tmpdir/osabi.out"]
 837         if { [lindex $exec_output 0] != 0 } then {
 838             fail "$test1 preserving OS/ABI"
 839         } else {
 840             verbose -log "grep OS/ABI tmpdir/osabi.out"
 841             catch "exec grep OS/ABI tmpdir/osabi.out" osabi_out
 842             if { "$osabi_in" == "$osabi_out" } {
 843                 pass "$test1 preserving OS/ABI"
 844             } else {
 845                 fail "$test1 preserving OS/ABI"
 846             }
 847         }
 848     }
 849
 850     set exec_output [binutils_run $NM "$NMFLAGS ${copyfile}"]
 851     if ![string match "*: no symbols*" $exec_output] {
 852         fail $test1
 853         return
 854     }
 855
 856     if [string equal "" $test2] {
 857         return
 858     }
 859
 860     set result [remote_load target tmpdir/striprog]
 861     set status [lindex $result 0]
 862     if { $status != "pass" } {
 863         fail $test2
 864         return
 865     }
 866
 867     pass $test2
 868 }
 869
 870 # Test stripping an executable with saving a symbol
 871
 872 proc strip_executable_with_saving_a_symbol { prog flags test1 test2 } {
 873     global NM
 874     global NMFLAGS
 875
 876     remote_file build delete tmpdir/striprog
 877     remote_download build tmpdir/copyprog tmpdir/striprog
 878     if [is_remote host] {
 879         set copyfile [remote_download host tmpdir/striprog]
 880     } else {
 881         set copyfile tmpdir/striprog
 882     }
 883
 884     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 885     if ![string equal "" $exec_output] {
 886         fail $test1
 887         if [string equal "" $test2] {
 888             return
 889         }
 890         fail $test2
 891         return
 892     }
 893
 894     set exec_output [binutils_run $NM "$NMFLAGS ${copyfile}"]
 895     if { [istarget mmix-knuth-mmixware] } {
 896         # Whenever there's a symbol in the mmo format, there's the symbol
 897         # Main, so remove it manually from the expected output for sake of
 898         # this test.
 899
 900         # Using "" not {} to get the \n and \r translated.
 901         regsub "^\[0-9a-fA-F\]+\[ \]+T Main\[\n\r\]+" $exec_output "" exec_output
 902     }
 903
 904     if {![regexp {^([0-9a-fA-F]+)?[ ]+[TtDd] _?main} $exec_output]} {
 905         fail $test1
 906         return
 907     }
 908
 909     if [string equal "" $test2] {
 910         return
 911     }
 912
 913     if [is_remote host] {
 914         remote_upload host ${copyfile} tmpdir/striprog
 915     }
 916
 917     set result [remote_load target tmpdir/striprog]
 918     set status [lindex $result 0]
 919     if { $status != "pass" } {
 920         fail $test2
 921         return
 922     }
 923
 924     pass $test2
 925 }
 926
 927 # Test keeping only debug symbols of an executable
 928
 929 proc keep_debug_symbols_and_test_copy { prog1 flags1 test1 prog2 flags2 test2 } {
 930     remote_file build delete tmpdir/striprog
 931     remote_download build tmpdir/copyprog tmpdir/striprog
 932     if [is_remote host] {
 933         set copyfile [remote_download host tmpdir/striprog]
 934     } else {
 935         set copyfile tmpdir/striprog
 936     }
 937
 938     set exec_output [binutils_run $prog1 "$flags1 ${copyfile}"]
 939     if ![string equal "" $exec_output] {
 940         fail $test1
 941         return
 942     }
 943     pass $test1
 944
 945     set exec_output [binutils_run $prog2 "$flags2 ${copyfile}"]
 946     if ![string equal "" $exec_output] {
 947         fail $test2
 948         return
 949     }
 950     pass $test2
 951 }
 952
 953 # Tests that in a debug only copy of a file the sections
 954 # headers whose types have been changed to NOBITS still
 955 # retain their sh_link fields.
 956
 957 proc keep_debug_symbols_and_check_links { prog flags test } {
 958     global READELF
 959
 960     remote_file build delete tmpdir/striprog
 961     remote_download build tmpdir/copyprog tmpdir/striprog
 962     if [is_remote host] {
 963         set copyfile [remote_download host tmpdir/striprog]
 964     } else {
 965         set copyfile tmpdir/striprog
 966     }
 967
 968     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 969     if ![string equal "" $exec_output] {
 970         fail $test
 971         return
 972     }
 973
 974     set got [binutils_run $READELF "-S --wide ${copyfile}"]
 975
 976     set fails 0
 977     # Regexp to match a section with NOBITS type and extract its name and sh_link fields
 978     while {[regexp \
 979                 {[^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]+)(.*)} \
 980                 $got all name link rest]} {
 981         set sh_link 0x$link
 982         if {$sh_link == 0} {
 983             # Only some NOBITS sections should have a non-zero sh_link field.
 984             # Look for them by name.
 985             verbose "NOBITS section .$name has a 0 sh_link field\n"
 986             switch $name {
 987                 "rela.*"        { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 988                 "rel.*"         { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 989                 "hash"          { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 990                 "gnu_version"   { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 991                 "dynsym"        { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 992                 "gnu.version_r" { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 993                 "dynamic"       { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 994                 "symtab"        { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 995             }
 996         }
 997         set got $rest
 998     }
 999
1000     if {$fails == 0} {
1001         pass $test
1002     } else {
1003         fail $test
1004     }
1005 }
1006
1007 # For ELF relocatables, test that --only-keep-debug
1008 # marks non-debug output sections as NOBITS.
1009
1010 proc keep_debug_symbols_for_elf_relocatable { prog flags test } {
1011     global srcdir
1012     global subdir
1013     global READELF
1014
1015     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
1016         untested $test
1017         return
1018     }
1019
1020     if [is_remote host] {
1021         set relocatable [remote_download host tmpdir/testprog.o]
1022     } else {
1023         set relocatable tmpdir/testprog.o
1024     }
1025
1026     set non_debug_sections {}
1027     set got [binutils_run $READELF "-S --wide ${relocatable}"]
1028     while { [regexp \
1029             {[^a-zA-Z]+([a-zA-Z0-9_\.]+)[ \t]+([A-Z]+)[ \t]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ [0-9]+[ \t]+([A-Z]*)[ \t]+[0-9]+(.*)} \
1030             $got all name type flag rest] } {
1031         if { $type != "NOTE" && [regexp {[AG]} $flag] } {
1032             # PR 30699: Some debug sections can be in a group, so
1033             # exclude sections whose name includes "debug_"
1034             if { ! [regexp {debug_} $name] } {
1035                 lappend non_debug_sections $name
1036             }
1037         }
1038         set got $rest
1039     }
1040
1041     set exec_output [binutils_run $prog "$flags ${relocatable}"]
1042     if ![string equal "" $exec_output] {
1043         fail $test
1044         return
1045     }
1046
1047     set fails 0
1048     set got [binutils_run $READELF "-S --wide ${relocatable}"]
1049     while { [regexp \
1050             {[^a-zA-Z]+([a-zA-Z0-9_\.]+)[ \t]+([A-Z]+)[ \t]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ [0-9]+[ \t]+[A-Z]*[ \t]+[0-9]+(.*)} \
1051             $got all name type rest] } {
1052         if { [lsearch -exact $non_debug_sections $name] >= 0 && $type != "NOBITS" } {
1053             set fails 1
1054             send_log "Expected SHT_NOBITS type for .$name\n"
1055         }
1056         set got $rest
1057     }
1058     if { $fails == 1 } {
1059         fail $test
1060         return
1061     }
1062
1063     pass $test
1064 }
1065
1066 set test1 "simple objcopy of executable"
1067 set test1r "run objcopy of executable"
1068 set test2 "strip executable"
1069 set test2r "run stripped executable"
1070 set test3 "strip executable with saving a symbol"
1071 set test3r "run stripped executable with saving a symbol"
1072 set test4 "keep only debug data"
1073 set test5 "simple objcopy of debug data"
1074 if [is_elf_format] {
1075     set test6 "NOBITS sections retain sh_link field"
1076     set test7 "--only-keep-debug for ELF relocatables"
1077 }
1078
1079 switch [copy_setup] {
1080     "1" {
1081         # do nothing
1082     }
1083     "2" {
1084         untested $test1
1085         untested $test1r
1086         untested $test2
1087         untested $test2r
1088         untested $test3
1089         untested $test3r
1090         untested $test4
1091         untested $test5
1092         if [is_elf_format] {
1093             untested $test6
1094             untested $test7
1095         }
1096     }
1097     "3" {
1098         copy_executable "$OBJCOPY" "$OBJCOPYFLAGS" "$test1" ""
1099         unsupported $test1r
1100         strip_executable "$STRIP" "$STRIPFLAGS" "$test2" ""
1101         unsupported $test2r
1102         strip_executable_with_saving_a_symbol "$STRIP" "-K main -K _main $STRIPFLAGS" "$test3" ""
1103         unsupported $test3r
1104         keep_debug_symbols_and_test_copy "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test4" \
1105                                          "$OBJCOPY" "$OBJCOPYFLAGS" "$test5"
1106         if [is_elf_format] {
1107             keep_debug_symbols_and_check_links "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test6"
1108             keep_debug_symbols_for_elf_relocatable "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test7"
1109         }
1110     }
1111     "0" {
1112         copy_executable "$OBJCOPY" "$OBJCOPYFLAGS" "$test1" "$test1r"
1113         strip_executable "$STRIP" "$STRIPFLAGS" "$test2" "$test2r"
1114         strip_executable_with_saving_a_symbol "$STRIP" "-K main -K _main $STRIPFLAGS" "$test3" "$test3r"
1115         keep_debug_symbols_and_test_copy "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test4" \
1116                                          "$OBJCOPY" "$OBJCOPYFLAGS" "$test5"
1117         if [is_elf_format] {
1118             keep_debug_symbols_and_check_links "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test6"
1119             keep_debug_symbols_for_elf_relocatable "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test7"
1120         }
1121     }
1122 }
1123
1124 proc objcopy_test_readelf {testname srcfile} {
1125     global OBJCOPY
1126     global OBJCOPYFLAGS
1127     global READELF
1128     global srcdir
1129     global subdir
1130
1131     if {![binutils_assemble $srcdir/$subdir/${srcfile} tmpdir/bintest.o]} then {
1132         unsupported "objcopy ($testname)"
1133         return
1134     }
1135
1136     verbose -log "$OBJCOPY $OBJCOPYFLAGS tmpdir/bintest.o tmpdir/copy.o"
1137     set exec_output [remote_exec host "$OBJCOPY $OBJCOPYFLAGS tmpdir/bintest.o tmpdir/copy.o"]
1138     if { [lindex $exec_output 0] != 0
1139          || ![string equal "" [lindex $exec_output 1]] } then {
1140         fail "objcopy ($testname)"
1141         return
1142     }
1143
1144     verbose -log "$READELF -a tmpdir/bintest.o > tmpdir/bintest.o.out"
1145     set exec_output [remote_exec host "$READELF -a tmpdir/bintest.o" "" "/dev/null" "tmpdir/bintest.o.out"]
1146     if { [lindex $exec_output 0] != 0 } then {
1147         fail "objcopy ($testname)"
1148         return
1149     }
1150     set exec_output [prune_warnings [lindex $exec_output 1]]
1151     if ![string equal "" $exec_output] then {
1152         unresolved "objcopy ($testname)"
1153         return
1154     }
1155
1156     verbose -log "$READELF -a tmpdir/copy.o > tmpdir/copy.o.out"
1157     set exec_output [remote_exec host "$READELF -a tmpdir/copy.o" "" "/dev/null" "tmpdir/copy.o.out"]
1158     if { [lindex $exec_output 0] != 0 } then {
1159         fail "objcopy ($testname)"
1160         return
1161     }
1162     set exec_output [prune_warnings [lindex $exec_output 1]]
1163     if ![string equal "" $exec_output] then {
1164         unresolved "objcopy ($testname)"
1165         return
1166     }
1167
1168     verbose -log "diff tmpdir/bintest.o.out tmpdir/copy.o.out"
1169     catch "exec diff tmpdir/bintest.o.out tmpdir/copy.o.out" exec_output
1170     set exec_output [prune_warnings $exec_output]
1171
1172     if [string equal "" $exec_output] then {
1173         pass "objcopy ($testname)"
1174     } else {
1175         fail "objcopy ($testname)"
1176     }
1177 }
1178
1179 proc objcopy_test_symbol_manipulation {} {
1180     global srcdir
1181     global subdir
1182
1183     set test_list [lsort [glob -nocomplain $srcdir/$subdir/symbols-*.d]]
1184     foreach t $test_list {
1185         # We need to strip the ".d", but can leave the dirname.
1186         verbose [file rootname $t]
1187         run_dump_test [file rootname $t]
1188     }
1189
1190     if { [supports_gnu_unique] } {
1191         run_dump_test "weaken-gnu-unique"
1192     }
1193 }
1194
1195 proc objcopy_test_elf_common_symbols {} {
1196     global srcdir
1197     global subdir
1198
1199     # hpux has a non-standard common directive.
1200     if { [istarget "*-*-hpux*"] } then {
1201         return
1202     }
1203
1204     set test_list [lsort [glob -nocomplain $srcdir/$subdir/common-*.d]]
1205     foreach t $test_list {
1206         # We need to strip the ".d", but can leave the dirname.
1207         verbose [file rootname $t]
1208         run_dump_test [file rootname $t]
1209     }
1210 }
1211
1212 # ia64 specific tests
1213 if { ([istarget "ia64-*-elf*"]
1214        || [istarget "ia64-*-linux*"]) } {
1215     objcopy_test "ia64 link order" link-order.s object "" ""
1216 }
1217
1218 # ELF specific tests
1219 set elf64 ""
1220 if [is_elf_format] {
1221     objcopy_test_symbol_manipulation
1222     objcopy_test_elf_common_symbols
1223     objcopy_test "ELF unknown section type" unknown.s object "" ""
1224     objcopy_test_readelf "ELF group 1" group.s
1225     objcopy_test_readelf "ELF group 2" group-2.s
1226     objcopy_test_readelf "ELF group 3" group-3.s
1227     objcopy_test_readelf "ELF group 4" group-4.s
1228     objcopy_test_readelf "GNU_MBIND section" mbind1.s
1229     run_dump_test "group-5"
1230     run_dump_test "group-6"
1231     run_dump_test "group-7a"
1232     run_dump_test "group-7b"
1233     run_dump_test "group-7c"
1234     run_dump_test "copy-1"
1235     run_dump_test "note-1"
1236     # Use copytest.o from the note-1 test to determine ELF32 or ELF64
1237     if [is_elf64 tmpdir/copytest.o] {
1238         set elf64 "--defsym ELF64=1"
1239         run_dump_test "note-2-64"
1240         run_dump_test "note-3-64"
1241         run_dump_test "note-4-64"
1242         run_dump_test "note-6-64"
1243     } else {
1244         run_dump_test "note-2-32"
1245         run_dump_test "note-3-32"
1246         run_dump_test "note-4-32"
1247         run_dump_test "note-6-32"
1248     }
1249     run_dump_test "note-5"
1250 }
1251
1252 run_dump_test "copy-2"
1253 run_dump_test "copy-3"
1254 run_dump_test "copy-4"
1255 run_dump_test "copy-5"
1256 run_dump_test "copy-6"
1257
1258 # Use bintest.o from the copy-4 test to determine ELF reloc type
1259 set reloc_format rel
1260 if { [is_elf_format] && [is_rela tmpdir/bintest.o] } {
1261     set reloc_format rela
1262 }
1263 run_dump_test "pr19020a"
1264 run_dump_test "pr19020b"
1265
1266 if [is_elf_format] {
1267     run_dump_test "strip-1"
1268     run_dump_test "strip-2"
1269     run_dump_test "strip-3"
1270     run_dump_test "strip-4"
1271     run_dump_test "strip-5"
1272     run_dump_test "strip-6"
1273     run_dump_test "strip-7"
1274     run_dump_test "strip-8"
1275     run_dump_test "strip-9"
1276     run_dump_test "strip-12"
1277
1278     if { [istarget "mips64*-*-openbsd*"] \
1279          || [istarget "mips64*-*-*-gnuabi64"] } {
1280         set reloc_format mips64
1281     }
1282     # A relocation type not supported by any target
1283     if { [istarget "nds32*-*"] } {
1284         set reloc 255
1285     } else {
1286         set reloc 215
1287     }
1288     run_dump_test "strip-13" [list \
1289                                   [list source strip-13${reloc_format}.s] \
1290                                   [list as "${elf64} --defsym RELOC=${reloc}"]]
1291     # Select a relocation number that corresponds to one actually
1292     # supported by the target and ABI being tested.
1293     if { [istarget "aarch64*-*"] } {
1294         set reloc 259
1295     } elseif { [istarget "ia64*-*"] \
1296                || [istarget "m32r*-*"] \
1297                || [istarget "nds32*-*"] \
1298                || [istarget "v850*-*"] } {
1299         set reloc 50
1300     } elseif { [istarget "pru-*"] } {
1301         set reloc 11
1302     } else {
1303         set reloc 1
1304     }
1305     run_dump_test "strip-14" [list \
1306                                   [list source strip-14${reloc_format}.s] \
1307                                   [list as "${elf64} --defsym RELOC=${reloc}"]]
1308     run_dump_test "strip-15" [list \
1309                                   [list source strip-15${reloc_format}.s] \
1310                                   [list as "${elf64} --defsym RELOC=${reloc}"]]
1311
1312     # This requires STB_GNU_UNIQUE support with OSABI set to GNU.
1313     if { [supports_gnu_unique] } {
1314         run_dump_test "strip-10"
1315     }
1316     run_dump_test "strip-11"
1317
1318     if { [istarget "i*86-*"] || [istarget "x86_64-*-*"] } {
1319         # Check to make sure we don't strip a symbol named in relocations.
1320         set test "objcopy keeps symbols needed by relocs"
1321
1322         set srcfile $srcdir/$subdir/needed-by-reloc.s
1323
1324         if {![binutils_assemble $srcfile tmpdir/bintest.o]} then {
1325             unsupported $test
1326         } else {
1327             set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS --strip-symbol=foo tmpdir/bintest.o ${copyfile}.o"]
1328
1329             if [regexp "not stripping symbol `foo' because it is named in a relocation" $got] {
1330                 pass $test
1331             } else {
1332                 fail $test
1333             }
1334         }
1335     }
1336
1337     # The symbol table for some MIPS targets is sorted differently than
1338     # the ELF canonical order, so the regexps in localize-hidden-1.d fail
1339     # to match.
1340     if { [is_bad_symtab] } then {
1341         setup_xfail "*-*-*"
1342     }
1343     run_dump_test "localize-hidden-1"
1344     run_dump_test "testranges"
1345     run_dump_test "testranges-ia64"
1346
1347     run_dump_test "add-section"
1348     run_dump_test "add-symbol"
1349     run_dump_test "add-empty-section"
1350
1351     run_dump_test "exclude-1a"
1352     run_dump_test "exclude-1b"
1353
1354     run_dump_test "only-section-01"
1355     run_dump_test "remove-section-01"
1356
1357     run_dump_test "keep-section-1"
1358     run_dump_test "keep-section-2"
1359
1360     # Test the remove relocation functionality
1361     set test_list [lsort [glob -nocomplain $srcdir/$subdir/remove-relocs-*.d]]
1362     foreach t $test_list {
1363         # We need to strip the ".d", but can leave the dirname.
1364         verbose [file rootname $t]
1365         run_dump_test [file rootname $t]
1366     }
1367
1368     # Test --strip-section-headers
1369     run_dump_test "strip-section-headers-1" [list \
1370                           [list source strip-15${reloc_format}.s] \
1371                           [list as "${elf64} --defsym RELOC=${reloc}"]]
1372 }
1373 run_dump_test "localize-hidden-2"
1374
1375 # Test objcopying an object file without global symbol
1376
1377 proc objcopy_test_without_global_symbol { } {
1378     global OBJCOPY
1379     global OBJCOPYFLAGS
1380     global OBJDUMP
1381     global OBJDUMPFLAGS
1382     global srcdir
1383     global subdir
1384
1385     set test "strip without global symbol "
1386
1387     if { [target_compile $srcdir/$subdir/pr19547.c tmpdir/pr19547.o object debug] != "" } {
1388         untested $test
1389         return
1390     }
1391
1392     if [is_remote host] {
1393         set objfile [remote_download host tmpdir/pr19547.o]
1394     } else {
1395         set objfile tmpdir/pr19547.o
1396     }
1397
1398     set exec_output [binutils_run $OBJCOPY "$OBJCOPYFLAGS --strip-unneeded $objfile"]
1399     set exec_output [prune_warnings $exec_output]
1400     if ![string equal "" $exec_output] {
1401         fail $test
1402         return
1403     }
1404
1405     set exec_output [binutils_run $OBJDUMP "$OBJDUMPFLAGS -t $objfile"]
1406     set exec_output [prune_warnings $exec_output]
1407     if {![regexp "no symbols" $exec_output]} {
1408         fail $test
1409         return
1410     }
1411
1412     pass $test
1413 }
1414
1415 # The AArch64 and ARM targets preserve mapping symbols
1416 # in object files, so they will fail this test.
1417 setup_xfail aarch64*-*-* arm*-*-*
1418
1419 objcopy_test_without_global_symbol
1420
1421 # objcopy remove relocation from executable test
1422
1423 proc objcopy_remove_relocations_from_executable { } {
1424     global OBJCOPY
1425     global srcdir
1426     global subdir
1427     global READELF
1428
1429     set test "remove-section relocation sections"
1430
1431     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/pr23611 executable debug] != "" } {
1432         untested $test
1433         return
1434     }
1435
1436     if [is_remote host] {
1437         set objfile [remote_download host tmpdir/pr23611]
1438     } else {
1439         set objfile tmpdir/pr23611
1440     }
1441     set out tmpdir/pr23611.out
1442
1443     set exec_output1 [binutils_run $OBJCOPY "-R .rela.plt -R .rela.dyn -R .rel.plt -R .rel.dyn $objfile $out"]
1444
1445     set exec_output1 [prune_warnings $exec_output1]
1446     if ![string equal "" $exec_output1] {
1447         fail $test
1448         return
1449     }
1450
1451     set exec_output2 [binutils_run $READELF "-S $out"]
1452     if { [string match "*.rel.plt*" $exec_output2] || [string match "*.rela.plt*" $exec_output2] || [string match "*.rel.dyn*" $exec_output2] || [string match "*.rela.dyn*" $exec_output2] } {
1453         fail $test
1454         return
1455     }
1456     pass $test
1457 }
1458
1459 if [is_elf_format] {
1460     objcopy_remove_relocations_from_executable
1461 }
1462
1463 run_dump_test "pr23633"
1464
1465 run_dump_test "set-section-alignment"
1466 run_dump_test "section-alignment"
1467
1468 setup_xfail "hppa*-*-*"
1469 setup_xfail "spu-*-*"
1470 clear_xfail "hppa*64*-*-hpux*" "hppa*-*-linux*" "hppa*-*-lites*"
1471 clear_xfail "hppa*-*-*n*bsd*" "hppa*-*-*elf*"
1472 if { [istarget pdp11-*-*] } {
1473     set src "pr25662-pdp11.s"
1474 } else {
1475     set src "pr25662.s"
1476 }
1477
1478 set ldflags "-T$srcdir/$subdir/pr25662.ld"
1479 if { [istarget *-*-cygwin] || [istarget *-*-mingw*] } {
1480    append ldflags " --disable-reloc-section"
1481 }
1482
1483 #xcoff doesn't support arbitrary sections
1484 if { ![is_xcoff_format] } {
1485     objcopy_test "pr25662" $src executable "" $ldflags
1486 }
1487
1488 run_dump_test "rename-section-01"