OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* gas/mn10200/*.s: New tests for the mn10200 assembler. 

* gas/mn10200/basic.exp: Run them.
Tests for all instructions except mov*.
This commit is contained in:
Jeff Law 1996-12-10 00:14:35 +00:00
parent 1fe1c717d9
commit 9d49699b24
14 changed files with 926 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gas/testsuite/ChangeLog
View File

@ -1,3 +1,8 @@
Mon Dec 9 17:08:38 1996 Jeffrey A Law (law@cygnus.com)
* gas/mn10200/*.s: New tests for the mn10200 assembler.
* gas/mn10200/basic.exp: Run them.
Fri Dec 6 15:35:04 1996 Jeffrey A Law (law@cygnus.com) Fri Dec 6 15:35:04 1996 Jeffrey A Law (law@cygnus.com)
* gas/mn10300/*.s: Remove '$' register prefixing. * gas/mn10300/*.s: Remove '$' register prefixing.

12
gas/testsuite/gas/mn10200/.Sanitize
View File

@ -24,6 +24,18 @@ Do-first:
# with rm -rf. # with rm -rf.
Things-to-keep: Things-to-keep:
add.s
basic.exp
bcc.s
bccs.s
bit.s
cmp.s
ext.s
logical.s
muldiv.s
other.s
shift.s
sub.s
Things-to-lose: Things-to-lose:

13
gas/testsuite/gas/mn10200/add.s Executable file
View File

@ -0,0 +1,13 @@
.text
add d1,d2
add d2,a3
add a2,d1
add a3,a2
add 16,d1
add 256,d2
add 131071,d3
add 16,a1
add 256,a2
add 131071,a3
addc d1,d2
addnf 16,a2

800
gas/testsuite/gas/mn10200/basic.exp Executable file
View File

@ -0,0 +1,800 @@
# Copyright (C) 1996 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:
# DejaGnu@cygnus.com
# Written by Cygnus Support.
proc do_add {} {
set testname "add.s: Add operations"
set x 0
gas_start "add.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 96\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0001 F20B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0003 F2C9\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0005 F24E\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0007 D510\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0009 F71A0001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000d F463FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +8 +01\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 D110\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 F70A0001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 F467FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +11 +01\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001d F286\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001f F50E10\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==14] then { pass $testname } else { fail $testname }
}
proc do_bcc {} {
set testname "bcc.s: Bcc tests"
set x 0
gas_start "bcc.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 E800\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 E900\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 E100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 E200\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 E300\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a E000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c E500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e E600\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 E700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 E400\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 F5FC00\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0017 F5FD00\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a F5FE00\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001d F5FF00\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 EA00\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==15] then { pass $testname } else { fail $testname }
}
proc do_bccx {} {
set testname "bccx.s: Bccx tests"
set x 0
gas_start "bccx.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 F5E800\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0003 F5E900\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 F5E100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0009 F5E200\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c F5E300\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000f F5E000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 F5E500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0015 F5E600\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 F5E700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001b F5E400\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e F5EC00\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0021 F5ED00\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 F5EE00\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0027 F5EF00\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==14] then { pass $testname } else { fail $testname }
}
proc do_bit {} {
set testname "bit.s: bit tests"
set x 0
gas_start "bit.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 F50540\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0003 F7060020\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0007 F029\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0009 F039\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +12 +FFFF40\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==4] then { pass $testname } else { fail $testname }
}
proc do_cmp {} {
set testname "cmp.s: cmp tests"
set x 0
gas_start "cmp.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 F396\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 F22B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 F2EF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 F26E\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 DB10\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a F74A0001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e F479FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +8 +01\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0013 EE0001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 F47DFFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +10 +01\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==11] then { pass $testname } else { fail $testname }
}
proc do_ext {} {
set testname "ext.s: ext tests"
set x 0
gas_start "ext.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 F3C5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 B2\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0003 B7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 BA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0005 BD\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==5] then { pass $testname } else { fail $testname }
}
proc do_extend {} {
set testname "extend.s: extended instruction tests"
set x 0
gas_start "extend.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 F505\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 F6FA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 F606\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 F90210\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0009 FB030100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000d FD030001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +7 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0013 F616\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0015 F91610\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 FB170100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c FD170001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0022 F64B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 F65E\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0026 F676\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==15] then { pass $testname } else { fail $testname }
}
proc do_logical {} {
set testname "logical.s: logical tests"
set x 0
gas_start "logical.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 F306\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 F5027F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0005 F703FF7F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0009 F710FF7F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000d F316\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000f F50A7F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 F743FF7F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 F714FF7F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a F326\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c F74FFF7F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 F3E7\[^\n\]*\n" { set x [expr $x+1] }
-re "^\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==11] then { pass $testname } else { fail $testname }
}
proc do_loop {} {
set testname "loop.s: loop tests"
set x 0
gas_start "loop.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 D8\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0001 D9\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 D1\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0003 D2\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 D3\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0005 D0\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 D5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0007 D6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 D7\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0009 D4\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a DA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000b DB\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==12] then { pass $testname } else { fail $testname }
}
proc do_mov1 {} {
set testname "mov1.s: mov1 tests"
set x 0
gas_start "mov1.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 86\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0001 F1E6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0003 F1D9\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0005 99\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 3E\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0007 F2F4\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0009 F2FB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000b F2E1\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000d F2FA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000f 76\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 F80608\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0013 FA060100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0017 FC060001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +14 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001d 5908\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001f FAB50100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0023 F2E7\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==17] then { pass $testname } else { fail $testname }
}
proc do_mov2 {} {
set testname "mov2.s: mov2 tests"
set x 0
gas_start "mov2.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 FCB50001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +2 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 F325\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 318000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000b FCA50001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +5 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0011 F006\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0013 F82608\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 FA260100 \[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a FC260001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +9 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 5D08\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0022 FAB10100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0026 FCB10001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +12 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c F3A5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002e FAA18000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0032 FCA10001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +15 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 F8F120\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==20] then { pass $testname } else { fail $testname }
}
proc do_mov3 {} {
set testname "mov3.s: mov3 tests"
set x 0
gas_start "mov3.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 66\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0001 F81620\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 FA160100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 FC160001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +5 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e 4620\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 FA958000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 FC950001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +8 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a F35A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c 050080\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001f FC850001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0025 F016\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0027 F83620\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002a FA360100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002e FC360001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +15 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 4720\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==19] then { pass $testname } else { fail $testname }
}
proc do_mov4 {} {
set testname "mov4.s: mov4 tests"
set x 0
gas_start "mov4.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 FA948000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 FC940001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +3 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a F3DA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c FA840080\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 FC840001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +6 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 F8F520\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0019 8508\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001b 2D0100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e FCCD0001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +10 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 9508\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0026 250100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0029 FCDD0001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +13 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==16] then { pass $testname } else { fail $testname }
}
proc do_movbu {} {
set testname "movbu.s: movbu tests"
set x 0
gas_start "movbu.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 F046\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 F84608\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0005 FA460100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0009 FC460001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +5 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000f F8B908\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 FAB90100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 FCB90001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +8 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c F425\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e 358000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0021 FCA90001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0027 F056\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0029 F85620\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c FA560100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 FC560001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +15 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0036 F89620\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0039 FA968000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003d FC960001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +18 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0043 F45A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0045 060080\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 FC860001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +21 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==26] then { pass $testname } else { fail $testname }
}
proc do_movhu {} {
set testname "movhu.s: movhu tests"
set x 0
gas_start "movhu.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 F066\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 F86608\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0005 FA660100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0009 FC660001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +5 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000f F8BD08\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 FABD0100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 FCBD0001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +8 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c F4A5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e 398000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0021 FCAD0001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0027 F076\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0029 F87620\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c FA760100\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 FC760001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +15 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0036 F89720\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0039 FA978000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003d FC970001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +18 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0043 F4DA\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0045 070080\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 FC870001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +21 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==26] then { pass $testname } else { fail $testname }
}
proc do_movm {} {
set testname "movm.s: movm tests"
set x 0
gas_start "movm.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 CE30\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 CEF8\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 CF30\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 CFF8\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==4] then { pass $testname } else { fail $testname }
}
proc do_muldiv {} {
set testname "muldiv.s: muldiv tests"
set x 0
gas_start "muldiv.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 F346\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 F35B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 F36E\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==3] then { pass $testname } else { fail $testname }
}
proc do_other {} {
set testname "other.s: other tests"
set x 0
gas_start "other.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 FC0001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0003 F4E0FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +3 +01\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 F008\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a FD0001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000d F4E1FFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +6 +01\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 F009\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 FE\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0015 EB\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 F6\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==11] then { pass $testname } else { fail $testname }
}
proc do_shift {} {
set testname "shift.s: shift tests"
set x 0
gas_start "shift.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 F33A\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 F33F\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 F335\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 F332\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==4] then { pass $testname } else { fail $testname }
}
proc do_sub {} {
set testname "sub.s: sub tests"
set x 0
gas_start "sub.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 A6\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0001 F21B\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0003 F2DF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0005 F25E\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0007 F71EFF7F \[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000b F46AFFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +7 +01\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 F70EFF7F \[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 F46EFFFF\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +9 +01\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0019 F296 \[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==11] then { pass $testname } else { fail $testname }
}
if [istarget mn10200*-*-*] then {
# Test the basic instruction parser.
do_add
do_bcc
do_bccx
do_bit
do_cmp
do_ext
do_logical
# do_mov1
# do_mov2
# do_mov3
# do_mov4
# do_movbu
do_muldiv
do_other
do_shift
do_sub
}

17
gas/testsuite/gas/mn10200/bcc.s Executable file
View File

@ -0,0 +1,17 @@
.text
foo:
beq foo
bne foo
bgt foo
bge foo
ble foo
blt foo
bhi foo
bcc foo
bls foo
bcs foo
bvc foo
bvs foo
bnc foo
bns foo
bra foo

16
gas/testsuite/gas/mn10200/bccx.s Executable file
View File

@ -0,0 +1,16 @@
.text
foo:
beqx foo
bnex foo
bgtx foo
bgex foo
blex foo
bltx foo
bhix foo
bccx foo
blsx foo
bcsx foo
bvcx foo
bvsx foo
bncx foo
bnsx foo

5
gas/testsuite/gas/mn10200/bit.s Executable file
View File

@ -0,0 +1,5 @@
.text
btst 64,d1
btst 8192,d2
bset d1,(a2)
bclr d1,(a2)

10
gas/testsuite/gas/mn10200/cmp.s Executable file
View File

@ -0,0 +1,10 @@
.text
cmp d1,d2
cmp d2,a3
cmp a3,d3
cmp a3,a2
cmp 16,d3
cmp 256,d2
cmp 131071,d1
cmp 256,a2
cmp 131071,a1

7
gas/testsuite/gas/mn10200/ext.s Executable file
View File

@ -0,0 +1,7 @@
.text
ext d1
extx d2
extxu d3
extxb d2
extxbu d1

12
gas/testsuite/gas/mn10200/logical.s Executable file
View File

@ -0,0 +1,12 @@
.text
and d1,d2
and 127,d2
and 32767,d3
and 32767,psw
or d1,d2
or 127,d2
or 32767,d3
or 32767,psw
xor d1,d2
xor 32767,d3
not d3

4
gas/testsuite/gas/mn10200/muldiv.s Executable file
View File

@ -0,0 +1,4 @@
.text
mul d1,d2
mulu d2,d3
divu d3,d2

10
gas/testsuite/gas/mn10200/other.s Executable file
View File

@ -0,0 +1,10 @@
.text
jmp 256
jmp 131071
jmp (a2)
jsr 256
jsr 131071
jsr (a2)
rts
rti
nop

5
gas/testsuite/gas/mn10200/shift.s Executable file
View File

@ -0,0 +1,5 @@
.text
asr d2
lsr d3
ror d1
rol d2

10
gas/testsuite/gas/mn10200/sub.s Executable file
View File

@ -0,0 +1,10 @@
.text
sub d1,d2
sub d2,a3
sub a3,d3
sub a3,a2
sub 32767,d2
sub 131071,d2
sub 32767,a2
sub 131071,a2
subc d1,d2