[deliverable/binutils-gdb.git] / ld / testsuite / ld-sh / sh64 / sh64.exp

# Expect script for ld-sh tests
#   Copyright (C) 2000, 2001, 2002 Free Software Foundation
#
# This file is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#

# Test SH linking; all types of relocs.  This tests the assembler and
# tools like objdump as well as the linker.

if ![istarget sh64-*-*] {
    return
}

# FIXME: This isn't set by testsuite/config/default.exp; make it.
if ![info exists readelf] then {
    set readelf [findfile $base_dir/../binutils/readelf]
}

# List contains test-items with 3 items followed by 2 lists:
# 0:name 1:ld options 2:assembler options
# 3:filenames of assembler files 4: action and options.

# Actions:
# objdump: Apply objdump options on result.  Compare with regex (last arg).
# nm: Apply nm options on result.  Compare with regex (last arg).

# Note that the contents dump is the same for "inter-file datalabel
# references, 64-bit ABI" as for 32-bit ABI and ELF so we re-use it.

set sh64tests {
    {"SH64 linking, 64-bit ABI" "-mshelf64"
     "--abi=64" {sh64-1.s sh64-2.s}
     {{objdump -sr abi64.sd} {objdump -x abi64.xd}}}
    {"SH64 linking, 64-bit ABI, -no-expand" "-mshelf64"
     "--abi=64 -no-expand" {sh64-1.s sh64-2.s}
     {{objdump -sr abixx-noexp.sd}}}
    {"SH64 linking, 32-bit ABI" "-mshelf32"
     "--abi=32" {sh64-1.s sh64-2.s}
     {{objdump -sr abi32.sd} {objdump -x abi32.xd}}}
    {"SH64 linking, 32-bit ABI, -no-expand" "-mshelf32"
     "--abi=32 -no-expand" {sh64-1.s sh64-2.s}
     {{objdump -sr abixx-noexp.sd}}}
    {"SH64 linking, single multi-ISA object" "-mshelf32"
     "--abi=32" {shmix-1.s}
     {{objdump -sr mix1.sd} {objdump -x mix1.xd}}}
    {"SH64 linking, single multi-ISA object, -no-expand" "-mshelf32"
     "--abi=32 -no-expand" {shmix-1.s}
     {{objdump -sr mix1-noexp.sd}}}
    {"SH64 linking, two different-ISA objects" "-mshelf32"
     "--abi=32" {shmix-2.s shmix-3.s}
     {{objdump -sr mix2.sd} {objdump -x mix2.xd}}}
    {"SH64 linking, two different-ISA objects, -no-expand" "-mshelf32"
     "--abi=32 -no-expand" {shmix-2.s shmix-3.s}
     {{objdump -sr mix2-noexp.sd}}}
    {"SH64 linking, single SHcompact" "-mshelf32"
     "--isa=SHcompact" {shcmp-1.s}
     {{objdump -sr cmpct1.sd} {objdump -x cmpct1.xd}}}
    {"SH64 inter-file datalabel references, 64-bit ABI" "-mshelf64"
     "--abi=64" {shdl-1.s shdl-2.s}
     {{objdump -sr shdl64.sd} {objdump -x shdl64.xd}}}
    {"SH64 inter-file datalabel references, 32-bit ABI" "-mshelf32"
     "--abi=32" {shdl-1.s shdl-2.s}
     {{objdump -sr shdl64.sd} {objdump -x shdl32.xd}}}
    {"SH64 inter-file datalabel references and gc-sections, 32-bit ABI" "-mshelf32 --gc-sections"
     "--abi=32" {dlsection-1.s }
     {{objdump -sr dlsection.sd}}}
    {"SH64 inter-file datalabel references and gc-sections, 64-bit ABI" "-mshelf64 --gc-sections"
     "--abi=64" {dlsection-1.s }
     {{objdump -sr dlsection.sd}}}
    {"SH64 simple partial linking, 32-bit ABI" "-mshelf32 -r"
     "--abi=32" {rel-1.s rel-2.s}
     {{objdump -sx rel32.xd}}}
    {"SH64 simple partial linking, 64-bit ABI" "-mshelf64 -r"
     "--abi=64" {rel-1.s rel-2.s}
     {{objdump -sx rel64.xd}}}
    {"SH64 partial linking with datalabel references, 32-bit ABI" "-mshelf32 -r"
     "--abi=32" {reldl-1.s reldl-2.s}
     {{readelf {-s -r -x 1 -x 3} reldl32.rd}}}
    {"SH64 partial linking with datalabel references, 64-bit ABI" "-mshelf64 -r"
     "--abi=64" {reldl-1.s reldl-2.s}
     {{readelf {-s -r -x 1 -x 3} reldl64.rd}}}
    {"Handling SH64 assembler-generated .cranges" "-mshelf32"
     "--abi=32" {crange-2a.s crange-1.s}
     {{readelf {-S -s -r -x 1 -x 2 -x 9} crange1.rd}}}
    {"Handling SH64 assembler-generated .cranges, partial linking" "-mshelf32 -r"
     "--abi=32" {crange-2a.s}
     {{readelf {-S -s -r -x 2 -x 5} crangerel1.rd}}}
    {"Mixing SH64 assembler-generated with linker-generated .cranges" "-mshelf32"
     "--abi=32" {crange-2a.s crange-2b.s crange-1.s}
     {{readelf {-S -s -r -x 2 -x 9} crange2.rd}}}
    {"Mixing SH64 assembler-generated with linker-generated .cranges, partial linking"
     "-mshelf32 -r"
     "--abi=32" {crange-2a.s crange-2c.s crange-2d.s crange-2e.s}
     {{readelf {-S -s -r -x 2 -x 5} crangerel2.rd}}}
    {"Merge and use of SH64 .cranges, some not originally in order" "-mshelf32"
     "--abi=32"
     {crange-2e.s crange-2f.s crange-2g.s crange-2a.s crange-2d.s crange-2i.s
      crange-2h.s crange-1.s}
      {{readelf {-S -s -x 2 -x 9} crange3.rd} {objdump -d crange3.dd}}}
    {"Sorted SH64 .cranges, entry at SHcompact code" "-mshelf32 --entry diversion"
     "--abi=32"
     {crange-2e.s crange-2f.s crange-2g.s crange-2a.s crange-2d.s crange-2i.s
      crange-2h.s crange-1.s}
      {{readelf {-h -S -s -x 2 -x 9} crange3-cmpct.rd}}}
    {"Sorted SH64 .cranges, entry at SHmedia code" "-mshelf32 --entry diversion2"
     "--abi=32"
     {crange-2e.s crange-2f.s crange-2g.s crange-2a.s crange-2d.s crange-2i.s
      crange-2h.s crange-1.s}
      {{readelf {-h -S -s -x 2 -x 9} crange3-media.rd}}}
    {"SH64 Big Endianness" "-mshelf64 -Tendian.ld"
     "--abi=64" {endian.s}
     {{objdump -s endian.sbd} {objdump -d endian.dbd}}}
    {"SH64 Little Endianness" "-mshlelf64 -Tendian.ld"
     "--abi=64 --little" {endian.s}
     {{objdump -s endian.sld} {objdump -d endian.dld}}}

}

