[deliverable/binutils-gdb.git] / binutils / testsuite / binutils-all / readelf.exp

#   Copyright 1999, 2000 Free Software Foundation, Inc.

# This program 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.

# Please email any bugs, comments, and/or additions to this file to:
# bug-dejagnu@prep.ai.mit.edu

# Written by Nick Clifton <nickc@cygnus.com>
# Based on scripts written by Ian Lance Taylor <ian@cygnus.com>
# and Ken Raeburn <raeburn@cygnus.com>.

# First some helpful procedures, then the tests themselves

# Return the contents of the filename given
proc file_contents { filename } {
    set file [open $filename r]
    set contents [read $file]
    close $file
    return $contents
}

# 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
}

# Find out the size by reading the output of the EI_CLASS field.
# Similar to the test for readelf -h, but we're just looking for the
# EI_CLASS line here.
proc readelf_find_size { binary_file } {
    global READELF
    global READELFFLAGS
    global readelf_size

    set readelf_size ""
    set testname "finding out ELF size with readelf -h"
    catch "exec $READELF $READELFFLAGS -h $binary_file > readelf.out" got

    if ![string match "" $got] then {
	send_log $got
	fail $testname
	return
    }

    if { ! [regexp "\n\[ \]*Class:\[ \]*ELF(\[0-9\]+)\n" \
	    [file_contents readelf.out] nil readelf_size] } {
	verbose -log "EI_CLASS field not found in output"
	verbose -log "output is \n[file_contents readelf.out]"
	fail $testname
	return
    } else {
	verbose -log "ELF size is $readelf_size"
    }

    pass $testname
}

# Run an individual readelf test.
# Basically readelf is run on the binary_file with the given options.
# Readelf's output is captured and then compared against the contents
# of the regexp_file-readelf_size if it exists, else regexp_file.

proc readelf_test { options binary_file regexp_file xfails } {

    global READELF
    global READELFFLAGS
    global readelf_size
    global srcdir
    global subdir
    
    send_log "exec $READELF $READELFFLAGS $options $binary_file > readelf.out\n"
    catch "exec $READELF $READELFFLAGS $options $binary_file > readelf.out" got

    foreach xfail $xfails {
	setup_xfail $xfail
    }
    
    if ![string match "" $got] then {
	send_log $got
	fail "readelf $options"
	return
    }

    set target_machine ""
    if [istarget "mips*-*-*"] then {
      set target_machine mips
    }

    if { $target_machine != "" && [file exists $srcdir/$subdir/$regexp_file-$readelf_size-$target_machine] } then {
	set regexp_file $regexp_file-$readelf_size-$target_machine
    } elseif { $target_machine != "" && [file exists $srcdir/$subdir/$regexp_file-$target_machine] } then {
	set regexp_file $regexp_file-$target_machine
    } elseif { [file exists $srcdir/$subdir/$regexp_file-$readelf_size] } then {
	set regexp_file $regexp_file-$readelf_size
    }

    if { [regexp_diff readelf.out $srcdir/$subdir/$regexp_file] } then {
	fail "readelf $options"
	verbose "output is \n[file_contents readelf.out]" 2
	return
    }

    pass "readelf $options"
}


# Only ELF based toolchains need readelf.
# For now be paranoid and assume that if ELF is not mentioned
# in the target string, then the target is not an ELF based port.

if ![istarget "*-*elf"] then {
    verbose "$READELF is only intended for ELF targets" 2
    return
}

if ![is_remote host] {
    if {[which $READELF] == 0} then {
        perror "$READELF does not exist"
        return
    }
}

send_user "Version [binutil_version $READELF]"

# Assemle the test file.
if {![binutils_assemble $srcdir/$subdir/bintest.s tmpdir/bintest.o]} then {
    perror "unresolved 1"
    unresolved "readelf - failed to assemble"
    return
}

if ![is_remote host] {
    set tempfile tmpdir/bintest.o;
} else {
    set tempfile [remote_download host tmpdir/bintest.o]
}

# First, determine the size, so specific output matchers can be used.
readelf_find_size $tempfile

# Run the tests.
readelf_test -h $tempfile readelf.h  {}
readelf_test -S $tempfile readelf.s  {}
readelf_test -s $tempfile readelf.ss {}
readelf_test -r $tempfile readelf.r  {}


# Compile the second test file.
if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
    untested "readelf -w"
    return
}

if [is_remote host] {
    set tempfile [remote_download host tmpdir/testprog.o];
} else {
    set tempfile tmpdir/testprog.o
}

# The xfail targets here do not default to DWARF2 format debug information
# The symptom is that the output of 'readelf -wi' is empty.

