binutils/testsuite/binutils-all/objcopy.exp

   1 #   Copyright (C) 1994-2023 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 *-*-gnu*] } {
 697         foreach i $gcc_gas_flag {
 698             set flags "additional_flags=$i $flags"
 699         }
 700     }
 701     if { [target_compile "$srcdir/$subdir/testprog.c $add_libs" tmpdir/$test_prog executable $flags]  != "" } {
 702         return 2
 703     }
 704
 705     set result [remote_load target tmpdir/$test_prog]
 706     set status [lindex $result 0]
 707
 708     if { $status != "pass"  } {
 709         send_log "cannot run executable, status = ${status} on ${host_triplet}\n"
 710         return 3
 711     }
 712
 713     return 0
 714 }
 715
 716 # Test copying an executable.
 717
 718 proc copy_executable { prog flags test1 test2 } {
 719     global test_prog
 720
 721     if [is_remote host] {
 722         set testfile [remote_download host tmpdir/$test_prog]
 723         set testcopy copyprog
 724     } else {
 725         set testfile tmpdir/$test_prog
 726         set testcopy tmpdir/copyprog
 727     }
 728     remote_file host delete $testcopy
 729
 730     set exec_output [binutils_run $prog "$flags $testfile $testcopy"]
 731
 732     if ![string equal "" $exec_output] {
 733         fail $test1
 734         if [string equal "" $test2] {
 735             return
 736         }
 737         fail $test2
 738         return
 739     }
 740
 741     if [is_remote host] {
 742         remote_upload host $testcopy tmpdir/copyprog
 743     }
 744
 745     set status [remote_exec build "cmp" "tmpdir/$test_prog tmpdir/copyprog"]
 746     set exec_output [lindex $status 1]
 747
 748     if [string equal "" $exec_output] then {
 749         pass $test1
 750     } else {
 751         send_log "$exec_output\n"
 752         verbose "$exec_output"
 753
 754         # This will fail for many reasons.  For example, it will most
 755         # likely fail if a non-GNU linker is used.  Therefore, we do
 756         # not insist that it pass.  If you are using an assembler and
 757         # linker based on the same BFD as objcopy, it is worth
 758         # investigating to see why this failure occurs.  If we are
 759         # cross compiling, we assume that a GNU linker is being used,
 760         # and expect it to succeed.
 761         if {[isnative]} then {
 762             setup_xfail "*-*-*"
 763         }
 764
 765         # This also fails for some mips targets.  See elf32-mips.c
 766         # mips_elf_sym_is_global.
 767         if { [is_bad_symtab] } then {
 768             setup_xfail "*-*-*"
 769         }
 770
 771         setup_xfail "arm*-*-pe"
 772         setup_xfail "*-*-mingw*"
 773         setup_xfail "*-*-cygwin*"
 774
 775         fail $test1
 776     }
 777
 778     if [string equal "" $test2] {
 779         return
 780     }
 781
 782     set output [remote_load target tmpdir/copyprog]
 783     set status [lindex $output 0]
 784     if { $status != "pass" } {
 785         fail $test2
 786     } else {
 787         pass $test2
 788     }
 789 }
 790
 791 # Test stripping an executable
 792
 793 proc strip_executable { prog flags test1 test2 } {
 794     global NM
 795     global NMFLAGS
 796     global READELF
 797
 798     remote_file build delete tmpdir/striprog
 799     remote_download build tmpdir/copyprog tmpdir/striprog
 800     if [is_remote host] {
 801         set copyfile [remote_download host tmpdir/striprog]
 802     } else {
 803         set copyfile tmpdir/striprog
 804     }
 805
 806     set osabi_fail "false"
 807     if [is_elf_format] {
 808         verbose -log "$READELF -a ${copyfile} > tmpdir/osabi.in"
 809         set exec_output [remote_exec host "$READELF -h ${copyfile}" "" "/dev/null" "tmpdir/osabi.in"]
 810         if { [lindex $exec_output 0] != 0 } then {
 811             fail "$test1 preserving OS/ABI"
 812             set osabi_fail "true"
 813         } else {
 814             verbose -log "grep OS/ABI tmpdir/osabi.in"
 815             catch "exec grep OS/ABI tmpdir/osabi.in" osabi_in
 816         }
 817      }
 818
 819     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 820     if ![string equal "" $exec_output] {
 821         fail $test1
 822         if [string equal "" $test2] {
 823             return
 824         }
 825         fail $test2
 826         return
 827     }
 828
 829     if [is_remote host] {
 830         remote_upload host ${copyfile} tmpdir/striprog
 831     }
 832
 833     if { $osabi_fail != "true" && [is_elf_format] } {
 834         verbose -log "$READELF -a ${copyfile} > tmpdir/osabi.out"
 835         set exec_output [remote_exec host "$READELF -h ${copyfile}" "" "/dev/null" "tmpdir/osabi.out"]
 836         if { [lindex $exec_output 0] != 0 } then {
 837             fail "$test1 preserving OS/ABI"
 838         } else {
 839             verbose -log "grep OS/ABI tmpdir/osabi.out"
 840             catch "exec grep OS/ABI tmpdir/osabi.out" osabi_out
 841             if { "$osabi_in" == "$osabi_out" } {
 842                 pass "$test1 preserving OS/ABI"
 843             } else {
 844                 fail "$test1 preserving OS/ABI"
 845             }
 846         }
 847     }
 848
 849     set exec_output [binutils_run $NM "$NMFLAGS ${copyfile}"]
 850     if ![string match "*: no symbols*" $exec_output] {
 851         fail $test1
 852         return
 853     }
 854
 855     if [string equal "" $test2] {
 856         return
 857     }
 858
 859     set result [remote_load target tmpdir/striprog]
 860     set status [lindex $result 0]
 861     if { $status != "pass" } {
 862         fail $test2
 863         return
 864     }
 865
 866     pass $test2
 867 }
 868
 869 # Test stripping an executable with saving a symbol
 870
 871 proc strip_executable_with_saving_a_symbol { prog flags test1 test2 } {
 872     global NM
 873     global NMFLAGS
 874
 875     remote_file build delete tmpdir/striprog
 876     remote_download build tmpdir/copyprog tmpdir/striprog
 877     if [is_remote host] {
 878         set copyfile [remote_download host tmpdir/striprog]
 879     } else {
 880         set copyfile tmpdir/striprog
 881     }
 882
 883     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 884     if ![string equal "" $exec_output] {
 885         fail $test1
 886         if [string equal "" $test2] {
 887             return
 888         }
 889         fail $test2
 890         return
 891     }
 892
 893     set exec_output [binutils_run $NM "$NMFLAGS ${copyfile}"]
 894     if { [istarget mmix-knuth-mmixware] } {
 895         # Whenever there's a symbol in the mmo format, there's the symbol
 896         # Main, so remove it manually from the expected output for sake of
 897         # this test.
 898
 899         # Using "" not {} to get the \n and \r translated.
 900         regsub "^\[0-9a-fA-F\]+\[ \]+T Main\[\n\r\]+" $exec_output "" exec_output
 901     }
 902
 903     if {![regexp {^([0-9a-fA-F]+)?[ ]+[TtDd] _?main} $exec_output]} {
 904         fail $test1
 905         return
 906     }
 907
 908     if [string equal "" $test2] {
 909         return
 910     }
 911
 912     if [is_remote host] {
 913         remote_upload host ${copyfile} tmpdir/striprog
 914     }
 915
 916     set result [remote_load target tmpdir/striprog]
 917     set status [lindex $result 0]
 918     if { $status != "pass" } {
 919         fail $test2
 920         return
 921     }
 922
 923     pass $test2
 924 }
 925
 926 # Test keeping only debug symbols of an executable
 927
 928 proc keep_debug_symbols_and_test_copy { prog1 flags1 test1 prog2 flags2 test2 } {
 929     remote_file build delete tmpdir/striprog
 930     remote_download build tmpdir/copyprog tmpdir/striprog
 931     if [is_remote host] {
 932         set copyfile [remote_download host tmpdir/striprog]
 933     } else {
 934         set copyfile tmpdir/striprog
 935     }
 936
 937     set exec_output [binutils_run $prog1 "$flags1 ${copyfile}"]
 938     if ![string equal "" $exec_output] {
 939         fail $test1
 940         return
 941     }
 942     pass $test1
 943
 944     set exec_output [binutils_run $prog2 "$flags2 ${copyfile}"]
 945     if ![string equal "" $exec_output] {
 946         fail $test2
 947         return
 948     }
 949     pass $test2
 950 }
 951
 952 # Tests that in a debug only copy of a file the sections
 953 # headers whose types have been changed to NOBITS still
 954 # retain their sh_link fields.
 955
 956 proc keep_debug_symbols_and_check_links { prog flags test } {
 957     global READELF
 958
 959     remote_file build delete tmpdir/striprog
 960     remote_download build tmpdir/copyprog tmpdir/striprog
 961     if [is_remote host] {
 962         set copyfile [remote_download host tmpdir/striprog]
 963     } else {
 964         set copyfile tmpdir/striprog
 965     }
 966
 967     set exec_output [binutils_run $prog "$flags ${copyfile}"]
 968     if ![string equal "" $exec_output] {
 969         fail $test
 970         return
 971     }
 972
 973     set got [binutils_run $READELF "-S --wide ${copyfile}"]
 974
 975     set fails 0
 976     # Regexp to match a section with NOBITS type and extract its name and sh_link fields
 977     while {[regexp \
 978                 {[^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]+)(.*)} \
 979                 $got all name link rest]} {
 980         set sh_link 0x$link
 981         if {$sh_link == 0} {
 982             # Only some NOBITS sections should have a non-zero sh_link field.
 983             # Look for them by name.
 984             verbose "NOBITS section .$name has a 0 sh_link field\n"
 985             switch $name {
 986                 "rela.*"        { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 987                 "rel.*"         { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 988                 "hash"          { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 989                 "gnu_version"   { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 990                 "dynsym"        { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 991                 "gnu.version_r" { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 992                 "dynamic"       { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 993                 "symtab"        { set fails 1 ; send_log "Expected non-zero sh_link for .$name\n" }
 994             }
 995         }
 996         set got $rest
 997     }
 998
 999     if {$fails == 0} {
1000         pass $test
1001     } else {
1002         fail $test
1003     }
1004 }
1005
1006 # For ELF relocatables, test that --only-keep-debug
1007 # marks non-debug output sections as NOBITS.
1008
1009 proc keep_debug_symbols_for_elf_relocatable { prog flags test } {
1010     global srcdir
1011     global subdir
1012     global READELF
1013
1014     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
1015         untested $test
1016         return
1017     }
1018
1019     if [is_remote host] {
1020         set relocatable [remote_download host tmpdir/testprog.o]
1021     } else {
1022         set relocatable tmpdir/testprog.o
1023     }
1024
1025     set non_debug_sections {}
1026     set got [binutils_run $READELF "-S --wide ${relocatable}"]
1027     while { [regexp \
1028             {[^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]+(.*)} \
1029             $got all name type flag rest] } {
1030         if { $type != "NOTE" && [regexp {[AG]} $flag] } {
1031             # PR 30699: Some debug sections can be in a group, so
1032             # exclude sections whose name includes "debug_"
1033             if { ! [regexp {debug_} $name] } {
1034                 lappend non_debug_sections $name
1035             }
1036         }
1037         set got $rest
1038     }
1039
1040     set exec_output [binutils_run $prog "$flags ${relocatable}"]
1041     if ![string equal "" $exec_output] {
1042         fail $test
1043         return
1044     }
1045
1046     set fails 0
1047     set got [binutils_run $READELF "-S --wide ${relocatable}"]
1048     while { [regexp \
1049             {[^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]+(.*)} \
1050             $got all name type rest] } {
1051         if { [lsearch -exact $non_debug_sections $name] >= 0 && $type != "NOBITS" } {
1052             set fails 1
1053             send_log "Expected SHT_NOBITS type for .$name\n"
1054         }
1055         set got $rest
1056     }
1057     if { $fails == 1 } {
1058         fail $test
1059         return
1060     }
1061
1062     pass $test
1063 }
1064
1065 set test1 "simple objcopy of executable"
1066 set test1r "run objcopy of executable"
1067 set test2 "strip executable"
1068 set test2r "run stripped executable"
1069 set test3 "strip executable with saving a symbol"
1070 set test3r "run stripped executable with saving a symbol"
1071 set test4 "keep only debug data"
1072 set test5 "simple objcopy of debug data"
1073 if [is_elf_format] {
1074     set test6 "NOBITS sections retain sh_link field"
1075     set test7 "--only-keep-debug for ELF relocatables"
1076 }
1077
1078 switch [copy_setup] {
1079     "1" {
1080         # do nothing
1081     }
1082     "2" {
1083         untested $test1
1084         untested $test1r
1085         untested $test2
1086         untested $test2r
1087         untested $test3
1088         untested $test3r
1089         untested $test4
1090         untested $test5
1091         if [is_elf_format] {
1092             untested $test6
1093             untested $test7
1094         }
1095     }
1096     "3" {
1097         copy_executable "$OBJCOPY" "$OBJCOPYFLAGS" "$test1" ""
1098         unsupported $test1r
1099         strip_executable "$STRIP" "$STRIPFLAGS" "$test2" ""
1100         unsupported $test2r
1101         strip_executable_with_saving_a_symbol "$STRIP" "-K main -K _main $STRIPFLAGS" "$test3" ""
1102         unsupported $test3r
1103         keep_debug_symbols_and_test_copy "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test4" \
1104                                          "$OBJCOPY" "$OBJCOPYFLAGS" "$test5"
1105         if [is_elf_format] {
1106             keep_debug_symbols_and_check_links "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test6"
1107             keep_debug_symbols_for_elf_relocatable "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test7"
1108         }
1109     }
1110     "0" {
1111         copy_executable "$OBJCOPY" "$OBJCOPYFLAGS" "$test1" "$test1r"
1112         strip_executable "$STRIP" "$STRIPFLAGS" "$test2" "$test2r"
1113         strip_executable_with_saving_a_symbol "$STRIP" "-K main -K _main $STRIPFLAGS" "$test3" "$test3r"
1114         keep_debug_symbols_and_test_copy "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test4" \
1115                                          "$OBJCOPY" "$OBJCOPYFLAGS" "$test5"
1116         if [is_elf_format] {
1117             keep_debug_symbols_and_check_links "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test6"
1118             keep_debug_symbols_for_elf_relocatable "$STRIP" "--only-keep-debug $STRIPFLAGS" "$test7"
1119         }
1120     }
1121 }
1122
1123 proc objcopy_test_readelf {testname srcfile} {
1124     global OBJCOPY
1125     global OBJCOPYFLAGS
1126     global READELF
1127     global srcdir
1128     global subdir
1129
1130     if {![binutils_assemble $srcdir/$subdir/${srcfile} tmpdir/bintest.o]} then {
1131         unsupported "objcopy ($testname)"
1132         return
1133     }
1134
1135     verbose -log "$OBJCOPY $OBJCOPYFLAGS tmpdir/bintest.o tmpdir/copy.o"
1136     set exec_output [remote_exec host "$OBJCOPY $OBJCOPYFLAGS tmpdir/bintest.o tmpdir/copy.o"]
1137     if { [lindex $exec_output 0] != 0
1138          || ![string equal "" [lindex $exec_output 1]] } then {
1139         fail "objcopy ($testname)"
1140         return
1141     }
1142
1143     verbose -log "$READELF -a tmpdir/bintest.o > tmpdir/bintest.o.out"
1144     set exec_output [remote_exec host "$READELF -a tmpdir/bintest.o" "" "/dev/null" "tmpdir/bintest.o.out"]
1145     if { [lindex $exec_output 0] != 0 } then {
1146         fail "objcopy ($testname)"
1147         return
1148     }
1149     set exec_output [prune_warnings [lindex $exec_output 1]]
1150     if ![string equal "" $exec_output] then {
1151         unresolved "objcopy ($testname)"
1152         return
1153     }
1154
1155     verbose -log "$READELF -a tmpdir/copy.o > tmpdir/copy.o.out"
1156     set exec_output [remote_exec host "$READELF -a tmpdir/copy.o" "" "/dev/null" "tmpdir/copy.o.out"]
1157     if { [lindex $exec_output 0] != 0 } then {
1158         fail "objcopy ($testname)"
1159         return
1160     }
1161     set exec_output [prune_warnings [lindex $exec_output 1]]
1162     if ![string equal "" $exec_output] then {
1163         unresolved "objcopy ($testname)"
1164         return
1165     }
1166
1167     verbose -log "diff tmpdir/bintest.o.out tmpdir/copy.o.out"
1168     catch "exec diff tmpdir/bintest.o.out tmpdir/copy.o.out" exec_output
1169     set exec_output [prune_warnings $exec_output]
1170
1171     if [string equal "" $exec_output] then {
1172         pass "objcopy ($testname)"
1173     } else {
1174         fail "objcopy ($testname)"
1175     }
1176 }
1177
1178 proc objcopy_test_symbol_manipulation {} {
1179     global srcdir
1180     global subdir
1181
1182     set test_list [lsort [glob -nocomplain $srcdir/$subdir/symbols-*.d]]
1183     foreach t $test_list {
1184         # We need to strip the ".d", but can leave the dirname.
1185         verbose [file rootname $t]
1186         run_dump_test [file rootname $t]
1187     }
1188
1189     if { [supports_gnu_unique] } {
1190         run_dump_test "weaken-gnu-unique"
1191     }
1192 }
1193
1194 proc objcopy_test_elf_common_symbols {} {
1195     global srcdir
1196     global subdir
1197
1198     # hpux has a non-standard common directive.
1199     if { [istarget "*-*-hpux*"] } then {
1200         return
1201     }
1202
1203     set test_list [lsort [glob -nocomplain $srcdir/$subdir/common-*.d]]
1204     foreach t $test_list {
1205         # We need to strip the ".d", but can leave the dirname.
1206         verbose [file rootname $t]
1207         run_dump_test [file rootname $t]
1208     }
1209 }
1210
1211 # ia64 specific tests
1212 if { ([istarget "ia64-*-elf*"]
1213        || [istarget "ia64-*-linux*"]) } {
1214     objcopy_test "ia64 link order" link-order.s object "" ""
1215 }
1216
1217 # ELF specific tests
1218 set elf64 ""
1219 if [is_elf_format] {
1220     objcopy_test_symbol_manipulation
1221     objcopy_test_elf_common_symbols
1222     objcopy_test "ELF unknown section type" unknown.s object "" ""
1223     objcopy_test_readelf "ELF group 1" group.s
1224     objcopy_test_readelf "ELF group 2" group-2.s
1225     objcopy_test_readelf "ELF group 3" group-3.s
1226     objcopy_test_readelf "ELF group 4" group-4.s
1227     objcopy_test_readelf "GNU_MBIND section" mbind1.s
1228     run_dump_test "group-5"
1229     run_dump_test "group-6"
1230     run_dump_test "group-7a"
1231     run_dump_test "group-7b"
1232     run_dump_test "group-7c"
1233     run_dump_test "copy-1"
1234     run_dump_test "note-1"
1235     # Use copytest.o from the note-1 test to determine ELF32 or ELF64
1236     if [is_elf64 tmpdir/copytest.o] {
1237         set elf64 "--defsym ELF64=1"
1238         run_dump_test "note-2-64"
1239         run_dump_test "note-3-64"
1240         run_dump_test "note-4-64"
1241         run_dump_test "note-6-64"
1242     } else {
1243         run_dump_test "note-2-32"
1244         run_dump_test "note-3-32"
1245         run_dump_test "note-4-32"
1246         run_dump_test "note-6-32"
1247     }
1248     run_dump_test "note-5"
1249 }
1250
1251 run_dump_test "copy-2"
1252 run_dump_test "copy-3"
1253 run_dump_test "copy-4"
1254 run_dump_test "copy-5"
1255 run_dump_test "copy-6"
1256
1257 # Use bintest.o from the copy-4 test to determine ELF reloc type
1258 set reloc_format rel
1259 if { [is_elf_format] && [is_rela tmpdir/bintest.o] } {
1260     set reloc_format rela
1261 }
1262 run_dump_test "pr19020a"
1263 run_dump_test "pr19020b"
1264
1265 if [is_elf_format] {
1266     run_dump_test "strip-1"
1267     run_dump_test "strip-2"
1268     run_dump_test "strip-3"
1269     run_dump_test "strip-4"
1270     run_dump_test "strip-5"
1271     run_dump_test "strip-6"
1272     run_dump_test "strip-7"
1273     run_dump_test "strip-8"
1274     run_dump_test "strip-9"
1275     run_dump_test "strip-12"
1276
1277     if { [istarget "mips64*-*-openbsd*"] \
1278          || [istarget "mips64*-*-*-gnuabi64"] } {
1279         set reloc_format mips64
1280     }
1281     # A relocation type not supported by any target
1282     if { [istarget "nds32*-*"] } {
1283         set reloc 255
1284     } else {
1285         set reloc 215
1286     }
1287     run_dump_test "strip-13" [list \
1288                                   [list source strip-13${reloc_format}.s] \
1289                                   [list as "${elf64} --defsym RELOC=${reloc}"]]
1290     # Select a relocation number that corresponds to one actually
1291     # supported by the target and ABI being tested.
1292     if { [istarget "aarch64*-*"] } {
1293         set reloc 259
1294     } elseif { [istarget "ia64*-*"] \
1295                || [istarget "m32r*-*"] \
1296                || [istarget "nds32*-*"] \
1297                || [istarget "v850*-*"] } {
1298         set reloc 50
1299     } elseif { [istarget "pru-*"] } {
1300         set reloc 11
1301     } else {
1302         set reloc 1
1303     }
1304     run_dump_test "strip-14" [list \
1305                                   [list source strip-14${reloc_format}.s] \
1306                                   [list as "${elf64} --defsym RELOC=${reloc}"]]
1307     run_dump_test "strip-15" [list \
1308                                   [list source strip-15${reloc_format}.s] \
1309                                   [list as "${elf64} --defsym RELOC=${reloc}"]]
1310
1311     # This requires STB_GNU_UNIQUE support with OSABI set to GNU.
1312     if { [supports_gnu_unique] } {
1313         run_dump_test "strip-10"
1314     }
1315     run_dump_test "strip-11"
1316
1317     if { [istarget "i*86-*"] || [istarget "x86_64-*-*"] } {
1318         # Check to make sure we don't strip a symbol named in relocations.
1319         set test "objcopy keeps symbols needed by relocs"
1320
1321         set srcfile $srcdir/$subdir/needed-by-reloc.s
1322
1323         if {![binutils_assemble $srcfile tmpdir/bintest.o]} then {
1324             unsupported $test
1325         } else {
1326             set got [binutils_run $OBJCOPY "$OBJCOPYFLAGS --strip-symbol=foo tmpdir/bintest.o ${copyfile}.o"]
1327
1328             if [regexp "not stripping symbol `foo' because it is named in a relocation" $got] {
1329                 pass $test
1330             } else {
1331                 fail $test
1332             }
1333         }
1334     }
1335
1336     # The symbol table for some MIPS targets is sorted differently than
1337     # the ELF canonical order, so the regexps in localize-hidden-1.d fail
1338     # to match.
1339     if { [is_bad_symtab] } then {
1340         setup_xfail "*-*-*"
1341     }
1342     run_dump_test "localize-hidden-1"
1343     run_dump_test "testranges"
1344     run_dump_test "testranges-ia64"
1345
1346     run_dump_test "add-section"
1347     run_dump_test "add-symbol"
1348     run_dump_test "add-empty-section"
1349
1350     run_dump_test "exclude-1a"
1351     run_dump_test "exclude-1b"
1352
1353     run_dump_test "only-section-01"
1354     run_dump_test "remove-section-01"
1355
1356     run_dump_test "keep-section-1"
1357     run_dump_test "keep-section-2"
1358
1359     # Test the remove relocation functionality
1360     set test_list [lsort [glob -nocomplain $srcdir/$subdir/remove-relocs-*.d]]
1361     foreach t $test_list {
1362         # We need to strip the ".d", but can leave the dirname.
1363         verbose [file rootname $t]
1364         run_dump_test [file rootname $t]
1365     }
1366
1367     # Test --strip-section-headers
1368     run_dump_test "strip-section-headers-1" [list \
1369                           [list source strip-15${reloc_format}.s] \
1370                           [list as "${elf64} --defsym RELOC=${reloc}"]]
1371 }
1372 run_dump_test "localize-hidden-2"
1373
1374 # Test objcopying an object file without global symbol
1375
1376 proc objcopy_test_without_global_symbol { } {
1377     global OBJCOPY
1378     global OBJCOPYFLAGS
1379     global OBJDUMP
1380     global OBJDUMPFLAGS
1381     global srcdir
1382     global subdir
1383
1384     set test "strip without global symbol "
1385
1386     if { [target_compile $srcdir/$subdir/pr19547.c tmpdir/pr19547.o object debug] != "" } {
1387         untested $test
1388         return
1389     }
1390
1391     if [is_remote host] {
1392         set objfile [remote_download host tmpdir/pr19547.o]
1393     } else {
1394         set objfile tmpdir/pr19547.o
1395     }
1396
1397     set exec_output [binutils_run $OBJCOPY "$OBJCOPYFLAGS --strip-unneeded $objfile"]
1398     set exec_output [prune_warnings $exec_output]
1399     if ![string equal "" $exec_output] {
1400         fail $test
1401         return
1402     }
1403
1404     set exec_output [binutils_run $OBJDUMP "$OBJDUMPFLAGS -t $objfile"]
1405     set exec_output [prune_warnings $exec_output]
1406     if {![regexp "no symbols" $exec_output]} {
1407         fail $test
1408         return
1409     }
1410
1411     pass $test
1412 }
1413
1414 # The AArch64 and ARM targets preserve mapping symbols
1415 # in object files, so they will fail this test.
1416 setup_xfail aarch64*-*-* arm*-*-*
1417
1418 objcopy_test_without_global_symbol
1419
1420 # objcopy remove relocation from executable test
1421
1422 proc objcopy_remove_relocations_from_executable { } {
1423     global OBJCOPY
1424     global srcdir
1425     global subdir
1426     global READELF
1427
1428     set test "remove-section relocation sections"
1429
1430     if { [target_compile $srcdir/$subdir/testprog.c tmpdir/pr23611 executable debug] != "" } {
1431         untested $test
1432         return
1433     }
1434
1435     if [is_remote host] {
1436         set objfile [remote_download host tmpdir/pr23611]
1437     } else {
1438         set objfile tmpdir/pr23611
1439     }
1440     set out tmpdir/pr23611.out
1441
1442     set exec_output1 [binutils_run $OBJCOPY "-R .rela.plt -R .rela.dyn -R .rel.plt -R .rel.dyn $objfile $out"]
1443
1444     set exec_output1 [prune_warnings $exec_output1]
1445     if ![string equal "" $exec_output1] {
1446         fail $test
1447         return
1448     }
1449
1450     set exec_output2 [binutils_run $READELF "-S $out"]
1451     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] } {
1452         fail $test
1453         return
1454     }
1455     pass $test
1456 }
1457
1458 if [is_elf_format] {
1459     objcopy_remove_relocations_from_executable
1460 }
1461
1462 run_dump_test "pr23633"
1463
1464 run_dump_test "set-section-alignment"
1465
1466 setup_xfail "hppa*-*-*"
1467 setup_xfail "spu-*-*"
1468 clear_xfail "hppa*64*-*-hpux*" "hppa*-*-linux*" "hppa*-*-lites*"
1469 clear_xfail "hppa*-*-*n*bsd*" "hppa*-*-*elf*"
1470 if { [istarget pdp11-*-*] } {
1471     set src "pr25662-pdp11.s"
1472 } else {
1473     set src "pr25662.s"
1474 }
1475
1476 set ldflags "-T$srcdir/$subdir/pr25662.ld"
1477 if { [istarget *-*-cygwin] || [istarget *-*-mingw*] } {
1478    append ldflags " --disable-reloc-section"
1479 }
1480
1481 #xcoff doesn't support arbitrary sections
1482 if { ![is_xcoff_format] } {
1483     objcopy_test "pr25662" $src executable "" $ldflags
1484 }
1485
1486 run_dump_test "rename-section-01"