# FIXME: Generalize and move this to ld-lib.exp

proc run_ld_link_tests { ldtests } {
    global ld
    global as
    global nm
    global objdump
    global readelf
    global srcdir
    global subdir
    global env

    set binfile "tmpdir/linked"

    foreach testitem $ldtests {
	set testname [lindex $testitem 0]
	set ld_options [lindex $testitem 1]
	set as_options [lindex $testitem 2]
	set as_files  [lindex $testitem 3]
	set actions [lindex $testitem 4]
	set objfiles {}
	set is_unresolved 0
	set failed 0

#	verbose -log "Testname is $testname"
#	verbose -log "ld_options is $ld_options"
#	verbose -log "as_options is $as_options"
#	verbose -log "as_files is $as_files"
#	verbose -log "actions is $actions"

	# Assemble each file in the test.
	foreach as_file $as_files {
	    set objfile "tmpdir/[file rootname $as_file].o"
	    lappend objfiles $objfile

	    if ![ld_assemble $as "$as_options $srcdir/$subdir/$as_file" $objfile] {
		set is_unresolved 1
		break
	    }
	}

	# Catch assembler errors.
	if { $is_unresolved != 0 } {
	    unresolved $testname
	    continue
	}

	if ![ld_simple_link $ld $binfile "-L$srcdir/$subdir $ld_options $objfiles"] {
	    fail $testname
	} else {
	    set failed 0
	    foreach actionlist $actions {
		set action [lindex $actionlist 0]
		set progopts [lindex $actionlist 1]

		# There are actions where we run regexp_diff on the
		# output, and there are other actions (presumably).
		# Handling of the former look the same.
		set dump_prog ""
		switch -- $action {
		    objdump
		        { set dump_prog $objdump }
		    nm
		        { set dump_prog $nm }
		    readelf
		        { set dump_prog $readelf }
		    default
			{
			    perror "Unrecognized action $action"
			    set is_unresolved 1
			    break
			}
		    }

		if { $dump_prog != "" } {
		    set dumpfile [lindex $actionlist 2]
		    set binary $dump_prog

		    # Ensure consistent sorting of symbols
		    if {[info exists env(LC_ALL)]} {
			set old_lc_all $env(LC_ALL)
		    }
		    set env(LC_ALL) "C"
		    set cmd "$binary $progopts $binfile > dump.out"
		    send_log "$cmd\n"
		    catch "exec $cmd" comp_output
		    if {[info exists old_lc_all]} {
			set env(LC_ALL) $old_lc_all
		    } else {
			unset env(LC_ALL)
		    }
		    set comp_output [prune_warnings $comp_output]

		    if ![string match "" $comp_output] then {
			send_log "$comp_output\n"
			set failed 1
			break
		    }

		    if { [regexp_diff "dump.out" "$srcdir/$subdir/$dumpfile"] } then {
			verbose "output is [file_contents "dump.out"]" 2
			set failed 1
			break
		    }
		}
	    }

	    if { $failed != 0 } {
		fail $testname
	    } else { if { $is_unresolved == 0 } {
		pass $testname
	    } }
	}

	# Catch action errors.
	if { $is_unresolved != 0 } {
	    unresolved $testname
	    continue
	}
    }
}

