ld/testsuite/lib/ld-lib.exp

   1 # Support routines for LD testsuite.
   2 #   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   3 #    2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4 #    Free Software Foundation, Inc.
   5 #
   6 # This file is part of the GNU Binutils.
   7 #
   8 # This file is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 3 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 # MA 02110-1301, USA.
  22
  23 proc load_common_lib { name } {
  24     global srcdir
  25     load_file $srcdir/../../binutils/testsuite/lib/$name
  26 }
  27
  28 load_common_lib binutils-common.exp
  29
  30 # Extract and print the version number of ld.
  31 #
  32 proc default_ld_version { ld } {
  33     global host_triplet
  34
  35     if { ![is_remote host] && [which $ld] == 0 } then {
  36         perror "$ld does not exist"
  37         exit 1
  38     }
  39
  40     remote_exec host "$ld --version" "" "/dev/null" "ld.version"
  41     remote_upload host "ld.version"
  42     set tmp [prune_warnings [file_contents "ld.version"]]
  43     remote_file build delete "ld.version"
  44     remote_file host delete "ld.version"
  45
  46     regexp "\[^\n\]* (cygnus-|)(\[-0-9.a-zA-Z-\]+)\[\r\n\].*" $tmp version cyg number
  47     if [info exists number] then {
  48         clone_output "$ld $number\n"
  49     }
  50 }
  51
  52 proc run_host_cmd { prog command } {
  53     global link_output
  54
  55     if { ![is_remote host] && [which "$prog"] == 0 } then {
  56         perror "$prog does not exist"
  57         return 0
  58     }
  59
  60     verbose -log "$prog $command"
  61     set status [remote_exec host [concat sh -c [list "$prog $command 2>&1"]] "" "/dev/null" "ld.tmp"]
  62     remote_upload host "ld.tmp"
  63     set link_output [file_contents "ld.tmp"]
  64     regsub "\n$" $link_output "" link_output
  65     if { [lindex $status 0] != 0 && [string match "" $link_output] } then {
  66         append link_output "child process exited abnormally"
  67     }
  68     remote_file build delete ld.tmp
  69     remote_file host delete ld.tmp
  70
  71     if [string match "" $link_output] then {
  72         return ""
  73     }
  74
  75     verbose -log "$link_output"
  76     return "$link_output"
  77 }
  78
  79 proc run_host_cmd_yesno { prog command } {
  80     global exec_output
  81
  82     set exec_output [prune_warnings [run_host_cmd "$prog" "$command"]]
  83     if [string match "" $exec_output] then {
  84         return 1;
  85     }
  86     return 0;
  87 }
  88
  89 # Link an object using relocation.
  90 #
  91 proc default_ld_relocate { ld target objects } {
  92     global HOSTING_EMU
  93
  94     remote_file host delete $target
  95     return [run_host_cmd_yesno "$ld" "$HOSTING_EMU -o $target -r $objects"]
  96 }
  97
  98 # Check to see if ld is being invoked with a non-endian output format
  99 #
 100 proc is_endian_output_format { object_flags } {
 101
 102     if {[string match "*-oformat binary*" $object_flags] ||      \
 103         [string match "*-oformat ieee*" $object_flags] ||        \
 104         [string match "*-oformat ihex*" $object_flags] ||        \
 105         [string match "*-oformat netbsd-core*" $object_flags] || \
 106         [string match "*-oformat srec*" $object_flags] ||        \
 107         [string match "*-oformat tekhex*" $object_flags] ||      \
 108         [string match "*-oformat trad-core*" $object_flags] } then {
 109         return 0
 110     } else {
 111         return 1
 112     }
 113 }
 114
 115 # Look for big-endian or little-endian switches in the multlib
 116 # options and translate these into a -EB or -EL switch.  Note
 117 # we cannot rely upon proc process_multilib_options to do this
 118 # for us because for some targets the compiler does not support
 119 # -EB/-EL but it does support -mbig-endian/-mlittle-endian, and
 120 # the site.exp file will include the switch "-mbig-endian"
 121 # (rather than "big-endian") which is not detected by proc
 122 # process_multilib_options.
 123 #
 124 proc big_or_little_endian {} {
 125
 126     if [board_info [target_info name] exists multilib_flags] {
 127         set tmp_flags " [board_info [target_info name] multilib_flags]"
 128
 129         foreach x $tmp_flags {
 130             case $x in {
 131                 {*big*endian eb EB -eb -EB -mb -meb} {
 132                     set flags " -EB"
 133                     return $flags
 134                 }
 135                 {*little*endian el EL -el -EL -ml -mel} {
 136                     set flags " -EL"
 137                     return $flags
 138                 }
 139             }
 140         }
 141     }
 142
 143     set flags ""
 144     return $flags
 145 }
 146
 147 # Link a program using ld.
 148 #
 149 proc default_ld_link { ld target objects } {
 150     global HOSTING_EMU
 151     global HOSTING_CRT0
 152     global HOSTING_LIBS
 153     global LIBS
 154     global host_triplet
 155     global link_output
 156     global exec_output
 157
 158     set objs "$HOSTING_CRT0 $objects"
 159     set libs "$LIBS $HOSTING_LIBS"
 160
 161     if [is_endian_output_format $objects] then {
 162         set flags [big_or_little_endian]
 163     } else {
 164         set flags ""
 165     }
 166
 167     remote_file host delete $target
 168
 169     return [run_host_cmd_yesno "$ld" "$HOSTING_EMU $flags -o $target $objs $libs"]
 170 }
 171
 172 # Link a program using ld, without including any libraries.
 173 #
 174 proc default_ld_simple_link { ld target objects } {
 175     global host_triplet
 176     global gcc_ld_flag
 177     global exec_output
 178
 179     if [is_endian_output_format $objects] then {
 180         set flags [big_or_little_endian]
 181     } else {
 182         set flags ""
 183     }
 184
 185     # If we are compiling with gcc, we want to add gcc_ld_flag to
 186     # flags.  Rather than determine this in some complex way, we guess
 187     # based on the name of the compiler.
 188     set ldexe $ld
 189     set ldparm [string first " " $ld]
 190     set ldflags ""
 191     if { $ldparm > 0 } then {
 192         set ldflags [string range $ld $ldparm end]
 193         set ldexe [string range $ld 0 $ldparm]
 194         set ld $ldexe
 195     }
 196     set ldexe [string replace $ldexe 0 [string last "/" $ldexe] ""]
 197     if {[string match "*gcc*" $ldexe] || [string match "*++*" $ldexe]} then {
 198         set ldflags "$gcc_ld_flag $ldflags"
 199     }
 200
 201     remote_file host delete $target
 202
 203     set exec_output [run_host_cmd "$ld" "$ldflags $flags -o $target $objects"]
 204     set exec_output [prune_warnings $exec_output]
 205
 206     # We don't care if we get a warning about a non-existent start
 207     # symbol, since the default linker script might use ENTRY.
 208     regsub -all "(^|\n)(\[^\n\]*: warning: cannot find entry symbol\[^\n\]*\n?)" $exec_output "\\1" exec_output
 209
 210     if [string match "" $exec_output] then {
 211         return 1
 212     } else {
 213         return 0
 214     }
 215 }
 216
 217 # Compile an object using cc.
 218 #
 219 proc default_ld_compile { cc source object } {
 220     global CFLAGS
 221     global CXXFLAGS
 222     global srcdir
 223     global subdir
 224     global host_triplet
 225     global gcc_gas_flag
 226
 227     set cc_prog $cc
 228     if {[llength $cc_prog] > 1} then {
 229         set cc_prog [lindex $cc_prog 0]
 230     }
 231     if {![is_remote host] && [which $cc_prog] == 0} then {
 232         perror "$cc_prog does not exist"
 233         return 0
 234     }
 235
 236     remote_file build delete "$object"
 237     remote_file host delete "$object"
 238
 239     set flags "-I$srcdir/$subdir"
 240
 241     # If we are compiling with gcc, we want to add gcc_gas_flag to
 242     # flags.  Rather than determine this in some complex way, we guess
 243     # based on the name of the compiler.
 244     set ccexe $cc
 245     set ccparm [string first " " $cc]
 246     set ccflags ""
 247     if { $ccparm > 0 } then {
 248         set ccflags [string range $cc $ccparm end]
 249         set ccexe [string range $cc 0 $ccparm]
 250         set cc $ccexe
 251     }
 252     set ccexe [string replace $ccexe 0 [string last "/" $ccexe] ""]
 253     if {[string match "*gcc*" $ccexe] || [string match "*++*" $ccexe]} then {
 254         set flags "$gcc_gas_flag $flags"
 255     }
 256
 257     if {[string match "*++*" $ccexe]} {
 258         set flags "$flags $CXXFLAGS"
 259     } else {
 260         set flags "$flags $CFLAGS"
 261     }
 262
 263     if [board_info [target_info name] exists multilib_flags] {
 264         append flags " [board_info [target_info name] multilib_flags]"
 265     }
 266
 267     verbose -log "$cc $flags $ccflags -c $source -o $object"
 268
 269     set status [remote_exec host [concat sh -c [list "$cc $flags $ccflags -c $source -o $object 2>&1"]] "" "/dev/null" "ld.tmp"]
 270     remote_upload host "ld.tmp"
 271     set exec_output [file_contents "ld.tmp"]
 272     remote_file build delete "ld.tmp"
 273     remote_file host delete "ld.tmp"
 274     set exec_output [prune_warnings $exec_output]
 275     if [string match "" $exec_output] then {
 276         if {![file exists $object]} then {
 277             regexp ".*/(\[^/\]*)$" $source all dobj
 278             regsub "\\.c" $dobj ".o" realobj
 279             verbose "looking for $realobj"
 280             if {[remote_file host exists $realobj]} then {
 281                 verbose -log "mv $realobj $object"
 282                 remote_upload "$realobj" "$object"
 283             } else {
 284                 perror "$object not found after compilation"
 285                 return 0
 286             }
 287         }
 288         return 1
 289     } else {
 290         verbose -log "$exec_output"
 291         perror "$source: compilation failed"
 292         return 0
 293     }
 294 }
 295
 296 # Assemble a file.
 297 #
 298 proc default_ld_assemble { as in_flags source object } {
 299     global ASFLAGS
 300     global host_triplet
 301
 302     if ![info exists ASFLAGS] { set ASFLAGS "" }
 303
 304     set flags [big_or_little_endian]
 305     set exec_output [run_host_cmd "$as" "$flags $in_flags $ASFLAGS -o $object $source"]
 306     set exec_output [prune_warnings $exec_output]
 307     if [string match "" $exec_output] then {
 308         return 1
 309     } else {
 310         perror "$source: assembly failed"
 311         return 0
 312     }
 313 }
 314
 315 # Run nm on a file, putting the result in the array nm_output.
 316 #
 317 proc default_ld_nm { nm nmflags object } {
 318     global NMFLAGS
 319     global nm_output
 320     global host_triplet
 321
 322     if {[info exists nm_output]} {
 323       unset nm_output
 324     }
 325
 326     if ![info exists NMFLAGS] { set NMFLAGS "" }
 327
 328     # Ensure consistent sorting of symbols
 329     if {[info exists env(LC_ALL)]} {
 330         set old_lc_all $env(LC_ALL)
 331     }
 332     set env(LC_ALL) "C"
 333
 334     verbose -log "$nm $NMFLAGS $nmflags $object >tmpdir/nm.out"
 335
 336     set status [remote_exec host [concat sh -c [list "$nm $NMFLAGS $nmflags $object 2>ld.stderr"]] "" "/dev/null" "tmpdir/nm.out"]
 337     if {[info exists old_lc_all]} {
 338         set env(LC_ALL) $old_lc_all
 339     } else {
 340         unset env(LC_ALL)
 341     }
 342     remote_upload host "ld.stderr"
 343     remote_upload host "tmpdir/nm.out" "tmpdir/nm.out"
 344     set exec_output [prune_warnings [file_contents "ld.stderr"]]
 345     remote_file host delete "ld.stderr"
 346     remote_file build delete "ld.stderr"
 347     if [string match "" $exec_output] then {
 348         set file [open tmpdir/nm.out r]
 349         while { [gets $file line] != -1 } {
 350             verbose "$line" 2
 351             if [regexp "^(\[0-9a-fA-F\]+) \[a-zA-Z0-9\] \\.*(.+)$" $line whole value name] {
 352                 set name [string trimleft $name "_"]
 353                 verbose "Setting nm_output($name) to 0x$value" 2
 354                 set nm_output($name) 0x$value
 355             }
 356         }
 357         close $file
 358         return 1
 359     } else {
 360         verbose -log "$exec_output"
 361         perror "$object: nm failed"
 362         return 0
 363     }
 364 }
 365
 366 # Define various symbols needed when not linking against all
 367 # target libs.
 368 proc ld_simple_link_defsyms {} {
 369
 370     set flags "--defsym __stack_chk_fail=0"
 371
 372     # ARM targets call __gccmain
 373     if {[istarget arm*-*-*]} {
 374         append flags " --defsym __gccmain=0"
 375     }
 376
 377     # Windows targets need __main, prefixed with underscore.
 378     if {[istarget *-*-cygwin* ] || [istarget *-*-mingw*]} {
 379         append flags " --defsym ___main=0"
 380     }
 381
 382     # PowerPC EABI code calls __eabi.
 383     if {[istarget powerpc*-*-eabi*] || [istarget powerpc*-*-rtems*]} {
 384         append flags " --defsym __eabi=0"
 385     }
 386
 387     # mn10200 code calls __truncsipsi2_d0_d2.
 388     if {[istarget mn10200*-*-*]} then {
 389         append flags " --defsym __truncsipsi2_d0_d2=0"
 390     }
 391
 392     # m6811/m6812 code has references to soft registers.
 393     if {[istarget m6811-*-*] || [istarget m6812-*-*]} {
 394         append flags " --defsym _.frame=0 --defsym _.d1=0 --defsym _.d2=0"
 395         append flags " --defsym _.d3=0 --defsym _.d4=0"
 396         append flags " --defsym _.tmp=0 --defsym _.xy=0 --defsym _.z=0"
 397     }
 398
 399     # Some OpenBSD targets have ProPolice and reference __guard and
 400     # __stack_smash_handler.
 401     if [istarget *-*-openbsd*] {
 402         append flags " --defsym __guard=0"
 403         append flags " --defsym __stack_smash_handler=0"
 404     }
 405
 406     return $flags
 407 }
 408
 409 # run_dump_test FILE
 410 # Copied from gas testsuite, tweaked and further extended.
 411 #
 412 # Assemble a .s file, then run some utility on it and check the output.
 413 #
 414 # There should be an assembly language file named FILE.s in the test
 415 # suite directory, and a pattern file called FILE.d.  `run_dump_test'
 416 # will assemble FILE.s, run some tool like `objdump', `objcopy', or
 417 # `nm' on the .o file to produce textual output, and then analyze that
 418 # with regexps.  The FILE.d file specifies what program to run, and
 419 # what to expect in its output.
 420 #
 421 # The FILE.d file begins with zero or more option lines, which specify
 422 # flags to pass to the assembler, the program to run to dump the
 423 # assembler's output, and the options it wants.  The option lines have
 424 # the syntax:
 425 #
 426 #         # OPTION: VALUE
 427 #
 428 # OPTION is the name of some option, like "name" or "objdump", and
 429 # VALUE is OPTION's value.  The valid options are described below.
 430 # Whitespace is ignored everywhere, except within VALUE.  The option
 431 # list ends with the first line that doesn't match the above syntax
 432 # (hmm, not great for error detection).
 433 #
 434 # The interesting options are:
 435 #
 436 #   name: TEST-NAME
 437 #       The name of this test, passed to DejaGNU's `pass' and `fail'
 438 #       commands.  If omitted, this defaults to FILE, the root of the
 439 #       .s and .d files' names.
 440 #
 441 #   as: FLAGS
 442 #       When assembling, pass FLAGS to the assembler.
 443 #       If assembling several files, you can pass different assembler
 444 #       options in the "source" directives.  See below.
 445 #
 446 #   ld: FLAGS
 447 #       Link assembled files using FLAGS, in the order of the "source"
 448 #       directives, when using multiple files.
 449 #
 450 #   ld_after_inputfiles: FLAGS
 451 #       Similar to "ld", but put after all input files.
 452 #
 453 #   objcopy_linked_file: FLAGS
 454 #       Run objcopy on the linked file with the specified flags.
 455 #       This lets you transform the linked file using objcopy, before the
 456 #       result is analyzed by an analyzer program specified below (which
 457 #       may in turn *also* be objcopy).
 458 #
 459 #   PROG: PROGRAM-NAME
 460 #       The name of the program to run to analyze the .o file produced
 461 #       by the assembler or the linker output.  This can be omitted;
 462 #       run_dump_test will guess which program to run by seeing which of
 463 #       the flags options below is present.
 464 #
 465 #   objdump: FLAGS
 466 #   nm: FLAGS
 467 #   objcopy: FLAGS
 468 #       Use the specified program to analyze the assembler or linker
 469 #       output file, and pass it FLAGS, in addition to the output name.
 470 #       Note that they are run with LC_ALL=C in the environment to give
 471 #       consistent sorting of symbols.
 472 #
 473 #   source: SOURCE [FLAGS]
 474 #       Assemble the file SOURCE.s using the flags in the "as" directive
 475 #       and the (optional) FLAGS.  If omitted, the source defaults to
 476 #       FILE.s.
 477 #       This is useful if several .d files want to share a .s file.
 478 #       More than one "source" directive can be given, which is useful
 479 #       when testing linking.
 480 #
 481 #   xfail: TARGET
 482 #       The test is expected to fail on TARGET.  This may occur more than
 483 #       once.
 484 #
 485 #   target: TARGET
 486 #       Only run the test for TARGET.  This may occur more than once; the
 487 #       target being tested must match at least one.  You may provide target
 488 #       name "cfi" for any target supporting the CFI statements.
 489 #
 490 #   notarget: TARGET
 491 #       Do not run the test for TARGET.  This may occur more than once;
 492 #       the target being tested must not match any of them.
 493 #
 494 #   error: REGEX
 495 #       An error with message matching REGEX must be emitted for the test
 496 #       to pass.  The PROG, objdump, nm and objcopy options have no
 497 #       meaning and need not supplied if this is present.  Multiple "error"
 498 #       directives append to the expected linker error message.
 499 #
 500 #   warning: REGEX
 501 #       Expect a linker warning matching REGEX.  It is an error to issue
 502 #       both "error" and "warning".  Multiple "warning" directives
 503 #       append to the expected linker warning message.
 504 #
 505 # Each option may occur at most once unless otherwise mentioned.
 506 #
 507 # After the option lines come regexp lines.  `run_dump_test' calls
 508 # `regexp_diff' to compare the output of the dumping tool against the
 509 # regexps in FILE.d.  `regexp_diff' is defined in binutils-common.exp;
 510 # see further comments there.
 511 #
 512 proc run_dump_test { name } {
 513     global subdir srcdir
 514     global OBJDUMP NM AS OBJCOPY READELF LD
 515     global OBJDUMPFLAGS NMFLAGS ASFLAGS OBJCOPYFLAGS READELFFLAGS LDFLAGS
 516     global host_triplet runtests
 517     global env verbose
 518
 519     if [string match "*/*" $name] {
 520         set file $name
 521         set name [file tail $name]
 522     } else {
 523         set file "$srcdir/$subdir/$name"
 524     }
 525
 526     if ![runtest_file_p $runtests $name] then {
 527         return
 528     }
 529
 530     set opt_array [slurp_options "${file}.d"]
 531     if { $opt_array == -1 } {
 532         perror "error reading options from $file.d"
 533         unresolved $subdir/$name
 534         return
 535     }
 536     set dumpfile tmpdir/dump.out
 537     set run_ld 0
 538     set run_objcopy 0
 539     set opts(as) {}
 540     set opts(ld) {}
 541     set opts(ld_after_inputfiles) {}
 542     set opts(xfail) {}
 543     set opts(target) {}
 544     set opts(notarget) {}
 545     set opts(objdump) {}
 546     set opts(nm) {}
 547     set opts(objcopy) {}
 548     set opts(readelf) {}
 549     set opts(name) {}
 550     set opts(PROG) {}
 551     set opts(source) {}
 552     set opts(error) {}
 553     set opts(warning) {}
 554     set opts(objcopy_linked_file) {}
 555     set asflags(${file}.s) {}
 556
 557     foreach i $opt_array {
 558         set opt_name [lindex $i 0]
 559         set opt_val [lindex $i 1]
 560         if ![info exists opts($opt_name)] {
 561             perror "unknown option $opt_name in file $file.d"
 562             unresolved $subdir/$name
 563             return
 564         }
 565
 566         switch -- $opt_name {
 567             xfail {}
 568             target {}
 569             notarget {}
 570             warning {}
 571             error {}
 572             source {
 573                 # Move any source-specific as-flags to a separate array to
 574                 # simplify processing.
 575                 if { [llength $opt_val] > 1 } {
 576                     set asflags([lindex $opt_val 0]) [lrange $opt_val 1 end]
 577                     set opt_val [lindex $opt_val 0]
 578                 } else {
 579                     set asflags($opt_val) {}
 580                 }
 581             }
 582             default {
 583                 if [string length $opts($opt_name)] {
 584                     perror "option $opt_name multiply set in $file.d"
 585                     unresolved $subdir/$name
 586                     return
 587                 }
 588
 589                 # A single "# ld:" with no options should do the right thing.
 590                 if { $opt_name == "ld" } {
 591                     set run_ld 1
 592                 }
 593                 # Likewise objcopy_linked_file.
 594                 if { $opt_name == "objcopy_linked_file" } {
 595                     set run_objcopy 1
 596                 }
 597             }
 598         }
 599         if { $opt_name == "as" || $opt_name == "ld" } {
 600             set opt_val [subst $opt_val]
 601         }
 602         set opts($opt_name) [concat $opts($opt_name) $opt_val]
 603     }
 604     foreach opt { as ld } {
 605         regsub {\[big_or_little_endian\]} $opts($opt) \
 606             [big_or_little_endian] opts($opt)
 607     }
 608
 609     # Decide early whether we should run the test for this target.
 610     if { [llength $opts(target)] > 0 } {
 611         set targmatch 0
 612         foreach targ $opts(target) {
 613             if [istarget $targ] {
 614                 set targmatch 1
 615                 break
 616             }
 617         }
 618         if { $targmatch == 0 } {
 619             return
 620         }
 621     }
 622     foreach targ $opts(notarget) {
 623         if [istarget $targ] {
 624             return
 625         }
 626     }
 627
 628     set program ""
 629     # It's meaningless to require an output-testing method when we
 630     # expect an error.
 631     if { $opts(error) == "" } {
 632         if {$opts(PROG) != ""} {
 633             switch -- $opts(PROG) {
 634                 objdump { set program objdump }
 635                 nm      { set program nm }
 636                 objcopy { set program objcopy }
 637                 readelf { set program readelf }
 638                 default
 639                 { perror "unrecognized program option $opts(PROG) in $file.d"
 640                   unresolved $subdir/$name
 641                   return }
 642             }
 643         } else {
 644         # Guess which program to run, by seeing which option was specified.
 645             foreach p {objdump objcopy nm readelf} {
 646                 if {$opts($p) != ""} {
 647                     if {$program != ""} {
 648                         perror "ambiguous dump program in $file.d"
 649                         unresolved $subdir/$name
 650                         return
 651                     } else {
 652                         set program $p
 653                     }
 654                 }
 655             }
 656         }
 657         if { $program == "" && $opts(warning) == "" } {
 658             perror "dump program unspecified in $file.d"
 659             unresolved $subdir/$name
 660             return
 661         }
 662     }
 663
 664     if { $opts(name) == "" } {
 665         set testname "$subdir/$name"
 666     } else {
 667         set testname $opts(name)
 668     }
 669
 670     if { $opts(source) == "" } {
 671         set sourcefiles [list ${file}.s]
 672     } else {
 673         set sourcefiles {}
 674         foreach sf $opts(source) {
 675             if { [string match "/*" $sf] } {
 676                 lappend sourcefiles "$sf"
 677             } else {
 678                 lappend sourcefiles "$srcdir/$subdir/$sf"
 679             }
 680             # Must have asflags indexed on source name.
 681             set asflags($srcdir/$subdir/$sf) $asflags($sf)
 682         }
 683     }
 684
 685     # Time to setup xfailures.
 686     foreach targ $opts(xfail) {
 687         setup_xfail $targ
 688     }
 689
 690     # Assemble each file.
 691     set objfiles {}
 692     for { set i 0 } { $i < [llength $sourcefiles] } { incr i } {
 693         set sourcefile [lindex $sourcefiles $i]
 694
 695         set objfile "tmpdir/dump$i.o"
 696         catch "exec rm -f $objfile" exec_output
 697         lappend objfiles $objfile
 698         set cmd "$AS $ASFLAGS $opts(as) $asflags($sourcefile) -o $objfile $sourcefile"
 699
 700         send_log "$cmd\n"
 701         set cmdret [remote_exec host [concat sh -c [list "$cmd 2>&1"]] "" "/dev/null" "ld.tmp"]
 702         remote_upload host "ld.tmp"
 703         set comp_output [prune_warnings [file_contents "ld.tmp"]]
 704         remote_file host delete "ld.tmp"
 705         remote_file build delete "ld.tmp"
 706
 707         if { [lindex $cmdret 0] != 0 || ![string match "" $comp_output] } then {
 708             send_log "$comp_output\n"
 709             verbose "$comp_output" 3
 710
 711             set exitstat "succeeded"
 712             if { $cmdret != 0 } { set exitstat "failed" }
 713             verbose -log "$exitstat with: <$comp_output>"
 714             fail $testname
 715             return
 716         }
 717     }
 718
 719     set expmsg $opts(error)
 720     if { $opts(warning) != "" } {
 721         if { $expmsg != "" } {
 722             perror "$testname: mixing error and warning test-directives"
 723             return
 724         }
 725         set expmsg $opts(warning)
 726     }
 727
 728     # Perhaps link the file(s).
 729     if { $run_ld } {
 730         set objfile "tmpdir/dump"
 731         catch "exec rm -f $objfile" exec_output
 732
 733         # Add -L$srcdir/$subdir so that the linker command can use
 734         # linker scripts in the source directory.
 735         set cmd "$LD $LDFLAGS -L$srcdir/$subdir \
 736                    $opts(ld) -o $objfile $objfiles $opts(ld_after_inputfiles)"
 737
 738         send_log "$cmd\n"
 739         set cmdret [remote_exec host [concat sh -c [list "$cmd 2>&1"]] "" "/dev/null" "ld.tmp"]
 740         remote_upload host "ld.tmp"
 741         set comp_output [file_contents "ld.tmp"]
 742         remote_file host delete "ld.tmp"
 743         remote_file build delete "ld.tmp"
 744         set cmdret [lindex $cmdret 0]
 745
 746         if { $cmdret == 0 && $run_objcopy } {
 747             set infile $objfile
 748             set objfile "tmpdir/dump1"
 749             remote_file host delete $objfile
 750
 751             # Note that we don't use OBJCOPYFLAGS here; any flags must be
 752             # explicitly specified.
 753             set cmd "$OBJCOPY $opts(objcopy_linked_file) $infile $objfile"
 754
 755             send_log "$cmd\n"
 756             set cmdret [remote_exec host [concat sh -c [list "$cmd 2>&1"]] "" "/dev/null" "ld.tmp"]
 757             remote_upload host "ld.tmp"
 758             append comp_output [file_contents "ld.tmp"]
 759             remote_file host delete "ld.tmp"
 760             remote_file build delete "ld.tmp"
 761             set cmdret [lindex $cmdret 0]
 762         }
 763
 764         regsub "\n$" $comp_output "" comp_output
 765         if { $cmdret != 0 || $comp_output != "" || $expmsg != "" } then {
 766             set exitstat "succeeded"
 767             if { $cmdret != 0 } { set exitstat "failed" }
 768             verbose -log "$exitstat with: <$comp_output>, expected: <$expmsg>"
 769             send_log "$comp_output\n"
 770             verbose "$comp_output" 3
 771
 772             if { ($expmsg == "") == ($comp_output == "") \
 773                     && [regexp $expmsg $comp_output] \
 774                     && (($cmdret == 0) == ($opts(error) == "")) } {
 775                 # We have the expected output from ld.
 776                 if { $opts(error) != "" || $program == "" } {
 777                     pass $testname
 778                     return
 779                 }
 780             } else {
 781                 verbose -log "$exitstat with: <$comp_output>, expected: <$expmsg>"
 782                 fail $testname
 783                 return
 784             }
 785         }
 786     } else {
 787         set objfile "tmpdir/dump0.o"
 788     }
 789
 790     # We must not have expected failure if we get here.
 791     if { $opts(error) != "" } {
 792         fail $testname
 793         return
 794     }
 795
 796     set progopts1 $opts($program)
 797     eval set progopts \$[string toupper $program]FLAGS
 798     eval set binary \$[string toupper $program]
 799
 800     if { ![is_remote host] && [which $binary] == 0 } {
 801         untested $testname
 802         return
 803     }
 804
 805     if { $progopts1 == "" } { set $progopts1 "-r" }
 806     verbose "running $binary $progopts $progopts1" 3
 807
 808     # Objcopy, unlike the other two, won't send its output to stdout,
 809     # so we have to run it specially.
 810     set cmd "$binary $progopts $progopts1 $objfile > $dumpfile"
 811     if { $program == "objcopy" } {
 812         set cmd "$binary $progopts $progopts1 $objfile $dumpfile"
 813     }
 814
 815     # Ensure consistent sorting of symbols
 816     if {[info exists env(LC_ALL)]} {
 817         set old_lc_all $env(LC_ALL)
 818     }
 819     set env(LC_ALL) "C"
 820     send_log "$cmd\n"
 821     set cmdret [remote_exec host [concat sh -c [list "$cmd 2>ld.tmp"]] "" "/dev/null"]
 822     set cmdret [lindex $cmdret 0]
 823     remote_upload host "ld.tmp"
 824     set comp_output [prune_warnings [file_contents "ld.tmp"]]
 825     remote_file host delete "ld.tmp"
 826     remote_file build delete "ld.tmp"
 827     if {[info exists old_lc_all]} {
 828         set env(LC_ALL) $old_lc_all
 829     } else {
 830         unset env(LC_ALL)
 831     }
 832     if { $cmdret != 0 || $comp_output != "" } {
 833         send_log "exited abnormally with $cmdret, output:$comp_output\n"
 834         fail $testname
 835         return
 836     }
 837
 838     if { $verbose > 2 } then { verbose "output is [file_contents $dumpfile]" 3 }
 839     if { [regexp_diff $dumpfile "${file}.d"] } then {
 840         fail $testname
 841         if { $verbose == 2 } then { verbose "output is [file_contents $dumpfile]" 2 }
 842         return
 843     }
 844
 845     pass $testname
 846 }
 847
 848 proc slurp_options { file } {
 849     if [catch { set f [open $file r] } x] {
 850         #perror "couldn't open `$file': $x"
 851         perror "$x"
 852         return -1
 853     }
 854     set opt_array {}
 855     # whitespace expression
 856     set ws  {[  ]*}
 857     set nws {[^         ]*}
 858     # whitespace is ignored anywhere except within the options list;
 859     # option names are alphabetic plus underscore only.
 860     set pat "^#${ws}(\[a-zA-Z_\]*)$ws:${ws}(.*)$ws\$"
 861     while { [gets $f line] != -1 } {
 862         set line [string trim $line]
 863         # Whitespace here is space-tab.
 864         if [regexp $pat $line xxx opt_name opt_val] {
 865             # match!
 866             lappend opt_array [list $opt_name $opt_val]
 867         } else {
 868             break
 869         }
 870     }
 871     close $f
 872     return $opt_array
 873 }
 874
 875 proc file_contents { filename } {
 876     set file [open $filename r]
 877     set contents [read $file]
 878     close $file
 879     return $contents
 880 }
 881
 882 proc set_file_contents { filename contents } {
 883     set file [open $filename w]
 884     puts $file "$contents"
 885     close $file
 886 }
 887
 888 # Create an archive using ar
 889 #
 890 proc ar_simple_create { ar aropts target objects } {
 891     remote_file host delete $target
 892
 893     set exec_output [run_host_cmd "$ar" "$aropts rc $target $objects"]
 894     set exec_output [prune_warnings $exec_output]
 895
 896     if [string match "" $exec_output] then {
 897         send_log "$exec_output\n"
 898         return 1
 899     } else {
 900         return 0
 901     }
 902 }
 903
 904 # List contains test-items with 3 items followed by 2 lists, one item and
 905 # one optional item:
 906 #  0:name
 907 #  1:ld/ar options
 908 #  2:assembler options
 909 #  3:filenames of assembler files
 910 #  4:list of actions, options and expected outputs.
 911 #  5:name of output file
 912 #  6:compiler flags (optional)
 913 #
 914 # Actions: { command command-line-options file-containg-expected-output-regexps }
 915 # Commands:
 916 #   objdump: Apply objdump options on result.
 917 #   nm: Apply nm options on result.
 918 #   readelf: Apply readelf options on result.
 919 #   ld: Don't apply anything on result.  Compare output during linking with
 920 #     the file containing regexps (which is the second arg, not the third).
 921 #     Note that this *must* be the first action if it is to be used at all;
 922 #     in all other cases, any output from the linker during linking is
 923 #     treated as a sign of an error and FAILs the test.
 924 #
 925 proc run_ld_link_tests { ldtests } {
 926     global ld
 927     global as
 928     global nm
 929     global ar
 930     global objdump
 931     global READELF
 932     global srcdir
 933     global subdir
 934     global env
 935     global CC
 936     global CFLAGS
 937     global runtests
 938     global exec_output
 939
 940     foreach testitem $ldtests {
 941         set testname [lindex $testitem 0]
 942
 943         if ![runtest_file_p $runtests $testname] then {
 944             continue
 945         }
 946
 947         set ld_options [lindex $testitem 1]
 948         set as_options [lindex $testitem 2]
 949         set src_files  [lindex $testitem 3]
 950         set actions [lindex $testitem 4]
 951         set binfile tmpdir/[lindex $testitem 5]
 952         set cflags [lindex $testitem 6]
 953         set objfiles {}
 954         set is_unresolved 0
 955         set failed 0
 956         set maybe_failed 0
 957         set ld_output ""
 958
 959 #       verbose -log "Testname is $testname"
 960 #       verbose -log "ld_options is $ld_options"
 961 #       verbose -log "as_options is $as_options"
 962 #       verbose -log "src_files is $src_files"
 963 #       verbose -log "actions is $actions"
 964 #       verbose -log "binfile is $binfile"
 965
 966         # Assemble each file in the test.
 967         foreach src_file $src_files {
 968             set objfile "tmpdir/[file rootname $src_file].o"
 969             lappend objfiles $objfile
 970
 971             if { [file extension $src_file] == ".c" } {
 972                 set as_file "tmpdir/[file rootname $src_file].s"
 973                 if ![ld_compile "$CC -S $CFLAGS $cflags" $srcdir/$subdir/$src_file $as_file] {
 974                     set is_unresolved 1
 975                     break
 976                 }
 977             } else {
 978                 set as_file "$srcdir/$subdir/$src_file"
 979             }
 980             if ![ld_assemble $as "$as_options $as_file" $objfile] {
 981                 set is_unresolved 1
 982                 break
 983             }
 984         }
 985
 986         # Catch assembler errors.
 987         if { $is_unresolved } {
 988             unresolved $testname
 989             continue
 990         }
 991
 992         if { [regexp ".*\\.a$" $binfile] } {
 993             if { ![ar_simple_create $ar $ld_options $binfile "$objfiles"] } {
 994                 set failed 1
 995             }
 996         } elseif { ![ld_simple_link $ld $binfile "-L$srcdir/$subdir $ld_options $objfiles"] } {
 997             set maybe_failed 1
 998             set ld_output "$exec_output"
 999         }
1000
1001         if { !$failed } {
1002             foreach actionlist $actions {
1003                 set action [lindex $actionlist 0]
1004                 set progopts [lindex $actionlist 1]
1005
1006                 # There are actions where we run regexp_diff on the
1007                 # output, and there are other actions (presumably).
1008                 # Handling of the former look the same.
1009                 set dump_prog ""
1010                 switch -- $action {
1011                     objdump
1012                         { set dump_prog $objdump }
1013                     nm
1014                         { set dump_prog $nm }
1015                     readelf
1016                         { set dump_prog $READELF }
1017                     ld
1018                         { set dump_prog "ld" }
1019                     default
1020                         {
1021                             perror "Unrecognized action $action"
1022                             set is_unresolved 1
1023                             break
1024                         }
1025                     }
1026
1027                 if { $action == "ld" } {
1028                     set regexpfile $progopts
1029                     verbose "regexpfile is $srcdir/$subdir/$regexpfile"
1030                     set_file_contents "tmpdir/ld.messages" "$ld_output"
1031                     verbose "ld.messages has '[file_contents tmpdir/ld.messages]'"
1032                     if { [regexp_diff "tmpdir/ld.messages" "$srcdir/$subdir/$regexpfile"] } then {
1033                         verbose "output is $ld_output" 2
1034                         set failed 1
1035                         break
1036                     }
1037                     set maybe_failed 0
1038                 } elseif { !$maybe_failed && $dump_prog != "" } {
1039                     set dumpfile [lindex $actionlist 2]
1040                     set binary $dump_prog
1041
1042                     # Ensure consistent sorting of symbols
1043                     if {[info exists env(LC_ALL)]} {
1044                         set old_lc_all $env(LC_ALL)
1045                     }
1046                     set env(LC_ALL) "C"
1047                     set cmd "$binary $progopts $binfile"
1048                     set status [remote_exec host [concat sh -c [list "$cmd >dump.out 2>ld.stderr"]] "" "/dev/null"]
1049                     send_log "$cmd\n"
1050                     remote_upload host "ld.stderr"
1051                     set comp_output [prune_warnings [file_contents "ld.stderr"]]
1052                     remote_file host delete "ld.stderr"
1053                     remote_file build delete "ld.stderr"
1054
1055                     if {[info exists old_lc_all]} {
1056                         set env(LC_ALL) $old_lc_all
1057                     } else {
1058                         unset env(LC_ALL)
1059                     }
1060
1061                     if ![string match "" $comp_output] then {
1062                         send_log "$comp_output\n"
1063                         set failed 1
1064                         break
1065                     }
1066
1067                     remote_upload host "dump.out"
1068
1069                     if { [regexp_diff "dump.out" "$srcdir/$subdir/$dumpfile"] } then {
1070                         verbose "output is [file_contents "dump.out"]" 2
1071                         set failed 1
1072                         remote_file build delete "dump.out"
1073                         remote_file host delete "dump.out"
1074                         break
1075                     }
1076                     remote_file build delete "dump.out"
1077                     remote_file host delete "dump.out"
1078                 }
1079             }
1080         }
1081
1082         if { $is_unresolved } {
1083             unresolved $testname
1084         } elseif { $maybe_failed || $failed } {
1085             fail $testname
1086         } else {
1087             pass $testname
1088         }
1089     }
1090 }
1091
1092 # This definition is taken from an unreleased version of DejaGnu.  Once
1093 # that version gets released, and has been out in the world for a few
1094 # months at least, it may be safe to delete this copy.
1095 if ![string length [info proc prune_warnings]] {
1096     #
1097     # prune_warnings -- delete various system verbosities from TEXT
1098     #
1099     # An example is:
1100     # ld.so: warning: /usr/lib/libc.so.1.8.1 has older revision than expected 9
1101     #
1102     # Sites with particular verbose os's may wish to override this in site.exp.
1103     #
1104     proc prune_warnings { text } {
1105         # This is from sun4's.  Do it for all machines for now.
1106         # The "\\1" is to try to preserve a "\n" but only if necessary.
1107         regsub -all "(^|\n)(ld.so: warning:\[^\n\]*\n?)+" $text "\\1" text
1108
1109         # It might be tempting to get carried away and delete blank lines, etc.
1110         # Just delete *exactly* what we're ask to, and that's it.
1111         return $text
1112     }
1113 }
1114
1115 # targets_to_xfail is a list of target triplets to be xfailed.
1116 # ldtests contains test-items with 3 items followed by 1 lists, 2 items
1117 # and 3 optional items:
1118 #   0:name
1119 #   1:ld options
1120 #   2:assembler options
1121 #   3:filenames of source files
1122 #   4:name of output file
1123 #   5:expected output
1124 #   6:compiler flags (optional)
1125 #   7:language (optional)
1126 #   8:linker warning (optional)
1127
1128 proc run_ld_link_exec_tests { targets_to_xfail ldtests } {
1129     global ld
1130     global as
1131     global srcdir
1132     global subdir
1133     global env
1134     global CC
1135     global CXX
1136     global CFLAGS
1137     global CXXFLAGS
1138     global errcnt
1139     global exec_output
1140
1141     foreach testitem $ldtests {
1142         foreach target $targets_to_xfail {
1143             setup_xfail $target
1144         }
1145         set testname [lindex $testitem 0]
1146         set ld_options [lindex $testitem 1]
1147         set as_options [lindex $testitem 2]
1148         set src_files  [lindex $testitem 3]
1149         set binfile tmpdir/[lindex $testitem 4]
1150         set expfile [lindex $testitem 5]
1151         set cflags [lindex $testitem 6]
1152         set lang [lindex $testitem 7]
1153         set warning [lindex $testitem 8]
1154         set objfiles {}
1155         set failed 0
1156
1157 #       verbose -log "Testname is $testname"
1158 #       verbose -log "ld_options is $ld_options"
1159 #       verbose -log "as_options is $as_options"
1160 #       verbose -log "src_files is $src_files"
1161 #       verbose -log "actions is $actions"
1162 #       verbose -log "binfile is $binfile"
1163
1164         # Assemble each file in the test.
1165         foreach src_file $src_files {
1166             set objfile "tmpdir/[file rootname $src_file].o"
1167             lappend objfiles $objfile
1168
1169             # We ignore warnings since some compilers may generate
1170             # incorrect section attributes and the assembler will warn
1171             # them.
1172             if { [ string match "c++" $lang ] } {
1173                 ld_compile "$CXX -c $CXXFLAGS $cflags" $srcdir/$subdir/$src_file $objfile
1174             } else {
1175                 ld_compile "$CC -c $CFLAGS $cflags" $srcdir/$subdir/$src_file $objfile
1176             }
1177
1178             # We have to use $CC to build PIE and shared library.
1179             if { [ string match "c" $lang ] } {
1180                 set link_proc ld_simple_link
1181                 set link_cmd $CC
1182             } elseif { [ string match "c++" $lang ] } {
1183                 set link_proc ld_simple_link
1184                 set link_cmd $CXX
1185             } elseif { [ string match "-shared" $ld_options ] \
1186                  || [ string match "-pie" $ld_options ] } {
1187                 set link_proc ld_simple_link
1188                 set link_cmd $CC
1189             } else {
1190                 set link_proc ld_link
1191                 set link_cmd $ld
1192             }
1193
1194             if ![$link_proc $link_cmd $binfile "-L$srcdir/$subdir $ld_options $objfiles"] {
1195                 set failed 1
1196             } else {
1197                 set failed 0
1198             }
1199
1200             # Check if exec_output is expected.
1201             if { $warning != "" } then {
1202                 verbose -log "returned with: <$exec_output>, expected: <$warning>"
1203                 if { [regexp $warning $exec_output] } then {
1204                     set failed 0
1205                 } else {
1206                     set failed 1
1207                 }
1208             }
1209
1210             if { $failed == 0 } {
1211                 send_log "Running: $binfile > $binfile.out\n"
1212                 verbose "Running: $binfile > $binfile.out"
1213                 catch "exec $binfile > $binfile.out" exec_output
1214
1215                 if ![string match "" $exec_output] then {
1216                     send_log "$exec_output\n"
1217                     verbose "$exec_output" 1
1218                     set failed 1
1219                 } else {
1220                     send_log "diff $binfile.out $srcdir/$subdir/$expfile\n"
1221                     verbose "diff $binfile.out $srcdir/$subdir/$expfile"
1222                     catch "exec diff $binfile.out $srcdir/$subdir/$expfile" exec_output
1223                     set exec_output [prune_warnings $exec_output]
1224
1225                     if ![string match "" $exec_output] then {
1226                         send_log "$exec_output\n"
1227                         verbose "$exec_output" 1
1228                         set failed 1
1229                     }
1230                 }
1231             }
1232
1233             if { $failed != 0 } {
1234                 fail $testname
1235             } else {
1236                 set errcnt 0
1237                 pass $testname
1238             }
1239         }
1240     }
1241 }
1242
1243 # List contains test-items with 3 items followed by 2 lists, one item and
1244 # one optional item:
1245 #  0:name
1246 #  1:ld or ar options
1247 #  2:compile options
1248 #  3:filenames of source files
1249 #  4:action and options.
1250 #  5:name of output file
1251 #  6:language (optional)
1252 #  7:linker warnings (optional)
1253 #
1254 # Actions:
1255 # objdump: Apply objdump options on result.  Compare with regex (last arg).
1256 # nm: Apply nm options on result.  Compare with regex (last arg).
1257 # readelf: Apply readelf options on result.  Compare with regex (last arg).
1258 #
1259 proc run_cc_link_tests { ldtests } {
1260     global nm
1261     global objdump
1262     global READELF
1263     global srcdir
1264     global subdir
1265     global env
1266     global CC
1267     global CXX
1268     global CFLAGS
1269     global CXXFLAGS
1270     global ar
1271     global exec_output
1272
1273     foreach testitem $ldtests {
1274         set testname [lindex $testitem 0]
1275         set ldflags [lindex $testitem 1]
1276         set cflags [lindex $testitem 2]
1277         set src_files  [lindex $testitem 3]
1278         set actions [lindex $testitem 4]
1279         set binfile tmpdir/[lindex $testitem 5]
1280         set lang [lindex $testitem 6]
1281         set warnings [lindex $testitem 7]
1282         set objfiles {}
1283         set is_unresolved 0
1284         set failed 0
1285
1286         # Compile each file in the test.
1287         foreach src_file $src_files {
1288             set objfile "tmpdir/[file rootname $src_file].o"
1289             lappend objfiles $objfile
1290
1291             # We ignore warnings since some compilers may generate
1292             # incorrect section attributes and the assembler will warn
1293             # them.
1294             if { [ string match "c++" $lang ] } {
1295                 ld_compile "$CXX -c $CXXFLAGS $cflags" $srcdir/$subdir/$src_file $objfile
1296             } else {
1297                 ld_compile "$CC -c $CFLAGS $cflags" $srcdir/$subdir/$src_file $objfile
1298             }
1299         }
1300
1301         # Clear error and warning counts.
1302         reset_vars
1303
1304         if { [ string match "c++" $lang ] } {
1305             set cc_cmd $CXX
1306         } else {
1307             set cc_cmd $CC
1308         }
1309
1310         if { [regexp ".*\\.a$" $binfile] } {
1311             if { ![ar_simple_create $ar $ldflags $binfile "$objfiles"] } {
1312                 fail $testname
1313                 set failed 1
1314             } else {
1315                 set failed 0
1316             }
1317         } elseif { ![ld_simple_link $cc_cmd $binfile "-L$srcdir/$subdir $ldflags $objfiles"] } {
1318             # Check if exec_output is expected.
1319             if { $warnings != "" } then {
1320                 verbose -log "returned with: <$exec_output>, expected: <$warnings>"
1321                 if { [regexp $warnings $exec_output] } then {
1322                     set failed 0
1323                 } else {
1324                     set failed 1
1325                 }
1326             } else {
1327                 fail $testname
1328                 set failed 1
1329             }
1330         } else {
1331             set failed 0
1332         }
1333
1334         if { $failed == 0 } {
1335             foreach actionlist $actions {
1336                 set action [lindex $actionlist 0]
1337                 set progopts [lindex $actionlist 1]
1338
1339                 # There are actions where we run regexp_diff on the
1340                 # output, and there are other actions (presumably).
1341                 # Handling of the former look the same.
1342                 set dump_prog ""
1343                 switch -- $action {
1344                     objdump
1345                         { set dump_prog $objdump }
1346                     nm
1347                         { set dump_prog $nm }
1348                     readelf
1349                         { set dump_prog $READELF }
1350                     default
1351                         {
1352                             perror "Unrecognized action $action"
1353                             set is_unresolved 1
1354                             break
1355                         }
1356                     }
1357
1358                 if { $dump_prog != "" } {
1359                     set dumpfile [lindex $actionlist 2]
1360                     set binary $dump_prog
1361
1362                     # Ensure consistent sorting of symbols
1363                     if {[info exists env(LC_ALL)]} {
1364                         set old_lc_all $env(LC_ALL)
1365                     }
1366                     set env(LC_ALL) "C"
1367                     set cmd "$binary $progopts $binfile > dump.out"
1368                     send_log "$cmd\n"
1369                     catch "exec $cmd" comp_output
1370                     if {[info exists old_lc_all]} {
1371                         set env(LC_ALL) $old_lc_all
1372                     } else {
1373                         unset env(LC_ALL)
1374                     }
1375                     set comp_output [prune_warnings $comp_output]
1376
1377                     if ![string match "" $comp_output] then {
1378                         send_log "$comp_output\n"
1379                         set failed 1
1380                         break
1381                     }
1382
1383                     if { [regexp_diff "dump.out" "$srcdir/$subdir/$dumpfile"] } then {
1384                         verbose "output is [file_contents "dump.out"]" 2
1385                         set failed 1
1386                         break
1387                     }
1388                 }
1389             }
1390
1391             if { $failed != 0 } {
1392                 fail $testname
1393             } else { if { $is_unresolved == 0 } {
1394                 pass $testname
1395             } }
1396         }
1397
1398         # Catch action errors.
1399         if { $is_unresolved != 0 } {
1400             unresolved $testname
1401             continue
1402         }
1403     }
1404 }
1405
1406 # Returns true if --gc-sections is supported on the target.
1407
1408 proc check_gc_sections_available { } {
1409     global gc_sections_available_saved
1410     global ld
1411
1412     if {![info exists gc_sections_available_saved]} {
1413         # Some targets don't support gc-sections despite whatever's
1414         # advertised by ld's options.
1415         if {[istarget arc-*-*]
1416              || [istarget d30v-*-*]
1417              || [istarget dlx-*-*]
1418              || [istarget i960-*-*]
1419              || [istarget or32-*-*]
1420              || [istarget pj*-*-*]
1421              || [istarget alpha-*-*]
1422              || [istarget hppa64-*-*]
1423              || [istarget i370-*-*]
1424              || [istarget i860-*-*]
1425              || [istarget ia64-*-*]
1426              || [istarget mep-*-*]
1427              || [istarget mn10200-*-*]
1428              || [istarget *-*-cygwin]
1429              || [istarget *-*-mingw*] } {
1430             set gc_sections_available_saved 0
1431             return 0
1432         }
1433
1434         # elf2flt uses -q (--emit-relocs), which is incompatible with
1435         # --gc-sections.
1436         if { [board_info target exists ldflags]
1437              && [regexp " -elf2flt\[ =\]" " [board_info target ldflags] "] } {
1438             set gc_sections_available_saved 0
1439             return 0
1440         }
1441
1442         # Check if the ld used by gcc supports --gc-sections.
1443         set ld_output [remote_exec host $ld "--help"]
1444         if { [ string first "--gc-sections" $ld_output ] >= 0 } {
1445             set gc_sections_available_saved 1
1446         } else {
1447             set gc_sections_available_saved 0
1448         }
1449     }
1450     return $gc_sections_available_saved
1451 }
1452
1453 # Returns true if the target ld supports the plugin API.
1454 proc check_plugin_api_available { } {
1455     global plugin_api_available_saved
1456     global ld
1457     if {![info exists plugin_api_available_saved]} {
1458         # Check if the ld used by gcc supports --plugin.
1459         set ld_output [remote_exec host $ld "--help"]
1460         if { [ string first "-plugin" $ld_output ] >= 0 } {
1461             set plugin_api_available_saved 1
1462         } else {
1463             set plugin_api_available_saved 0
1464         }
1465     }
1466     return $plugin_api_available_saved
1467 }
1468
1469 # Check if the assembler supports CFI statements.
1470
1471 proc check_as_cfi { } {
1472     global check_as_cfi_result
1473     global as
1474     if [info exists check_as_cfi_result] {
1475         return $check_as_cfi_result
1476     }
1477     set as_file "tmpdir/check_as_cfi.s"
1478     set as_fh [open $as_file w 0666]
1479     puts $as_fh "# Generated file. DO NOT EDIT"
1480     puts $as_fh "\t.cfi_startproc"
1481     puts $as_fh "\t.cfi_endproc"
1482     close $as_fh
1483     remote_download host $as_file
1484     verbose -log "Checking CFI support:"
1485     rename "perror" "check_as_cfi_perror"
1486     proc perror { args } { }
1487     set success [ld_assemble $as $as_file "/dev/null"]
1488     rename "perror" ""
1489     rename "check_as_cfi_perror" "perror"
1490     #remote_file host delete $as_file
1491     set check_as_cfi_result $success
1492     return $success
1493 }
1494
1495 # Provide virtual target "cfi" for targets supporting CFI.
1496
1497 rename "istarget" "istarget_ld"
1498 proc istarget { target } {
1499     if {$target == "cfi"} {
1500         return [check_as_cfi]
1501     }
1502     return [istarget_ld $target]
1503 }