URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [gas/] [testsuite/] [gas/] [sh/] [arch/] [arch.exp] - Rev 856
Go to most recent revision | Compare with Previous | Blame | View Log
# Copyright (C) 2004, 2005, 2007
# 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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
# Please email any bugs, comments, and/or additions to this file to:
# binutils@sources.redhat.com
# This scripts tests all available SH architectures with all the assembler
# options related to the architecture. It ensures that those combinations
# which should not work do not work, and that those that should work
# produce the correct output architecture.
#
# It looks for files in the same directory as this file named sh*.s .
# Each file must contain all the instructions available within
# that architecture. The architecture name is inferred from the file name.
#
# The sh*.s files should NOT be hand edited. Whenever the script is run
# (e.g. with 'make check') it creates a set of new (usually identical) files
# in the <objdir>/gas/testsuite directory. These are compared against the
# old ones in the testsuite. When the expected results change (or new
# architectures are added) these new files can be used to replace the old
# ones with no modification required.
#
# The script generates the architecture/option permutations automatically,
# but it reads the expected results from the file arch_expected.txt (also
# found in the same directory as this script).
#
# The arch_expected.txt file should NOT be hand edited. Whenever the script
# is run (e.g. with 'make check') it creates a new (usually identical) file
# named arch_results.txt in the <objdir>/gas/testsuite directory. When the
# expected results change (or new architectures are added) this new file
# can be used to replace arch_expected.txt with no modification required.
if {[istarget sh*-*-*]} then {
# This procedure extracts the architecture name from the objdump output.
# If there is no architecture name (or objdump output changes significantly)
# then the behaviour is undefined, but it will most likely return junk.
proc get_sh_arch { ofile } {
global comp_output
objdump "-f $ofile"
send_log $comp_output
set comp_output [string replace $comp_output 0 \
[expr [string first "architecture:" $comp_output] + 13] ""]
return [string range $comp_output 0 [expr [string first "," $comp_output] - 1]]
}
# This procedure runs two tests:
# Test 1: Check the assembler can assemble the given file with
# given options.
# Test 2: Check that the resultant architecture is as expected.
# It also writes an entry to the arch_results.txt file.
proc test_arch { file opt arch resultfile } {
global comp_output
set name [file tail $file]
set rootname [file rootname $name]
if [string equal $opt "default-options"] then {
gas_run $name "-o ${rootname}-#${opt}#.o" ""
} else {
gas_run $name "$opt -o ${rootname}-#${opt}#.o" ""
}
if [want_no_output "$rootname file should assemble with $opt"] then {
set result [get_sh_arch "${rootname}-#${opt}#.o"]
puts $resultfile [format "%-20s %-25s %s" $file $opt $result]
if {$result == $arch} then {
pass "$rootname file with $opt should assemble to arch $arch"
file delete "${rootname}-#${opt}#.o"
} else {
send_log $comp_output
fail "$rootname file with $opt should assemble to arch $arch"
}
} else {
puts $resultfile [format "%-20s %-25s ERROR" $file $opt]
untested "$rootname file with $opt should assemble to arch $arch"
}
}
# This procedure tests that a file that is not suposed to assemble
# with a given option does, in fact, not assemble.
# It also writes an entry to the arch_results.txt file.
proc test_arch_error { file opt resultfile} {
global comp_output
set name [file tail $file]
set rootname [file rootname $name]
if [string equal $opt "default-options"] then {
gas_run $name "-o ${rootname}-#${opt}#.o" ""
} else {
gas_run $name "$opt -o ${rootname}-#${opt}#.o" ""
}
if [string match "" $comp_output] then {
fail "$rootname file with $opt should not assemble"
puts $resultfile [format "%-20s %-25s [get_sh_arch ${rootname}-#${opt}#.o]" $file $opt]
} else {
pass "$rootname file with $opt should not assemble"
puts $resultfile [format "%-20s %-25s ERROR" $file $opt]
}
}
# These tests are not suitable for sh-coff because
# coff does not store the architecture information.
if [istarget sh*-*-elf] then {
global subdir srcdir
# Find all the architectures and generate the
# list of options we will test.
set filelist [lsort -ascii [glob "$srcdir/$subdir/sh*.s"]]
set optlist {"default-options" "-dsp" "-isa=any" "-isa=dsp" "-isa=fp"}
foreach file $filelist {
set arch [file rootname [file tail $file]]
lappend optlist "-isa=$arch" "-isa=${arch}-up"
}
# Initialise the results file
set outfile [open "arch_results.txt" w 0666]
puts $outfile "# Generated file. DO NOT EDIT"
puts $outfile "#"
puts $outfile "# This file is generated by gas/testsuite/gas/sh/arch/arch.exp ."
puts $outfile "# It contains the expected results of the tests."
puts $outfile "# If the tests are failing because the expected results"
puts $outfile "# have changed then run 'make check' and copy the new file"
puts $outfile "# from <objdir>/gas/testsuite/arch_results.txt"
puts $outfile "# to <srcdir>/gas/testsuite/gas/sh/arch/arch_expected.txt ."
puts $outfile "# Make sure the new expected results are ALL correct."
puts $outfile "#"
puts $outfile [format "# %-18s %-25s %s" "FILE" "OPTION" "OUTPUT"]
puts $outfile [format "# %-18s %-25s %s" "----" "------" "------"]
# Open the expected results file and skip the header
set infile [open "$srcdir/$subdir/arch_expected.txt" r]
while {[gets $infile line] >= 0 && [string match {\#*} $line]} {send_log "reading '$line'\n"}
foreach file $filelist {
foreach opt $optlist {
set name [file tail $file]
set rootname [file rootname $name]
# Decode the expected result from the file
scan $line "%s %s %s" exfile exopt exarch
send_log "exfile = '$exfile', exopt = '$exopt', exarch = '$exarch'\n"
send_log " name = '$name', opt = '$opt'\n"
if {[string equal $exfile $name] && [string equal $exopt $opt]} then {
# The expected result file makes sense and
# appears up-to-date (the file and options match)
if {[string equal $exarch "ERROR"]} then {
test_arch_error $name $opt $outfile
} else {
test_arch $name $opt $exarch $outfile
}
} else {
# The expected result file isn't right somehow
# so just try any old test. This will cause
# many failures, but will generate the results file.
test_arch $name $opt $rootname $outfile
}
# Read the next line from the expected result file.
# This is at the end because the process of skipping
# the header reads the first real line
if [gets $infile line] then {
send_log "reading '$line'\n"
}
}
}
close $infile
close $outfile
}
#########################################################################
# Generate one sh*.s file for each architecture defined in sh-opc.h
# This will contain all the instructions valid on that platform
#
# This code produces pass or fail reports for each instruction
# in order to ensure that problems are visible to the developer,
# rather than just warnings hidden in the log file.
# These variables will contains the architecture
# and instruction data extracted from sh-opc.h
array set arches {}
set archcount 0
array set insns {}
set insncount 0
# Pull the architecture inheritance macros out of sh-opc.h
# Pull all the insns out of the sh-opc.h file.
send_log "Reading sh-opc.h\n"
send_log "--------------------------------------------------------\n"
spawn -noecho cat "$srcdir/../../opcodes/sh-opc.h" ;# -open doesn't seem to be reliable
expect {
-re {#define\s+arch_([^ ]*)_up\s*\(([^)]*)\)} {
set arches($archcount) [string map {_ -} $expect_out(1,string)]
set arches($archcount,descendents) [string map {_ -} $expect_out(2,string)]
incr archcount
pass "Architecture arch_$expect_out(1,string) read OK"
exp_continue
}
# Match all 32 bit opcodes
-re {(?x) # enable expanded regexp syntax
^/\* # open C comment at start of input
(?:\s*\S+){2} # 2 binary words (for 32 bit opcodes)
\s+ ([^*]+?) # instruction mnemonics (must not leave comment)
\s* \*/ # close C comment
\s* \{ # open brace of data initialiser
(?:[^\}]+\}){2}# 2 brace pairs (operands and nibbles)
\s* , # comma
\s* arch_(\S+)_up # architecture name
\s* \| # literal or
\s* arch_op32 # 32 bit opcode indicator
\s* \} # close brace of data initialiser
} {
set insns(insn,$insncount) $expect_out(1,string)
set insns(arch,$insncount) [string map {_ -} $expect_out(2,string)]
set insns(context,$insncount) $expect_out(0,string)
incr insncount
pass "Instruction '$expect_out(1,string)' read OK"
exp_continue
}
# Special case: Match the repeat pseudo op
-re {(?x) # enable expanded regexp syntax
^/\* # open C comment at start of input
\s* repeat # repeat does not have a bit pattern
\s+ start\s+end # don't read fake operands as such (replaced below)
\s+ ([^*]+?) # instruction operand
\s* \*/ # close C comment
\s* \{ # open brace of data initialiser
(?:[^\}]+\}){2}# 2 brace pairs (operands and nibbles)
\s* , # comma
\s* arch_(\S+)_up # architecture name
\s* \} # close brace of data initialiser
} {
set insns(insn,$insncount) "repeat 10 20 $expect_out(1,string)"
set insns(arch,$insncount) [string map {_ -} $expect_out(2,string)]
set insns(context,$insncount) $expect_out(0,string)
incr insncount
pass "Instruction '$expect_out(1,string)' read OK"
exp_continue
}
# Match all 16 bit opcodes
-re {(?x) # enable expanded regexp syntax
^/\* # open C comment at start of input
\s* \S+ # 1 binary word (for 16 bit opcodes)
\s+ ([^*]+?) # instruction mnemonics (must not leave comment)
\s* \*/ # close C comment
\s* \{ # open brace of data initialiser
(?:[^\}]+\}){2}# 2 brace pairs (operands and nibbles)
\s* , # comma
\s* arch_(\S+)_up # architecture name
\s* \} # close brace of data initialiser
} {
set insns(insn,$insncount) $expect_out(1,string)
set insns(arch,$insncount) [string map {_ -} $expect_out(2,string)]
set insns(context,$insncount) $expect_out(0,string)
incr insncount
pass "Instruction '$expect_out(1,string)' read OK"
exp_continue
}
# Match all remaining possible instructions (error detection)
-re {(?x) # enable expanded regexp syntax
^/\* # open C comment at start of input
(?:[^*]*(?:\*[^/])?)+ # match contents of comment allowing *
\*/ # close C comment
\s* \{ # open brace of data initialiser
(?:[^\}]+\}){2}# 2 brace pairs (operands and nibbles)
\s* , # comma
[^\}]*
arch # look for 'arch' anywhere before closing brace
[^\}]*
\} # close brace of data initialiser
} {
fail "Found something that looks like an instruction but cannot be decoded:\n\t$expect_out(0,string)"
exp_continue
}
# No match so move to next (possible) comment
-re {^.+?((?=/\*)|(?=\#\s*define))} exp_continue
}
send_log "--------------------------------------------------------\n"
if {$archcount == 0} then {
fail "Unable to read any architectures from sh-opc.h"
} else {
pass "Read architecture data from sh-opc.h"
}
if {$insncount == 0} then {
fail "Unable to read any instructions from sh-opc.h"
} else {
pass "Read instruction data from sh-opc.h"
}
# Munge the insns such that they will assemble
# Each instruction in sh-opc.h has an example format
# with placeholders for the parameters. These placeholders
# need to be replaced with real registers and constants
# as appropriate in order to assemble correctly.
for {set i 0} {$i < $insncount} {incr i} {
set out $insns(insn,$i)
if {[regexp {AY_.{3,4}_N} $insns(context,$i)] == 1} then {
regsub -nocase {<REG_N>} $out {r6} out
} else {
regsub -nocase {<REG_N>} $out {r4} out
}
regsub -nocase {<REG_M>} $out {r5} out
if {[regexp {IMM0_20BY8} $insns(context,$i)] == 1} then {
regsub -nocase {<imm>} $out {1024} out
} else {
regsub -nocase {<imm>} $out {4} out
}
regsub -nocase {<bdisp\d*>} $out {.+8} out
regsub -nocase {<disp12>} $out {2048} out
regsub -nocase {<disp\d*>} $out {8} out
regsub -nocase {Rn_BANK} $out {r1_bank} out
regsub -nocase {Rm_BANK} $out {r2_bank} out
regsub -nocase {<F_REG_N>} $out {fr1} out
regsub -nocase {<F_REG_M>} $out {fr2} out
regsub -nocase {<D_REG_N>} $out {dr2} out
regsub -nocase {<D_REG_M>} $out {dr4} out
regsub -nocase {<V_REG_N>} $out {fv0} out
regsub -nocase {<V_REG_M>} $out {fv4} out
regsub -nocase {<DX_REG_N>} $out {xd2} out
regsub -nocase {<DX_REG_M>} $out {xd4} out
regsub -nocase (XMTRX_M4) $out {xmtrx} out
regsub -nocase (<DSP_REG_X>) $out {x1} out
regsub -nocase (<DSP_REG_Y>) $out {y0} out
regsub -nocase (<DSP_REG_M>) $out {a1} out
regsub -nocase (<DSP_REG_N>) $out {m0} out
regsub -nocase (<REG_Axy>) $out {r1} out
regsub -nocase (<REG_Ayx>) $out {r3} out
regsub -nocase (<DSP_REG_XY>) $out {y1} out
regsub -nocase (<DSP_REG_YX>) $out {y1} out
regsub -nocase (<DSP_REG_AX>) $out {a0} out
regsub -nocase (<DSP_REG_AY>) $out {a0} out
regsub (Se) $out {x0} out
regsub (Sf) $out {y0} out
regsub (Dg) $out {m0} out
# Put in a dct in order to differentiate between
# conditional and non-conditional pabs and prnd
# i.e. between sh-dsp and sh4al-dsp
if {[regexp {PPIC} $insns(context,$i)] == 1} then {
set out "dct $out"
}
# Make sure the proper alignments are ok.
if [regexp {i8p4} $insns(context,$i)] {
set out ".align 2\n\t$out"
}
# Write back the results.
set insns(insn,$i) $out
set insns(context,$i) [string map {\n " " \r " "} $insns(context,$i)]
}
# Initialise the data structure for the inheritance
array set archtree {}
for {set a 0} {$a < $archcount} {incr a} {
set archtree($arches($a)) {}
}
# For each architecture, extract its immediate parents
for {set a 0} {$a < $archcount} {incr a} {
set s $arches($a,descendents)
regsub -all {[\s|]+} $s { } s
foreach word [split $s { }] {
# Word should be one of arch-..., | (or), or arch-...-up
# We only want the -up information
# Note that the _ -> - translation was done above
if {[regexp {^arch-(.*)-up$} $word match arch] == 1} then {
# $arch is the descendent of $arches($a),
# so $arches($a) is the parent of $arch
lappend archtree($arch) $arches($a)
}
}
}
# Propagate the inhertances through the list
# Iterate to ensure all inheritances are found (necessary?)
set changesmade 1
while {$changesmade == 1} {
set changesmade 0
foreach a [array names archtree] {
foreach b [array names archtree] {
# If arch 'a' is a parent of arch 'b' then b inherits from a
if {[lsearch -exact $archtree($b) $a] != -1} then {
# Only add each arch if it is not already present
foreach arch $archtree($a) {
if {[lsearch -exact $archtree($b) $arch] == -1} then {
lappend archtree($b) $arch
set changesmade 1
}
}
}
}
}
}
# Generate the assembler file for each architecture
# Also count up how many instructions should be valid for each architecture
array set insns_valid {}
for {set arch 0} {$arch < $archcount} {incr arch} {
set insns_valid($arches($arch)) 0
set fd [open $arches($arch).s w 0666]
puts $fd "! Generated file. DO NOT EDIT.\n!"
puts $fd "! This file was generated by gas/testsuite/gas/sh/arch/arch.exp ."
puts $fd "! This file should contain every instruction valid on"
puts $fd "! architecture $arches($arch) but no more."
puts $fd "! If the tests are failing because the expected results"
puts $fd "! have changed then run 'make check' and copy the new file"
puts $fd "! from <objdir>/gas/testsuite/$arches($arch).s"
puts $fd "! to <srcdir>/gas/testsuite/gas/sh/arch/$arches($arch).s ."
puts $fd "! Make sure there are no unexpected or missing instructions."
puts $fd "\n\t.section .text"
puts $fd "[string map {- _} $arches($arch)]:"
puts $fd "! Instructions introduced into $arches($arch)"
for {set i 0} {$i < $insncount} {incr i} {
if [string equal $arches($arch) $insns(arch,$i)] then {
puts $fd [format "\t%-25s ;!%s" $insns(insn,$i) $insns(context,$i)]
incr insns_valid($arches($arch))
}
}
puts $fd "\n! Instructions inherited from ancestors: [lsort -increasing $archtree($arches($arch))]"
for {set i 0} {$i < $insncount} {incr i} {
if {[string equal $arches($arch) $insns(arch,$i)] != 1 && [lsearch -exact $archtree($arches($arch)) $insns(arch,$i)] != -1} then {
puts $fd [format "\t%-25s ;!%s" $insns(insn,$i) $insns(context,$i)]
incr insns_valid($arches($arch))
}
}
close $fd
}
###################################################################
# Compare the newly created sh*.s files with the existing
# ones in the testsuite
for {set arch 0} {$arch < $archcount} {incr arch} {
send_log "diff $srcdir/$subdir/$arches($arch).s $arches($arch).s\n"
catch "exec diff $srcdir/$subdir/$arches($arch).s $arches($arch).s" diff_output
if {[string equal $diff_output ""] == 0} then {
send_log $diff_output
fail "Check $arches($arch) architecture has not changed"
} else {
pass "Check $arches($arch) architecture has not changed"
}
}
###################################################################
# Generate an assembler file with every instruction
# Then use it to test how many failures there are for
# each architecture. If this does not match the predicted value
# then the assembler accepts too many instructions for a given
# architecture.
set fd [open "all_insns.s" w 0666]
for {set i 0} {$i < $insncount} {incr i} {
puts $fd [format "\t%-25s ;!%s" $insns(insn,$i) $insns(context,$i)]
}
close $fd
# Assemble the all_insns.s file for each isa and count how many failures there are
foreach arch [array names insns_valid] {
set errormessages 0
set expected [expr $insncount - $insns_valid($arch)]
# The -Z option ensures that all error messages are output,
# even those from later phases of assembly (such as offset range errors)
send_log "$AS -Z -isa=$arch all_insns.s -o /dev/null\n"
spawn $AS -Z -isa=$arch all_insns.s -o /dev/null
expect Error: {incr errormessages; exp_continue}
if {$errormessages == $expected} then {
pass "$expected insns should not assemble on $arch"
} else {
if {([istarget sh*-*-coff] || [istarget sh*-hms]) && [string match {*dsp} $arch]} {
xfail "$expected insns should not assemble on $arch ($errormessages did not)"
} else {
fail "$expected insns should not assemble on $arch ($errormessages did not)"
}
}
}
} ;# istarget sh*-*-*
Go to most recent revision | Compare with Previous | Blame | View Log