# FIXME: Move this to ld-lib.exp or higher up.

# regexp_diff, based on simple_diff taken from ld test suite
#	compares two files line-by-line
#	file1 contains strings, file2 contains regexps and #-comments
#	blank lines are ignored in either file
#	returns non-zero if differences exist
#
proc regexp_diff { file_1 file_2 } {

    set eof -1
    set end_1 0
    set end_2 0
    set differences 0
    set diff_pass 0

    if [file exists $file_1] then {
	set file_a [open $file_1 r]
    } else {
	warning "$file_1 doesn't exist"
	return 1
    }

    if [file exists $file_2] then {
	set file_b [open $file_2 r]
    } else {
	fail "$file_2 doesn't exist"
	close $file_a
	return 1
    }

    verbose " Regexp-diff'ing: $file_1 $file_2" 2

    while { 1 } {
	set line_a ""
	set line_b ""
	while { [string length $line_a] == 0 } {
	    if { [gets $file_a line_a] == $eof } {
		set end_1 1
		break
	    }
	}
	while { [string length $line_b] == 0 || [string match "#*" $line_b] } {
	    if [ string match "#pass" $line_b ] {
		set end_2 1
		set diff_pass 1
		break
	    } elseif [ string match "#..." $line_b ] {
		if { [gets $file_b line_b] == $eof } {
		    set end_2 1
		    break
		}
		verbose "looking for \"^$line_b$\"" 3
		while { ![regexp "^$line_b$" "$line_a"] } {
		    verbose "skipping    \"$line_a\"" 3
		    if { [gets $file_a line_a] == $eof } {
			set end_1 1
			break
		    }
		}
		break
	    }
	    if { [gets $file_b line_b] == $eof } {
		set end_2 1
		break
	    }
	}

        if { $diff_pass } {
            break
        } elseif { $end_1 && $end_2 } {
            break
        } elseif { $end_1 } {
            send_log "extra regexps in $file_2 starting with \"^$line_b$\"\nEOF from $file_1\n"
            verbose "extra regexps in $file_2 starting with \"^$line_b$\"\nEOF from $file_1" 3
            set differences 1
            break
        } elseif { $end_2 } {
            send_log "extra lines in $file_1 starting with \"^$line_a$\"\nEOF from $file_2\n"
            verbose "extra lines in $file_1 starting with \"^$line_a$\"\nEOF from $file_2\n" 3
            set differences 1
            break
        } else {
            verbose "regexp \"^$line_b$\"\nline   \"$line_a\"" 3
            if ![regexp "^$line_b$" "$line_a"] {
		send_log "regexp_diff match failure\n"
		send_log "regexp \"^$line_b$\"\nline   \"$line_a\"\n"
		set differences 1
            }
        }
    }

    if { $differences == 0 && !$diff_pass && [eof $file_a] != [eof $file_b] } {
	send_log "$file_1 and $file_2 are different lengths\n"
	verbose "$file_1 and $file_2 are different lengths" 3
	set differences 1
    }

    close $file_a
    close $file_b

    return $differences
}

