binutils/testsuite/binutils-all/objcopy.exp

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