readelf_test -wi $tempfile readelf.wi {v850*-*-* cris-*-*}
Commit	Line	Data
8c2bc687	1	# Copyright 1999, 2000 Free Software Foundation, Inc.
252b5132 RH	2
	3	# This program is free software; you can redistribute it and/or modify
	4	# it under the terms of the GNU General Public License as published by
	5	# the Free Software Foundation; either version 2 of the License, or
	6	# (at your option) any later version.
	7	#
	8	# This program is distributed in the hope that it will be useful,
	9	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	# GNU General Public License for more details.
	12	#
	13	# You should have received a copy of the GNU General Public License
	14	# along with this program; if not, write to the Free Software
	15	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	16
	17	# Please email any bugs, comments, and/or additions to this file to:
	18	# bug-dejagnu@prep.ai.mit.edu
	19
113675b7	20	# Written by Nick Clifton <nickc@cygnus.com>
252b5132 RH	21	# Based on scripts written by Ian Lance Taylor <ian@cygnus.com>
	22	# and Ken Raeburn <raeburn@cygnus.com>.
	23
	24	# First some helpful procedures, then the tests themselves
	25
	26	# Return the contents of the filename given
	27	proc file_contents { filename } {
	28	set file [open $filename r]
	29	set contents [read $file]
	30	close $file
	31	return $contents
	32	}
	33
	34	# regexp_diff, based on simple_diff taken from ld test suite
	35	# compares two files line-by-line
	36	# file1 contains strings, file2 contains regexps and #-comments
	37	# blank lines are ignored in either file
	38	# returns non-zero if differences exist
	39	#
	40	proc regexp_diff { file_1 file_2 } {
	41
	42	set eof -1
	43	set end_1 0
	44	set end_2 0
	45	set differences 0
	46	set diff_pass 0
	47
	48	if [file exists $file_1] then {
	49	set file_a [open $file_1 r]
	50	} else {
	51	warning "$file_1 doesn't exist"
	52	return 1
	53	}
	54
	55	if [file exists $file_2] then {
	56	set file_b [open $file_2 r]
	57	} else {
	58	fail "$file_2 doesn't exist"
	59	close $file_a
	60	return 1
	61	}
	62
	63	verbose " Regexp-diff'ing: $file_1 $file_2" 2
	64
	65	while { 1 } {
	66	set line_a ""
	67	set line_b ""
	68	while { [string length $line_a] == 0 } {
	69	if { [gets $file_a line_a] == $eof } {
	70	set end_1 1
	71	break
	72	}
	73	}
	74	while { [string length $line_b] == 0 \|\| [string match "#*" $line_b] } {
	75	if [ string match "#pass" $line_b ] {
	76	set end_2 1
	77	set diff_pass 1
	78	break
ade0b24f NC	79	} elseif [ string match "#..." $line_b ] {
	80	if { [gets $file_b line_b] == $eof } {
	81	set end_2 1
	82	break
	83	}
	84	verbose "looking for \"^$line_b$\"" 3
	85	while { ![regexp "^$line_b$" "$line_a"] } {
	86	verbose "skipping \"$line_a\"" 3
	87	if { [gets $file_a line_a] == $eof } {
	88	set end_1 1
	89	break
	90	}
	91	}
	92	break
252b5132 RH	93	}
	94	if { [gets $file_b line_b] == $eof } {
	95	set end_2 1
	96	break
	97	}
	98	}
	99
	100	if { $diff_pass } {
	101	break
	102	} elseif { $end_1 && $end_2 } {
	103	break
	104	} elseif { $end_1 } {
	105	send_log "extra regexps in $file_2 starting with \"^$line_b$\"\nEOF from $file_1\n"
	106	verbose "extra regexps in $file_2 starting with \"^$line_b$\"\nEOF from $file_1" 3
	107	set differences 1
	108	break
	109	} elseif { $end_2 } {
	110	send_log "extra lines in $file_1 starting with \"^$line_a$\"\nEOF from $file_2\n"
	111	verbose "extra lines in $file_1 starting with \"^$line_a$\"\nEOF from $file_2\n" 3
	112	set differences 1
	113	break
	114	} else {
	115	verbose "regexp \"^$line_b$\"\nline \"$line_a\"" 3
	116	if ![regexp "^$line_b$" "$line_a"] {
	117	send_log "regexp_diff match failure\n"
	118	send_log "regexp \"^$line_b$\"\nline \"$line_a\"\n"
	119	set differences 1
252b5132 RH	120	}
	121	}
	122	}
	123
	124	if { $differences == 0 && !$diff_pass && [eof $file_a] != [eof $file_b] } {
	125	send_log "$file_1 and $file_2 are different lengths\n"
	126	verbose "$file_1 and $file_2 are different lengths" 3
	127	set differences 1
	128	}
	129
	130	close $file_a
	131	close $file_b
	132
	133	return $differences
	134	}
	135