proc file_contents { filename } {
    set file [open $filename r]
    set contents [read $file]
    close $file
    return $contents
}

run_ld_link_tests $sh64tests
Commit	Line	Data
1b19eb81 AO	1	# Expect script for ld-sh tests
	2	# Copyright (C) 2000, 2001, 2002 Free Software Foundation
	3	#
	4	# This file 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.
3e8cba19	8	#
1b19eb81 AO	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.
3e8cba19	13	#
1b19eb81 AO	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
	19	# Test SH linking; all types of relocs. This tests the assembler and
	20	# tools like objdump as well as the linker.
	21
	22	if ![istarget sh64--] {
	23	return
	24	}
	25
	26	# FIXME: This isn't set by testsuite/config/default.exp; make it.
	27	if ![info exists readelf] then {
	28	set readelf [findfile $base_dir/../binutils/readelf]
	29	}
	30
	31	# List contains test-items with 3 items followed by 2 lists:
	32	# 0:name 1:ld options 2:assembler options
	33	# 3:filenames of assembler files 4: action and options.
	34
	35	# Actions:
	36	# objdump: Apply objdump options on result. Compare with regex (last arg).
	37	# nm: Apply nm options on result. Compare with regex (last arg).
	38
	39	# Note that the contents dump is the same for "inter-file datalabel
	40	# references, 64-bit ABI" as for 32-bit ABI and ELF so we re-use it.
	41
	42	set sh64tests {
	43	{"SH64 linking, 64-bit ABI" "-mshelf64"
	44	"--abi=64" {sh64-1.s sh64-2.s}
	45	{{objdump -sr abi64.sd} {objdump -x abi64.xd}}}
	46	{"SH64 linking, 64-bit ABI, -no-expand" "-mshelf64"
	47	"--abi=64 -no-expand" {sh64-1.s sh64-2.s}
	48	{{objdump -sr abixx-noexp.sd}}}
	49	{"SH64 linking, 32-bit ABI" "-mshelf32"
	50	"--abi=32" {sh64-1.s sh64-2.s}
	51	{{objdump -sr abi32.sd} {objdump -x abi32.xd}}}
	52	{"SH64 linking, 32-bit ABI, -no-expand" "-mshelf32"
	53	"--abi=32 -no-expand" {sh64-1.s sh64-2.s}
	54	{{objdump -sr abixx-noexp.sd}}}
	55	{"SH64 linking, single multi-ISA object" "-mshelf32"
	56	"--abi=32" {shmix-1.s}
	57	{{objdump -sr mix1.sd} {objdump -x mix1.xd}}}
	58	{"SH64 linking, single multi-ISA object, -no-expand" "-mshelf32"
	59	"--abi=32 -no-expand" {shmix-1.s}
	60	{{objdump -sr mix1-noexp.sd}}}
	61	{"SH64 linking, two different-ISA objects" "-mshelf32"
	62	"--abi=32" {shmix-2.s shmix-3.s}
	63	{{objdump -sr mix2.sd} {objdump -x mix2.xd}}}
	64	{"SH64 linking, two different-ISA objects, -no-expand" "-mshelf32"
	65	"--abi=32 -no-expand" {shmix-2.s shmix-3.s}
	66	{{objdump -sr mix2-noexp.sd}}}
	67	{"SH64 linking, single SHcompact" "-mshelf32"
	68	"--isa=SHcompact" {shcmp-1.s}
	69	{{objdump -sr cmpct1.sd} {objdump -x cmpct1.xd}}}
	70	{"SH64 inter-file datalabel references, 64-bit ABI" "-mshelf64"
	71	"--abi=64" {shdl-1.s shdl-2.s}
	72	{{objdump -sr shdl64.sd} {objdump -x shdl64.xd}}}
	73	{"SH64 inter-file datalabel references, 32-bit ABI" "-mshelf32"
	74	"--abi=32" {shdl-1.s shdl-2.s}
	75	{{objdump -sr shdl64.sd} {objdump -x shdl32.xd}}}
0b65791f SC	76	{"SH64 inter-file datalabel references and gc-sections, 32-bit ABI" "-mshelf32 --gc-sections"
	77	"--abi=32" {dlsection-1.s }
	78	{{objdump -sr dlsection.sd}}}
	79	{"SH64 inter-file datalabel references and gc-sections, 64-bit ABI" "-mshelf64 --gc-sections"
	80	"--abi=64" {dlsection-1.s }
	81	{{objdump -sr dlsection.sd}}}
1b19eb81 AO	82	{"SH64 simple partial linking, 32-bit ABI" "-mshelf32 -r"
	83	"--abi=32" {rel-1.s rel-2.s}
	84	{{objdump -sx rel32.xd}}}
	85	{"SH64 simple partial linking, 64-bit ABI" "-mshelf64 -r"
	86	"--abi=64" {rel-1.s rel-2.s}
	87	{{objdump -sx rel64.xd}}}
	88	{"SH64 partial linking with datalabel references, 32-bit ABI" "-mshelf32 -r"
	89	"--abi=32" {reldl-1.s reldl-2.s}
	90	{{readelf {-s -r -x 1 -x 3} reldl32.rd}}}
	91	{"SH64 partial linking with datalabel references, 64-bit ABI" "-mshelf64 -r"
	92	"--abi=64" {reldl-1.s reldl-2.s}
	93	{{readelf {-s -r -x 1 -x 3} reldl64.rd}}}
	94	{"Handling SH64 assembler-generated .cranges" "-mshelf32"
	95	"--abi=32" {crange-2a.s crange-1.s}
	96	{{readelf {-S -s -r -x 1 -x 2 -x 9} crange1.rd}}}
	97	{"Handling SH64 assembler-generated .cranges, partial linking" "-mshelf32 -r"
	98	"--abi=32" {crange-2a.s}
	99	{{readelf {-S -s -r -x 2 -x 5} crangerel1.rd}}}
	100	{"Mixing SH64 assembler-generated with linker-generated .cranges" "-mshelf32"
	101	"--abi=32" {crange-2a.s crange-2b.s crange-1.s}
	102	{{readelf {-S -s -r -x 2 -x 9} crange2.rd}}}
	103	{"Mixing SH64 assembler-generated with linker-generated .cranges, partial linking"
	104	"-mshelf32 -r"
	105	"--abi=32" {crange-2a.s crange-2c.s crange-2d.s crange-2e.s}
	106	{{readelf {-S -s -r -x 2 -x 5} crangerel2.rd}}}
	107	{"Merge and use of SH64 .cranges, some not originally in order" "-mshelf32"
	108	"--abi=32"
	109	{crange-2e.s crange-2f.s crange-2g.s crange-2a.s crange-2d.s crange-2i.s
	110	crange-2h.s crange-1.s}
	111	{{readelf {-S -s -x 2 -x 9} crange3.rd} {objdump -d crange3.dd}}}
	112	{"Sorted SH64 .cranges, entry at SHcompact code" "-mshelf32 --entry diversion"
	113	"--abi=32"
	114	{crange-2e.s crange-2f.s crange-2g.s crange-2a.s crange-2d.s crange-2i.s
	115	crange-2h.s crange-1.s}
	116	{{readelf {-h -S -s -x 2 -x 9} crange3-cmpct.rd}}}
	117	{"Sorted SH64 .cranges, entry at SHmedia code" "-mshelf32 --entry diversion2"
	118	"--abi=32"
	119	{crange-2e.s crange-2f.s crange-2g.s crange-2a.s crange-2d.s crange-2i.s
	120	crange-2h.s crange-1.s}
	121	{{readelf {-h -S -s -x 2 -x 9} crange3-media.rd}}}
	122	{"SH64 Big Endianness" "-mshelf64 -Tendian.ld"
	123	"--abi=64" {endian.s}
	124	{{objdump -s endian.sbd} {objdump -d endian.dbd}}}
	125	{"SH64 Little Endianness" "-mshlelf64 -Tendian.ld"
	126	"--abi=64 --little" {endian.s}
	127	{{objdump -s endian.sld} {objdump -d endian.dld}}}
3e8cba19	128
1b19eb81 AO	129	}
	130
	131	# FIXME: Generalize and move this to ld-lib.exp
	132
	133	proc run_ld_link_tests { ldtests } {
	134	global ld
	135	global as
	136	global nm
	137	global objdump
	138	global readelf
	139	global srcdir
	140	global subdir
3e8cba19	141	global env
1b19eb81 AO	142
	143	set binfile "tmpdir/linked"
	144
	145	foreach testitem $ldtests {
	146	set testname [lindex $testitem 0]
	147	set ld_options [lindex $testitem 1]
	148	set as_options [lindex $testitem 2]
	149	set as_files [lindex $testitem 3]
	150	set actions [lindex $testitem 4]
	151	set objfiles {}
	152	set is_unresolved 0
	153	set failed 0
	154
	155	# verbose -log "Testname is $testname"
	156	# verbose -log "ld_options is $ld_options"
	157	# verbose -log "as_options is $as_options"
	158	# verbose -log "as_files is $as_files"
	159	# verbose -log "actions is $actions"
	160
	161	# Assemble each file in the test.
	162	foreach as_file $as_files {
	163	set objfile "tmpdir/[file rootname $as_file].o"
	164	lappend objfiles $objfile
	165
	166	if ![ld_assemble $as "$as_options $srcdir/$subdir/$as_file" $objfile] {
	167	set is_unresolved 1
	168	break
	169	}
	170	}
	171
	172	# Catch assembler errors.
	173	if { $is_unresolved != 0 } {
	174	unresolved $testname
	175	continue
	176	}
	177
	178	if ![ld_simple_link $ld $binfile "-L$srcdir/$subdir $ld_options $objfiles"] {
	179	fail $testname
	180	} else {
	181	set failed 0
	182	foreach actionlist $actions {
	183	set action [lindex $actionlist 0]
	184	set progopts [lindex $actionlist 1]
	185
	186	# There are actions where we run regexp_diff on the
	187	# output, and there are other actions (presumably).
	188	# Handling of the former look the same.
	189	set dump_prog ""
	190	switch -- $action {
	191	objdump
	192	{ set dump_prog $objdump }
	193	nm
	194	{ set dump_prog $nm }
	195	readelf
	196	{ set dump_prog $readelf }
	197	default
	198	{
	199	perror "Unrecognized action $action"
	200	set is_unresolved 1
	201	break
	202	}
	203	}
	204
	205	if { $dump_prog != "" } {
206	set dumpfile [lindex $actionlist 2]
207	set binary $dump_prog
208
3e8cba19 AM	209	# Ensure consistent sorting of symbols
	210	if {[info exists env(LC_ALL)]} {
	211	set old_lc_all $env(LC_ALL)
	212	}
	213	set env(LC_ALL) "C"
	214	set cmd "$binary $progopts $binfile > dump.out"
	215	send_log "$cmd\n"
	216	catch "exec $cmd" comp_output
	217	if {[info exists old_lc_all]} {
	218	set env(LC_ALL) $old_lc_all
	219	} else {
	220	unset env(LC_ALL)
	221	}
1b19eb81 AO	222	set comp_output [prune_warnings $comp_output]
	223
	224	if ![string match "" $comp_output] then {
	225	send_log "$comp_output\n"
	226	set failed 1
	227	break
	228	}
	229
	230	if { [regexp_diff "dump.out" "$srcdir/$subdir/$dumpfile"] } then {
	231	verbose "output is [file_contents "dump.out"]" 2
	232	set failed 1
	233	break
	234	}
	235	}
	236	}
	237
	238	if { $failed != 0 } {
	239	fail $testname
	240	} else { if { $is_unresolved == 0 } {
	241	pass $testname
	242	} }
	243	}
	244
	245	# Catch action errors.
	246	if { $is_unresolved != 0 } {
	247	unresolved $testname
	248	continue
	249	}
	250	}
	251	}
	252
	253	# FIXME: Move this to ld-lib.exp or higher up.
	254
	255	# regexp_diff, based on simple_diff taken from ld test suite
	256	# compares two files line-by-line
	257	# file1 contains strings, file2 contains regexps and #-comments
	258	# blank lines are ignored in either file
	259	# returns non-zero if differences exist
	260	#
	261	proc regexp_diff { file_1 file_2 } {
	262
	263	set eof -1
	264	set end_1 0
	265	set end_2 0
	266	set differences 0
	267	set diff_pass 0
	268
	269	if [file exists $file_1] then {
	270	set file_a [open $file_1 r]
	271	} else {
	272	warning "$file_1 doesn't exist"
	273	return 1
	274	}
	275
	276	if [file exists $file_2] then {
	277	set file_b [open $file_2 r]
	278	} else {
	279	fail "$file_2 doesn't exist"
	280	close $file_a
	281	return 1
	282	}
	283
	284	verbose " Regexp-diff'ing: $file_1 $file_2" 2
	285
286	while { 1 } {
287	set line_a ""
288	set line_b ""
289	while { [string length $line_a] == 0 } {
290	if { [gets $file_a line_a] == $eof } {
291	set end_1 1
292	break
293	}
294	}
295	while { [string length $line_b] == 0 \|\| [string match "#*" $line_b] } {
296	if [ string match "#pass" $line_b ] {
297	set end_2 1
298	set diff_pass 1
299	break
300	} elseif [ string match "#..." $line_b ] {
301	if { [gets $file_b line_b] == $eof } {
302	set end_2 1
303	break
304	}
305	verbose "looking for \"^$line_b$\"" 3
306	while { ![regexp "^$line_b$" "$line_a"] } {
307	verbose "skipping \"$line_a\"" 3
308	if { [gets $file_a line_a] == $eof } {
309	set end_1 1
310	break
311	}
312	}
313	break
314	}
315	if { [gets $file_b line_b] == $eof } {
316	set end_2 1
317	break
318	}
319	}
320
3e8cba19 AM	321	if { $diff_pass } {
	322	break
	323	} elseif { $end_1 && $end_2 } {
1b19eb81 AO	324	break
	325	} elseif { $end_1 } {
	326	send_log "extra regexps in $file_2 starting with \"^$line_b$\"\nEOF from $file_1\n"
	327	verbose "extra regexps in $file_2 starting with \"^$line_b$\"\nEOF from $file_1" 3
	328	set differences 1
	329	break
	330	} elseif { $end_2 } {
	331	send_log "extra lines in $file_1 starting with \"^$line_a$\"\nEOF from $file_2\n"
	332	verbose "extra lines in $file_1 starting with \"^$line_a$\"\nEOF from $file_2\n" 3
	333	set differences 1
	334	break
	335	} else {
	336	verbose "regexp \"^$line_b$\"\nline \"$line_a\"" 3
	337	if ![regexp "^$line_b$" "$line_a"] {
	338	send_log "regexp_diff match failure\n"
	339	send_log "regexp \"^$line_b$\"\nline \"$line_a\"\n"
	340	set differences 1
	341	}
	342	}
	343	}
	344
	345	if { $differences == 0 && !$diff_pass && [eof $file_a] != [eof $file_b] } {
	346	send_log "$file_1 and $file_2 are different lengths\n"
	347	verbose "$file_1 and $file_2 are different lengths" 3
	348	set differences 1
	349	}
	350
	351	close $file_a
	352	close $file_b
	353
	354	return $differences
	355	}
	356
	357	proc file_contents { filename } {
	358	set file [open $filename r]
	359	set contents [read $file]
	360	close $file
	361	return $contents
	362	}
	363
	364	run_ld_link_tests $sh64tests