projects / binutils-gdb.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 1e5ddd3)
* gas/mn10300/basic.exp: Check bit patterns for many
authorJeff Law <law@redhat.com>
Thu, 10 Oct 1996 19:13:48 +0000 (19:13 +0000)
committerJeff Law <law@redhat.com>
Thu, 10 Oct 1996 19:13:48 +0000 (19:13 +0000)
        instructions.  Add missing test in do_mov1.
        * gas/mn10300/mov1.s: Add missing test.
We should now assemble just about anything without any
immediate operands.

gas/testsuite/ChangeLog patch | blob | history
gas/testsuite/gas/mn10300/basic.exp patch | blob | history

diff --git a/gas/testsuite/ChangeLog b/gas/testsuite/ChangeLog
index 52f1c91e24e6e9d3089141c0ad20c7f76ce35d76..8ee1445a5223875963b0f0f13eafa585fd910e84 100644 (file)
--- a/gas/testsuite/ChangeLog
+++ b/gas/testsuite/ChangeLog
@@ -1,3 +1,9 @@
+Thu Oct 10 13:11:48 1996  Jeffrey A Law  (law@cygnus.com)
+
+       * gas/mn10300/basic.exp: Check bit patterns for many
+       instructions.  Add missing test in do_mov1.
+       * gas/mn10300/mov1.s: Add missing test.
+
 Wed Oct  9 14:15:18 1996  Jeffrey A Law  (law@cygnus.com)
 
        * gas/mn10300/{add.s, bcc.s, bit.s, cmp.s, ext.s}: New tests.
