# Support routines for LD testsuite.
# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
-# 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
+# Free Software Foundation, Inc.
#
# This file is part of the GNU Binutils.
#
load_common_lib binutils-common.exp
+# Returns 1 if the gcc for the target is at least version MAJOR.MINOR
+# Returns 0 otherwise.
+#
+proc at_least_gcc_version { major minor } {
+
+ if {![info exists CC]} {
+ set CC [find_gcc]
+ }
+ if { $CC == "" } {
+ return 0
+ }
+ set state [remote_exec host $CC --version]
+ set tmp "[lindex $state 1]\n"
+ # Look for (eg) 4.6.1 in the version output.
+ set ver_re "\[^\\.0-9\]+(\[1-9\]\[0-9\]*)\\.(\[0-9\]+)(?:\\.\[0-9\]+)?"
+ regexp $ver_re $tmp fred maj min
+ verbose "gcc version: $tmp"
+ if { ![info exists maj] || ![info exists min] } then {
+ perror "can't decipher gcc version number, fix the framework!"
+ return 0
+ }
+ verbose "major gcc version is $maj, want at least $major"
+ if { $maj == $major } then {
+ verbose "minor gcc version is $min, want at least $minor"
+ return [expr $min >= $minor]
+ } else {
+ return [expr $maj > $major]
+ }
+}
+
# Extract and print the version number of ld.
#
proc default_ld_version { ld } {
# Assemble a file.
#
-proc default_ld_assemble { as source object } {
+proc default_ld_assemble { as in_flags source object } {
global ASFLAGS
global host_triplet
if ![info exists ASFLAGS] { set ASFLAGS "" }
set flags [big_or_little_endian]
- set exec_output [run_host_cmd "$as" "$flags $ASFLAGS -o $object $source"]
+ set exec_output [run_host_cmd "$as" "$flags $in_flags $ASFLAGS -o $object $source"]
set exec_output [prune_warnings $exec_output]
if [string match "" $exec_output] then {
return 1
set flags "--defsym __stack_chk_fail=0"
# ARM targets call __gccmain
- if {[istarget arm*-*-*] || \
- [istarget strongarm*-*-*] || \
- [istarget xscale*-*-*] || \
- [istarget thumb-*-*] } {
+ if {[istarget arm*-*-*]} {
append flags " --defsym __gccmain=0"
}
}
# m6811/m6812 code has references to soft registers.
- if {[istarget m6811-*-*] || [istarget m6812-*-*]} {
+ if {[istarget m6811-*-*] || [istarget m6812-*-*] || [istarget m68hc1*-*-*]} {
append flags " --defsym _.frame=0 --defsym _.d1=0 --defsym _.d2=0"
append flags " --defsym _.d3=0 --defsym _.d4=0"
append flags " --defsym _.tmp=0 --defsym _.xy=0 --defsym _.z=0"
return $flags
}
-# Compares two files line-by-line.
-# Returns differences if exist.
-# Returns null if file(s) cannot be opened.
-#
-proc simple_diff { file_1 file_2 } {
- global target
-
- set eof -1
- set differences 0
-
- if [file exists $file_1] then {
- set file_a [open $file_1 r]
- } else {
- warning "$file_1 doesn't exist"
- return
- }
-
- if [file exists $file_2] then {
- set file_b [open $file_2 r]
- } else {
- fail "$file_2 doesn't exist"
- return
- }
-
- verbose "# Diff'ing: $file_1 $file_2\n" 2
-
- while { [gets $file_a line] != $eof } {
- if [regexp "^#.*$" $line] then {
- continue
- } else {
- lappend list_a $line
- }
- }
- close $file_a
-
- while { [gets $file_b line] != $eof } {
- if [regexp "^#.*$" $line] then {
- continue
- } else {
- lappend list_b $line
- }
- }
- close $file_b
-
- for { set i 0 } { $i < [llength $list_a] } { incr i } {
- set line_a [lindex $list_a $i]
- set line_b [lindex $list_b $i]
-
- verbose "\t$file_1: $i: $line_a\n" 3
- verbose "\t$file_2: $i: $line_b\n" 3
- if [string compare $line_a $line_b] then {
- verbose -log "\t$file_1: $i: $line_a\n"
- verbose -log "\t$file_2: $i: $line_b\n"
-
- fail "Test: $target"
- return
- }
- }
-
- if { [llength $list_a] != [llength $list_b] } {
- fail "Test: $target"
- return
- }
-
- if $differences<1 then {
- pass "Test: $target"
- }
-}
-
-# run_dump_test FILE
+# run_dump_test FILE (optional:) EXTRA_OPTIONS
# Copied from gas testsuite, tweaked and further extended.
#
# Assemble a .s file, then run some utility on it and check the output.
# list ends with the first line that doesn't match the above syntax
# (hmm, not great for error detection).
#
+# The optional EXTRA_OPTIONS argument to `run_dump_test' is a list of
+# two-element lists. The first element of each is an option name, and
+# the second additional arguments to be added on to the end of the
+# option list as given in FILE.d. (If omitted, no additional options
+# are added.)
+#
# The interesting options are:
#
# name: TEST-NAME
# More than one "source" directive can be given, which is useful
# when testing linking.
#
+# dump: DUMP
+# Match against DUMP.d. If omitted, this defaults to FILE.d. This
+# is useful if several .d files differ by options only. Options are
+# always read from FILE.d.
+#
# xfail: TARGET
# The test is expected to fail on TARGET. This may occur more than
# once.
#
# After the option lines come regexp lines. `run_dump_test' calls
# `regexp_diff' to compare the output of the dumping tool against the
-# regexps in FILE.d. `regexp_diff' is defined later in this file; see
-# further comments there.
+# regexps in FILE.d. `regexp_diff' is defined in binutils-common.exp;
+# see further comments there.
#
-proc run_dump_test { name } {
+proc run_dump_test { name {extra_options {}} } {
global subdir srcdir
global OBJDUMP NM AS OBJCOPY READELF LD
global OBJDUMPFLAGS NMFLAGS ASFLAGS OBJCOPYFLAGS READELFFLAGS LDFLAGS
set opts(name) {}
set opts(PROG) {}
set opts(source) {}
+ set opts(dump) {}
set opts(error) {}
set opts(warning) {}
set opts(objcopy_linked_file) {}
- set asflags(${file}.s) {}
foreach i $opt_array {
set opt_name [lindex $i 0]
warning {}
error {}
source {
- # Move any source-specific as-flags to a separate array to
+ # Move any source-specific as-flags to a separate list to
# simplify processing.
if { [llength $opt_val] > 1 } {
- set asflags([lindex $opt_val 0]) [lrange $opt_val 1 end]
+ lappend asflags [lrange $opt_val 1 end]
set opt_val [lindex $opt_val 0]
} else {
- set asflags($opt_val) {}
+ lappend asflags {}
}
}
default {
if { $opt_name == "as" || $opt_name == "ld" } {
set opt_val [subst $opt_val]
}
- set opts($opt_name) [concat $opts($opt_name) $opt_val]
+
+ # Append differently whether it's a message (without space) or
+ # an option or list (with space).
+ switch -- $opt_name {
+ warning -
+ error {
+ append opts($opt_name) $opt_val
+ }
+ default {
+ set opts($opt_name) [concat $opts($opt_name) $opt_val]
+ }
+ }
}
+
+ foreach i $extra_options {
+ set opt_name [lindex $i 0]
+ set opt_val [lindex $i 1]
+ if ![info exists opts($opt_name)] {
+ perror "unknown option $opt_name given in extra_opts"
+ unresolved $subdir/$name
+ return
+ }
+ # Add extra option to end of existing option, adding space
+ # if necessary.
+ if { ![regexp "warning|error" $opt_name]
+ && [string length $opts($opt_name)] } {
+ append opts($opt_name) " "
+ }
+ append opts($opt_name) $opt_val
+ }
+
foreach opt { as ld } {
regsub {\[big_or_little_endian\]} $opts($opt) \
[big_or_little_endian] opts($opt)
if { $opts(source) == "" } {
set sourcefiles [list ${file}.s]
+ set asflags [list ""]
} else {
set sourcefiles {}
foreach sf $opts(source) {
} else {
lappend sourcefiles "$srcdir/$subdir/$sf"
}
- # Must have asflags indexed on source name.
- set asflags($srcdir/$subdir/$sf) $asflags($sf)
}
}
+ if { $opts(dump) == "" } {
+ set dfile ${file}.d
+ } else {
+ set dfile $srcdir/$subdir/$opts(dump)
+ }
+
# Time to setup xfailures.
foreach targ $opts(xfail) {
setup_xfail $targ
set objfiles {}
for { set i 0 } { $i < [llength $sourcefiles] } { incr i } {
set sourcefile [lindex $sourcefiles $i]
+ set sourceasflags [lindex $asflags $i]
set objfile "tmpdir/dump$i.o"
catch "exec rm -f $objfile" exec_output
lappend objfiles $objfile
- set cmd "$AS $ASFLAGS $opts(as) $asflags($sourcefile) -o $objfile $sourcefile"
+ set cmd "$AS $ASFLAGS $opts(as) $sourceasflags -o $objfile $sourcefile"
send_log "$cmd\n"
set cmdret [remote_exec host [concat sh -c [list "$cmd 2>&1"]] "" "/dev/null" "ld.tmp"]
}
if { $verbose > 2 } then { verbose "output is [file_contents $dumpfile]" 3 }
- if { [regexp_diff $dumpfile "${file}.d"] } then {
+ if { [regexp_diff $dumpfile "${dfile}"] } then {
fail $testname
if { $verbose == 2 } then { verbose "output is [file_contents $dumpfile]" 2 }
return
}
proc slurp_options { file } {
+ # If options_regsub(foo) is set to {a b}, then the contents of a
+ # "#foo:" line will have regsub -all applied to replace a with b.
+ global options_regsub
+
if [catch { set f [open $file r] } x] {
#perror "couldn't open `$file': $x"
perror "$x"
# Whitespace here is space-tab.
if [regexp $pat $line xxx opt_name opt_val] {
# match!
+ if [info exists options_regsub($opt_name)] {
+ set subst $options_regsub($opt_name)
+ regsub -all -- [lindex $subst 0] $opt_val [lindex $subst 1] \
+ opt_val
+ }
lappend opt_array [list $opt_name $opt_val]
} else {
break
return $opt_array
}
-# regexp_diff, copied from gas, based on simple_diff above.
-# 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
- set fail_if_match 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 "#failif" $line_b ] {
- send_log "fail if no difference\n"
- verbose "fail if no difference" 3
- set fail_if_match 1
- } elseif [ string match "#..." $line_b ] {
- if { [gets $file_b line_b] == $eof } {
- set end_2 1
- set diff_pass 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"] {
- verbose "regexp_diff match failure\n" 3
- 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
- }
-
- if { $fail_if_match } {
- if { $differences == 0 } {
- set differences 1
- } else {
- set differences 0
- }
- }
-
- close $file_a
- close $file_b
-
- return $differences
-}
-
proc file_contents { filename } {
set file [open $filename r]
set contents [read $file]
# List contains test-items with 3 items followed by 2 lists, one item and
# one optional item:
-# 0:name 1:ld/ar options 2:assembler options
-# 3:filenames of assembler files 4: action and options. 5: name of output file
-# 6:compiler flags (optional)
+# 0:name
+# 1:ld/ar options
+# 2:assembler options
+# 3:filenames of assembler files
+# 4:list of actions, options and expected outputs.
+# 5:name of output file
+# 6:compiler flags (optional)
#
-# Actions:
-# objdump: Apply objdump options on result. Compare with regex (last arg).
-# nm: Apply nm options on result. Compare with regex (last arg).
-# readelf: Apply readelf options on result. Compare with regex (last arg).
-# ld: Don't apply anything on result. Compare output during linking with
-# regex (second arg). Note that this *must* be the first action if it
-# is to be used at all; in all other cases, any output from the linker
-# during linking is treated as a sign of an error and FAILs the test.
+# Actions: { command command-line-options file-containg-expected-output-regexps }
+# Commands:
+# objdump: Apply objdump options on result.
+# nm: Apply nm options on result.
+# readelf: Apply readelf options on result.
+# ld: Don't apply anything on result. Compare output during linking with
+# the file containing regexps (which is the second arg, not the third).
+# Note that this *must* be the first action if it is to be used at all;
+# in all other cases, any output from the linker during linking is
+# treated as a sign of an error and FAILs the test.
#
proc run_ld_link_tests { ldtests } {
global ld
# Assemble each file in the test.
foreach src_file $src_files {
- set objfile "tmpdir/[file rootname $src_file].o"
+ set fileroot "[file rootname [file tail $src_file]]"
+ set objfile "tmpdir/$fileroot.o"
lappend objfiles $objfile
if { [file extension $src_file] == ".c" } {
- set as_file "tmpdir/[file rootname $src_file].s"
+ set as_file "tmpdir/$fileroot.s"
if ![ld_compile "$CC -S $CFLAGS $cflags" $srcdir/$subdir/$src_file $as_file] {
set is_unresolved 1
break
}
# Catch assembler errors.
- if { $is_unresolved != 0 } {
+ if { $is_unresolved } {
unresolved $testname
continue
}
if { [regexp ".*\\.a$" $binfile] } {
if { ![ar_simple_create $ar $ld_options $binfile "$objfiles"] } {
- fail $testname
set failed 1
- } else {
- set failed 0
}
} elseif { ![ld_simple_link $ld $binfile "-L$srcdir/$subdir $ld_options $objfiles"] } {
set maybe_failed 1
set ld_output "$exec_output"
- } else {
- set failed 0
}
- if { $failed == 0 } {
+ if { !$failed } {
foreach actionlist $actions {
set action [lindex $actionlist 0]
set progopts [lindex $actionlist 1]
}
if { $action == "ld" } {
- set dumpfile [lindex $actionlist 1]
- verbose "dumpfile is $dumpfile"
+ set regexpfile $progopts
+ verbose "regexpfile is $srcdir/$subdir/$regexpfile"
set_file_contents "tmpdir/ld.messages" "$ld_output"
verbose "ld.messages has '[file_contents tmpdir/ld.messages]'"
- if { [regexp_diff "tmpdir/ld.messages" "$srcdir/$subdir/$dumpfile"] } then {
+ if { [regexp_diff "tmpdir/ld.messages" "$srcdir/$subdir/$regexpfile"] } then {
verbose "output is $ld_output" 2
set failed 1
break
}
set maybe_failed 0
- } elseif { $maybe_failed != 0 } {
- set failed 1
- break
- } elseif { $dump_prog != "" } {
+ } elseif { !$maybe_failed && $dump_prog != "" } {
set dumpfile [lindex $actionlist 2]
set binary $dump_prog
set comp_output [prune_warnings [file_contents "ld.stderr"]]
remote_file host delete "ld.stderr"
remote_file build delete "ld.stderr"
-
+
if {[info exists old_lc_all]} {
set env(LC_ALL) $old_lc_all
} else {
remote_file host delete "dump.out"
}
}
-
- if { $failed != 0 } {
- fail $testname
- } else { if { $is_unresolved == 0 } {
- pass $testname
- } }
}
- # Catch action errors.
- if { $is_unresolved != 0 } {
+ if { $is_unresolved } {
unresolved $testname
- continue
+ } elseif { $maybe_failed || $failed } {
+ fail $testname
+ } else {
+ pass $testname
}
}
}
# Assemble each file in the test.
foreach src_file $src_files {
- set objfile "tmpdir/[file rootname $src_file].o"
+ set fileroot "[file rootname [file tail $src_file]]"
+ set objfile "tmpdir/$fileroot.o"
lappend objfiles $objfile
# We ignore warnings since some compilers may generate
send_log "Running: $binfile > $binfile.out\n"
verbose "Running: $binfile > $binfile.out"
catch "exec $binfile > $binfile.out" exec_output
-
+
if ![string match "" $exec_output] then {
send_log "$exec_output\n"
verbose "$exec_output" 1
# 4:action and options.
# 5:name of output file
# 6:language (optional)
+# 7:linker warnings (optional)
#
# Actions:
# objdump: Apply objdump options on result. Compare with regex (last arg).
global CFLAGS
global CXXFLAGS
global ar
+ global exec_output
foreach testitem $ldtests {
set testname [lindex $testitem 0]
set actions [lindex $testitem 4]
set binfile tmpdir/[lindex $testitem 5]
set lang [lindex $testitem 6]
+ set warnings [lindex $testitem 7]
set objfiles {}
set is_unresolved 0
set failed 0
# Compile each file in the test.
foreach src_file $src_files {
- set objfile "tmpdir/[file rootname $src_file].o"
+ set fileroot "[file rootname [file tail $src_file]]"
+ set objfile "tmpdir/$fileroot.o"
lappend objfiles $objfile
# We ignore warnings since some compilers may generate
set failed 0
}
} elseif { ![ld_simple_link $cc_cmd $binfile "-L$srcdir/$subdir $ldflags $objfiles"] } {
- fail $testname
- set failed 1
+ # Check if exec_output is expected.
+ if { $warnings != "" } then {
+ verbose -log "returned with: <$exec_output>, expected: <$warnings>"
+ if { [regexp $warnings $exec_output] } then {
+ set failed 0
+ } else {
+ set failed 1
+ }
+ } else {
+ fail $testname
+ set failed 1
+ }
} else {
set failed 0
}
proc check_gc_sections_available { } {
global gc_sections_available_saved
global ld
-
+
if {![info exists gc_sections_available_saved]} {
# Some targets don't support gc-sections despite whatever's
# advertised by ld's options.
|| [istarget or32-*-*]
|| [istarget pj*-*-*]
|| [istarget alpha-*-*]
- || [istarget hppa64-*-*]
+ || [istarget hppa*64-*-*]
|| [istarget i370-*-*]
|| [istarget i860-*-*]
|| [istarget ia64-*-*]
}
# Check if the ld used by gcc supports --gc-sections.
+ # FIXME: this test is useless since ld --help always says
+ # --gc-sections is available
set ld_output [remote_exec host $ld "--help"]
if { [ string first "--gc-sections" $ld_output ] >= 0 } {
set gc_sections_available_saved 1
return $gc_sections_available_saved
}
+# Returns true if -shared is supported on the target
+# Only used and accurate for ELF targets at the moment
+
+proc check_shared_lib_support { } {
+ if {![istarget arc-*-*]
+ && ![istarget avr-*-*]
+ && ![istarget cr16-*-*]
+ && ![istarget cris*-*-*]
+ && ![istarget crx-*-*]
+ && ![istarget d10v-*-*]
+ && ![istarget d30v-*-*]
+ && ![istarget dlx-*-*]
+ && ![istarget epiphany-*-*]
+ && ![istarget fr30-*-*]
+ && ![istarget frv-*-*]
+ && ![istarget h8300-*-*]
+ && ![istarget i860-*-*]
+ && ![istarget i960-*-*]
+ && ![istarget ip2k-*-*]
+ && ![istarget iq2000-*-*]
+ && ![istarget lm32-*-*]
+ && ![istarget m32c-*-*]
+ && ![istarget m32r-*-*]
+ && ![istarget m6811-*-*]
+ && ![istarget m6812-*-*]
+ && ![istarget m68hc1*-*-*]
+ && ![istarget mcore*-*-*]
+ && ![istarget mep-*-*]
+ && ![istarget microblaze-*-*]
+ && ![istarget mn10200-*-*]
+ && ![istarget moxie-*-*]
+ && ![istarget msp430-*-*]
+ && ![istarget mt-*-*]
+ && ![istarget openrisc-*-*]
+ && ![istarget or32-*-*]
+ && ![istarget pj-*-*]
+ && ![istarget rx-*-*]
+ && ![istarget spu-*-*]
+ && ![istarget v850*-*-*]
+ && ![istarget xstormy16-*-*]
+ && ![istarget *-*-irix*]
+ && ![istarget *-*-rtems] } {
+ return 1
+ }
+ return 0
+}
+
# Returns true if the target ld supports the plugin API.
proc check_plugin_api_available { } {
global plugin_api_available_saved
projects / deliverable / binutils-gdb.git / blobdiff