9921923c HPN	136	# Find out the size by reading the output of the EI_CLASS field.
	137	# Similar to the test for readelf -h, but we're just looking for the
	138	# EI_CLASS line here.
	139	proc readelf_find_size { binary_file } {
	140	global READELF
	141	global READELFFLAGS
	142	global readelf_size
	143
	144	set readelf_size ""
	145	set testname "finding out ELF size with readelf -h"
	146	catch "exec $READELF $READELFFLAGS -h $binary_file > readelf.out" got
	147
	148	if ![string match "" $got] then {
	149	send_log $got
	150	fail $testname
	151	return
	152	}
	153
	154	if { ! [regexp "\n\[ \]Class:\[ \]ELF(\[0-9\]+)\n" \
	155	[file_contents readelf.out] nil readelf_size] } {
	156	verbose -log "EI_CLASS field not found in output"
	157	verbose -log "output is \n[file_contents readelf.out]"
	158	fail $testname
	159	return
	160	} else {
	161	verbose -log "ELF size is $readelf_size"
	162	}
	163
	164	pass $testname
	165	}
	166
252b5132 RH	167	# Run an individual readelf test.
	168	# Basically readelf is run on the binary_file with the given options.
	169	# Readelf's output is captured and then compared against the contents
9921923c	170	# of the regexp_file-readelf_size if it exists, else regexp_file.
252b5132 RH	171
	172	proc readelf_test { options binary_file regexp_file xfails } {
	173
	174	global READELF
	175	global READELFFLAGS
9921923c	176	global readelf_size
252b5132 RH	177	global srcdir
	178	global subdir
	179
9921923c	180	send_log "exec $READELF $READELFFLAGS $options $binary_file > readelf.out\n"
252b5132 RH	181	catch "exec $READELF $READELFFLAGS $options $binary_file > readelf.out" got
252b5132 RH	182
9a1c9383 NC	183	foreach xfail $xfails {
9a1c9383 NC	184	setup_xfail $xfail
252b5132 RH	185	}
	186
	187	if ![string match "" $got] then {
	188	send_log $got
	189	fail "readelf $options"
	190	return
	191	}
	192
ade0b24f NC	193	set target_machine ""
	194	if [istarget "mips--*"] then {
	195	set target_machine mips
	196	}
	197
	198	if { $target_machine != "" && [file exists $srcdir/$subdir/$regexp_file-$readelf_size-$target_machine] } then {
	199	set regexp_file $regexp_file-$readelf_size-$target_machine
	200	} elseif { $target_machine != "" && [file exists $srcdir/$subdir/$regexp_file-$target_machine] } then {
	201	set regexp_file $regexp_file-$target_machine
	202	} elseif { [file exists $srcdir/$subdir/$regexp_file-$readelf_size] } then {
9921923c HPN	203	set regexp_file $regexp_file-$readelf_size
	204	}
	205
252b5132 RH	206	if { [regexp_diff readelf.out $srcdir/$subdir/$regexp_file] } then {
	207	fail "readelf $options"
	208	verbose "output is \n[file_contents readelf.out]" 2
	209	return
	210	}
	211
	212	pass "readelf $options"
	213	}
	214
	215
	216
	217	# Only ELF based toolchains need readelf.
	218	# For now be paranoid and assume that if ELF is not mentioned
	219	# in the target string, then the target is not an ELF based port.
	220
	221	if ![istarget "-elf"] then {
9921923c	222	verbose "$READELF is only intended for ELF targets" 2
252b5132 RH	223	return
	224	}
	225
	226	if ![is_remote host] {
	227	if {[which $READELF] == 0} then {
	228	perror "$READELF does not exist"
	229	return
	230	}
	231	}
	232
	233	send_user "Version [binutil_version $READELF]"
	234
	235	# Assemle the test file.
	236	if {![binutils_assemble $srcdir/$subdir/bintest.s tmpdir/bintest.o]} then {
	237	perror "unresolved 1"
	238	unresolved "readelf - failed to assemble"
	239	return
	240	}
	241
	242	if ![is_remote host] {
	243	set tempfile tmpdir/bintest.o;
	244	} else {
	245	set tempfile [remote_download host tmpdir/bintest.o]
	246	}
	247
9921923c HPN	248	# First, determine the size, so specific output matchers can be used.
	249	readelf_find_size $tempfile
	250
	251	# Run the tests.
252b5132	252	readelf_test -h $tempfile readelf.h {}
ade0b24f NC	253	readelf_test -S $tempfile readelf.s {}
ade0b24f NC	254	readelf_test -s $tempfile readelf.ss {}
252b5132 RH	255	readelf_test -r $tempfile readelf.r {}
	256
	257
	258	# Compile the second test file.
	259	if { [target_compile $srcdir/$subdir/testprog.c tmpdir/testprog.o object debug] != "" } {
	260	untested "readelf -w"
	261	return
	262	}
	263
	264	if [is_remote host] {
	265	set tempfile [remote_download host tmpdir/testprog.o];
	266	} else {
	267	set tempfile tmpdir/testprog.o
	268	}
	269
	270	# The xfail targets here do not default to DWARF2 format debug information
	271	# The symptom is that the output of 'readelf -wi' is empty.
	272
ba181e2f	273	readelf_test -wi $tempfile readelf.wi {v850--* cris--}