diff --git a/gas/testsuite/gas/mn10300/basic.exp b/gas/testsuite/gas/mn10300/basic.exp
index 02655783b426655003d7e37aa43fbb6baddf7fc9..ba30fa56b109bbf359a714591ca8d8d5997ab28d 100755 (executable)
--- a/gas/testsuite/gas/mn10300/basic.exp
+++ b/gas/testsuite/gas/mn10300/basic.exp
@@ -30,11 +30,11 @@ proc do_add {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0001\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0003\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0005\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0007\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 E6\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0001 F16B\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0003 F17E\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0005 F159\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0007 \[^\n\]*\n"   { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 000d\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0013\[^\n\]*\n"    { set x [expr $x+1] }
@@ -43,7 +43,7 @@ proc do_add {} {
            -re "^ +\[0-9\]+ 001f\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0022\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0026\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 002c\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 002c F146\[^\n\]*\n"       { set x [expr $x+1] }
            -re "\[^\n\]*\n"                            { }
            timeout                             { perror "timeout\n"; break }
            eof                                 { break }
@@ -69,21 +69,21 @@ proc do_bcc {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0004\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0008\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000a\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000c\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000e\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0010\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0012\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0014\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0017\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 001a\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 001d\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0020\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 C800\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0002 C900\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0004 C100\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0006 C200\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0008 C300\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 000a C000\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 000c C500\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 000e C600\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0010 C700\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0012 C400\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0014 F8E800\[^\n\]*\n"     { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0017 F8E900\[^\n\]*\n"     { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 001a F8EA00\[^\n\]*\n"     { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 001d F8EB00\[^\n\]*\n"     { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0020 CA00\[^\n\]*\n"       { set x [expr $x+1] }
            -re "\[^\n\]*\n"                            { }
            timeout                             { perror "timeout\n"; break }
            eof                                 { break }
@@ -114,10 +114,10 @@ proc do_bit {} {
            -re "^ +\[0-9\]+ 0007\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 000d\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0011\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0018\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0018 F086\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001a\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001e\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0025\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0025 F096\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0027\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 002b\[^\n\]*\n"    { set x [expr $x+1] }
            -re "\[^\n\]*\n"                            { }
@@ -145,10 +145,10 @@ proc do_cmp {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0001\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0003\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0005\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 A6\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0001 F1AB\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0003 F19F\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0005 BE\[^\n\]*\n" { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0008\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 000c\[^\n\]*\n"    { set x [expr $x+1] }
@@ -180,11 +180,11 @@ proc do_ext {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0003\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0004\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0005\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 F2D1\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0002 12\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0003 17\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0004 1A\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0005 1D\[^\n\]*\n" { set x [expr $x+1] }
            -re "\[^\n\]*\n"                            { }
            timeout                             { perror "timeout\n"; break }
            eof                                 { break }
@@ -248,20 +248,20 @@ proc do_logical {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 F206\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0005\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 000f\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0013\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0013 F216\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0015\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0018\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0022\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0026\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0026 F226\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0028\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 002c\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0032\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0032 F233\[^\n\]*\n"       { set x [expr $x+1] }
            -re "\[^\n\]*\n"                            { }
            timeout                             { perror "timeout\n"; break }
            eof                                 { break }
@@ -287,18 +287,18 @@ proc do_loop {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0001\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0003\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0004\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0005\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0007\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0008\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000a\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000b\[^\n\]*\n"    { set x [expr $x+1] }
+           -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 }
@@ -324,21 +324,22 @@ proc do_mov1 {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0001\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0003\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0005\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0007\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000b\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000d\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000f\[^\n\]*\n"    { set x [expr $x+1] }
+           -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\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0013\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0017\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001d\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001f\[^\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 }
@@ -350,7 +351,7 @@ proc do_mov1 {} {
     gas_finish
 
     # Did we find what we were looking for?  If not, flunk it.
-    if [expr $x==15] then { pass $testname } else { fail $testname }
+    if [expr $x==16] then { pass $testname } else { fail $testname }
 }
 
 proc do_mov2 {} {
@@ -368,7 +369,7 @@ proc do_mov2 {} {
            -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0008\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 000b\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0011\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0011 F006\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0013\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0016\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001a\[^\n\]*\n"    { set x [expr $x+1] }
@@ -404,7 +405,7 @@ proc do_mov3 {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 66\[^\n\]*\n" { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0001\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0004\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0008\[^\n\]*\n"    { set x [expr $x+1] }
@@ -414,7 +415,7 @@ proc do_mov3 {} {
            -re "^ +\[0-9\]+ 001a\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001f\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0025\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0025 F016\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0027\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 002a\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 002e\[^\n\]*\n"    { set x [expr $x+1] }
@@ -481,52 +482,7 @@ proc do_movbu {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0005\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000f\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0012\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0016\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 001e\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0021\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0027\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0029\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 002c\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0030\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0036\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0039\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 003d\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0043\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0045\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0048\[^\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_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\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 F046\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0005\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
@@ -536,7 +492,7 @@ proc do_movbu {} {
            -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001e\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0021\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0027\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0027 F056\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0029\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 002c\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0030\[^\n\]*\n"    { set x [expr $x+1] }
@@ -571,7 +527,7 @@ proc do_movhu {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 F066\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0005\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
@@ -581,7 +537,7 @@ proc do_movhu {} {
            -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001e\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0021\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0027\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0027 F076\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0029\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 002c\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0030\[^\n\]*\n"    { set x [expr $x+1] }
@@ -645,10 +601,10 @@ proc do_muldiv {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0004\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 F246\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0002 F25B\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0004 F26F\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0006 F27E\[^\n\]*\n"       { set x [expr $x+1] }
            -re "\[^\n\]*\n"                            { }
            timeout                             { perror "timeout\n"; break }
            eof                                 { break }
@@ -674,25 +630,25 @@ proc do_other {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0001\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0003\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0004\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 08\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0001 44\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0002 49\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0003 53\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0004 F0F6\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 000e\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0013\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 001a\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 001a F0F2\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0020\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0026\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0029\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 002c\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 002e\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0030\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0032\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0033\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 002c F0FC\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 002e F0FD\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0030 F0FE\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0032 CB\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0033 F0FF\[^\n\]*\n"       { set x [expr $x+1] }
            -re "\[^\n\]*\n"                            { }
            timeout                             { perror "timeout\n"; break }
            eof                                 { break }
@@ -718,15 +674,15 @@ proc do_shift {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 F2B6\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0005\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0005 F2AB\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0007\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000a\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 000a F29E\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 000c\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 000f\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0010\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0012\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 000f 56\[^\n\]*\n" { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0010 F285\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0012 F282\[^\n\]*\n"       { set x [expr $x+1] }
            -re "\[^\n\]*\n"                            { }
            timeout                             { perror "timeout\n"; break }
            eof                                 { break }
@@ -752,13 +708,13 @@ proc do_sub {} {
     # of instructions (as these tests to).
     while 1 {
        expect {
-           -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0004\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0000 F106\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0002 F12B\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0004 F11F\[^\n\]*\n"       { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0006 F13E\[^\n\]*\n"       { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 0008\[^\n\]*\n"    { set x [expr $x+1] }
            -re "^ +\[0-9\]+ 000e\[^\n\]*\n"    { set x [expr $x+1] }
-           -re "^ +\[0-9\]+ 0014\[^\n\]*\n"    { set x [expr $x+1] }
+           -re "^ +\[0-9\]+ 0014 F186\[^\n\]*\n"       { set x [expr $x+1] }
            -re "\[^\n\]*\n"                            { }
            timeout                             { perror "timeout\n"; break }
            eof                                 { break }