gas/testsuite/gas/mn10300/basic.exp

   1 # Copyright (C) 1996 Free Software Foundation, Inc.
   2
   3 # This program is free software; you can redistribute it and/or modify
   4 # it under the terms of the GNU General Public License as published by
   5 # the Free Software Foundation; either version 2 of the License, or
   6 # (at your option) any later version.
   7 #
   8 # This program is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 # GNU General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU General Public License
  14 # along with this program; if not, write to the Free Software
  15 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  16
  17 # Please email any bugs, comments, and/or additions to this file to:
  18 # DejaGnu@cygnus.com
  19
  20 # Written by Cygnus Support.
  21
  22 proc do_add {} {
  23     set testname "add.s: Add operations"
  24     set x 0
  25
  26     gas_start "add.s" "-al"
  27
  28     # Instead of having a variable for each match string just increment the
  29     # total number of matches seen.  That's simpler when testing large numbers
  30     # of instructions (as these tests to).
  31     while 1 {
  32         expect {
  33             -re "^ +\[0-9\]+ 0000 E6\[^\n\]*\n" { set x [expr $x+1] }
  34             -re "^ +\[0-9\]+ 0001 F16B\[^\n\]*\n"       { set x [expr $x+1] }
  35             -re "^ +\[0-9\]+ 0003 F17E\[^\n\]*\n"       { set x [expr $x+1] }
  36             -re "^ +\[0-9\]+ 0005 F159\[^\n\]*\n"       { set x [expr $x+1] }
  37             -re "^ +\[0-9\]+ 0007 2910\[^\n\]*\n"       { set x [expr $x+1] }
  38             -re "^ +\[0-9\]+ 0009 FAC20100\[^\n\]*\n"   { set x [expr $x+1] }
  39             -re "^ +\[0-9\]+ 000d FCC30001\[^\n\]*\n"   { set x [expr $x+1] }
  40             -re "^ +8 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
  41             -re "^ +\[0-9\]+ 0013 2110\[^\n\]*\n"       { set x [expr $x+1] }
  42             -re "^ +\[0-9\]+ 0015 FAD20100\[^\n\]*\n"   { set x [expr $x+1] }
  43             -re "^ +\[0-9\]+ 0019 FCD30001\[^\n\]*\n"   { set x [expr $x+1] }
  44             -re "^ +11 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
  45             -re "^ +\[0-9\]+ 001f F8FE10\[^\n\]*\n"     { set x [expr $x+1] }
  46             -re "^ +\[0-9\]+ 0022 FAFE0100\[^\n\]*\n"   { set x [expr $x+1] }
  47             -re "^ +\[0-9\]+ 0026 FCFE0001\[^\n\]*\n"   { set x [expr $x+1] }
  48             -re "^ +14 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
  49             -re "^ +\[0-9\]+ 002c F146\[^\n\]*\n"       { set x [expr $x+1] }
  50             -re "\[^\n\]*\n"                            { }
  51             timeout                             { perror "timeout\n"; break }
  52             eof                                 { break }
  53         }
  54     }
  55
  56     # This was intended to do any cleanup necessary.  It kinda looks like it
  57     # isn't needed, but just in case, please keep it in for now.
  58     gas_finish
  59
  60     # Did we find what we were looking for?  If not, flunk it.
  61     if [expr $x==17] then { pass $testname } else { fail $testname }
  62 }
  63
  64 proc do_bcc {} {
  65     set testname "bcc.s: Bcc tests"
  66     set x 0
  67
  68     gas_start "bcc.s" "-al"
  69
  70     # Instead of having a variable for each match string just increment the
  71     # total number of matches seen.  That's simpler when testing large numbers
  72     # of instructions (as these tests to).
  73     while 1 {
  74         expect {
  75             -re "^ +\[0-9\]+ 0000 C800\[^\n\]*\n"       { set x [expr $x+1] }
  76             -re "^ +\[0-9\]+ 0002 C900\[^\n\]*\n"       { set x [expr $x+1] }
  77             -re "^ +\[0-9\]+ 0004 C100\[^\n\]*\n"       { set x [expr $x+1] }
  78             -re "^ +\[0-9\]+ 0006 C200\[^\n\]*\n"       { set x [expr $x+1] }
  79             -re "^ +\[0-9\]+ 0008 C300\[^\n\]*\n"       { set x [expr $x+1] }
  80             -re "^ +\[0-9\]+ 000a C000\[^\n\]*\n"       { set x [expr $x+1] }
  81             -re "^ +\[0-9\]+ 000c C500\[^\n\]*\n"       { set x [expr $x+1] }
  82             -re "^ +\[0-9\]+ 000e C600\[^\n\]*\n"       { set x [expr $x+1] }
  83             -re "^ +\[0-9\]+ 0010 C700\[^\n\]*\n"       { set x [expr $x+1] }
  84             -re "^ +\[0-9\]+ 0012 C400\[^\n\]*\n"       { set x [expr $x+1] }
  85             -re "^ +\[0-9\]+ 0014 F8E800\[^\n\]*\n"     { set x [expr $x+1] }
  86             -re "^ +\[0-9\]+ 0017 F8E900\[^\n\]*\n"     { set x [expr $x+1] }
  87             -re "^ +\[0-9\]+ 001a F8EA00\[^\n\]*\n"     { set x [expr $x+1] }
  88             -re "^ +\[0-9\]+ 001d F8EB00\[^\n\]*\n"     { set x [expr $x+1] }
  89             -re "^ +\[0-9\]+ 0020 CA00\[^\n\]*\n"       { set x [expr $x+1] }
  90             -re "\[^\n\]*\n"                            { }
  91             timeout                             { perror "timeout\n"; break }
  92             eof                                 { break }
  93         }
  94     }
  95
  96     # This was intended to do any cleanup necessary.  It kinda looks like it
  97     # isn't needed, but just in case, please keep it in for now.
  98     gas_finish
  99
 100     # Did we find what we were looking for?  If not, flunk it.
 101     if [expr $x==15] then { pass $testname } else { fail $testname }
 102 }
 103
 104 proc do_bit {} {
 105     set testname "bit.s: bit tests"
 106     set x 0
 107
 108     gas_start "bit.s" "-al"
 109
 110     # Instead of having a variable for each match string just increment the
 111     # total number of matches seen.  That's simpler when testing large numbers
 112     # of instructions (as these tests to).
 113     while 1 {
 114         expect {
 115             -re "^ +\[0-9\]+ 0000 F8ED40\[^\n\]*\n"     { set x [expr $x+1] }
 116             -re "^ +\[0-9\]+ 0003 FAEE2000\[^\n\]*\n"   { set x [expr $x+1] }
 117             -re "^ +\[0-9\]+ 0007 FCEF0001\[^\n\]*\n"   { set x [expr $x+1] }
 118             -re "^ +4 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 119             -re "^ +\[0-9\]+ 000d FAF90840\[^\n\]*\n"   { set x [expr $x+1] }
 120             -re "^ +\[0-9\]+ 0011 FE020001\[^\n\]*\n"   { set x [expr $x+1] }
 121             -re "^ +6 +FFFF40\[^\n\]*\n"                { set x [expr $x+1] }
 122             -re "^ +\[0-9\]+ 0018 F086\[^\n\]*\n"       { set x [expr $x+1] }
 123             -re "^ +\[0-9\]+ 001a FAF10840\[^\n\]*\n"   { set x [expr $x+1] }
 124             -re "^ +\[0-9\]+ 001e FE000001\[^\n\]*\n"   { set x [expr $x+1] }
 125             -re "^ +9 +FFFF40\[^\n\]*\n"                { set x [expr $x+1] }
 126             -re "^ +\[0-9\]+ 0025 F096\[^\n\]*\n"       { set x [expr $x+1] }
 127             -re "^ +\[0-9\]+ 0027 FAF50840\[^\n\]*\n"   { set x [expr $x+1] }
 128             -re "^ +\[0-9\]+ 002b FE010001\[^\n\]*\n"   { set x [expr $x+1] }
 129             -re "^ +12 +FFFF40\[^\n\]*\n"               { set x [expr $x+1] }
 130             -re "\[^\n\]*\n"                            { }
 131             timeout                             { perror "timeout\n"; break }
 132             eof                                 { break }
 133         }
 134     }
 135
 136     # This was intended to do any cleanup necessary.  It kinda looks like it
 137     # isn't needed, but just in case, please keep it in for now.
 138     gas_finish
 139
 140     # Did we find what we were looking for?  If not, flunk it.
 141     if [expr $x==15] then { pass $testname } else { fail $testname }
 142 }
 143
 144 proc do_cmp {} {
 145     set testname "cmp.s: cmp tests"
 146     set x 0
 147
 148     gas_start "cmp.s" "-al"
 149
 150     # Instead of having a variable for each match string just increment the
 151     # total number of matches seen.  That's simpler when testing large numbers
 152     # of instructions (as these tests to).
 153     while 1 {
 154         expect {
 155             -re "^ +\[0-9\]+ 0000 A6\[^\n\]*\n"         { set x [expr $x+1] }
 156             -re "^ +\[0-9\]+ 0001 F1AB\[^\n\]*\n"       { set x [expr $x+1] }
 157             -re "^ +\[0-9\]+ 0003 F19F\[^\n\]*\n"       { set x [expr $x+1] }
 158             -re "^ +\[0-9\]+ 0005 BE\[^\n\]*\n"         { set x [expr $x+1] }
 159             -re "^ +\[0-9\]+ 0006 AF10\[^\n\]*\n"       { set x [expr $x+1] }
 160             -re "^ +\[0-9\]+ 0008 FACA0100\[^\n\]*\n"   { set x [expr $x+1] }
 161             -re "^ +\[0-9\]+ 000c FCC90001\[^\n\]*\n"   { set x [expr $x+1] }
 162             -re "^ +8 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 163             -re "^ +\[0-9\]+ 0012 BF10\[^\n\]*\n"       { set x [expr $x+1] }
 164             -re "^ +\[0-9\]+ 0014 FADA0100\[^\n\]*\n"   { set x [expr $x+1] }
 165             -re "^ +\[0-9\]+ 0018 FCD90001\[^\n\]*\n"   { set x [expr $x+1] }
 166             -re "^ +11 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 167             -re "\[^\n\]*\n"                            { }
 168             timeout                             { perror "timeout\n"; break }
 169             eof                                 { break }
 170         }
 171     }
 172
 173     # This was intended to do any cleanup necessary.  It kinda looks like it
 174     # isn't needed, but just in case, please keep it in for now.
 175     gas_finish
 176
 177     # Did we find what we were looking for?  If not, flunk it.
 178     if [expr $x==12] then { pass $testname } else { fail $testname }
 179 }
 180
 181 proc do_ext {} {
 182     set testname "ext.s: ext tests"
 183     set x 0
 184
 185     gas_start "ext.s" "-al"
 186
 187     # Instead of having a variable for each match string just increment the
 188     # total number of matches seen.  That's simpler when testing large numbers
 189     # of instructions (as these tests to).
 190     while 1 {
 191         expect {
 192             -re "^ +\[0-9\]+ 0000 F2D1\[^\n\]*\n"       { set x [expr $x+1] }
 193             -re "^ +\[0-9\]+ 0002 12\[^\n\]*\n"         { set x [expr $x+1] }
 194             -re "^ +\[0-9\]+ 0003 17\[^\n\]*\n"         { set x [expr $x+1] }
 195             -re "^ +\[0-9\]+ 0004 1A\[^\n\]*\n"         { set x [expr $x+1] }
 196             -re "^ +\[0-9\]+ 0005 1D\[^\n\]*\n"         { set x [expr $x+1] }
 197             -re "\[^\n\]*\n"                            { }
 198             timeout                             { perror "timeout\n"; break }
 199             eof                                 { break }
 200         }
 201     }
 202
 203     # This was intended to do any cleanup necessary.  It kinda looks like it
 204     # isn't needed, but just in case, please keep it in for now.
 205     gas_finish
 206
 207     # Did we find what we were looking for?  If not, flunk it.
 208     if [expr $x==5] then { pass $testname } else { fail $testname }
 209 }
 210
 211 proc do_extend {} {
 212     set testname "extend.s: extended instruction tests"
 213     set x 0
 214
 215     gas_start "extend.s" "-al"
 216
 217     # Instead of having a variable for each match string just increment the
 218     # total number of matches seen.  That's simpler when testing large numbers
 219     # of instructions (as these tests to).
 220     while 1 {
 221         expect {
 222             -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
 223             -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
 224             -re "^ +\[0-9\]+ 0004\[^\n\]*\n"    { set x [expr $x+1] }
 225             -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
 226             -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
 227             -re "^ +\[0-9\]+ 000d\[^\n\]*\n"    { set x [expr $x+1] }
 228             -re "^ +\[0-9\]+ 0013\[^\n\]*\n"    { set x [expr $x+1] }
 229             -re "^ +\[0-9\]+ 0015\[^\n\]*\n"    { set x [expr $x+1] }
 230             -re "^ +\[0-9\]+ 0018\[^\n\]*\n"    { set x [expr $x+1] }
 231             -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
 232             -re "^ +\[0-9\]+ 0022\[^\n\]*\n"    { set x [expr $x+1] }
 233             -re "^ +\[0-9\]+ 0024\[^\n\]*\n"    { set x [expr $x+1] }
 234             -re "^ +\[0-9\]+ 0026\[^\n\]*\n"    { set x [expr $x+1] }
 235             -re "\[^\n\]*\n"                            { }
 236             timeout                             { perror "timeout\n"; break }
 237             eof                                 { break }
 238         }
 239     }
 240
 241     # This was intended to do any cleanup necessary.  It kinda looks like it
 242     # isn't needed, but just in case, please keep it in for now.
 243     gas_finish
 244
 245     # Did we find what we were looking for?  If not, flunk it.
 246     if [expr $x==13] then { pass $testname } else { fail $testname }
 247 }
 248
 249 proc do_logical {} {
 250     set testname "logical.s: logical tests"
 251     set x 0
 252
 253     gas_start "logical.s" "-al"
 254
 255     # Instead of having a variable for each match string just increment the
 256     # total number of matches seen.  That's simpler when testing large numbers
 257     # of instructions (as these tests to).
 258     while 1 {
 259         expect {
 260             -re "^ +\[0-9\]+ 0000 F206\[^\n\]*\n"       { set x [expr $x+1] }
 261             -re "^ +\[0-9\]+ 0002 F8E27F\[^\n\]*\n"     { set x [expr $x+1] }
 262             -re "^ +\[0-9\]+ 0005 FAE37FFF\[^\n\]*\n"   { set x [expr $x+1] }
 263             -re "^ +\[0-9\]+ 0009 FCE30001\[^\n\]*\n"   { set x [expr $x+1] }
 264             -re "^ +5 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 265             -re "^ +\[0-9\]+ 000f FAFC7FFF\[^\n\]*\n"   { set x [expr $x+1] }
 266             -re "^ +\[0-9\]+ 0013 F216\[^\n\]*\n"       { set x [expr $x+1] }
 267             -re "^ +\[0-9\]+ 0015 F8E67F\[^\n\]*\n"     { set x [expr $x+1] }
 268             -re "^ +\[0-9\]+ 0018 FAE77FFF\[^\n\]*\n"   { set x [expr $x+1] }
 269             -re "^ +\[0-9\]+ 001c FCE70001\[^\n\]*\n"   { set x [expr $x+1] }
 270             -re "^ +10 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 271             -re "^ +\[0-9\]+ 0022 FAFD7FFF\[^\n\]*\n"   { set x [expr $x+1] }
 272             -re "^ +\[0-9\]+ 0026 F226\[^\n\]*\n"       { set x [expr $x+1] }
 273             -re "^ +\[0-9\]+ 0028 FAEB7FFF\[^\n\]*\n"   { set x [expr $x+1] }
 274             -re "^ +\[0-9\]+ 002c FCEB0001\[^\n\]*\n"   { set x [expr $x+1] }
 275             -re "^ +14 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 276             -re "^ +\[0-9\]+ 0032 F233\[^\n\]*\n"       { set x [expr $x+1] }
 277             -re "^\[^\n\]*\n"                           { }
 278             timeout                             { perror "timeout\n"; break }
 279             eof                                 { break }
 280         }
 281     }
 282
 283     # This was intended to do any cleanup necessary.  It kinda looks like it
 284     # isn't needed, but just in case, please keep it in for now.
 285     gas_finish
 286
 287     # Did we find what we were looking for?  If not, flunk it.
 288     if [expr $x==17] then { pass $testname } else { fail $testname }
 289 }
 290
 291 proc do_loop {} {
 292     set testname "loop.s: loop tests"
 293     set x 0
 294
 295     gas_start "loop.s" "-al"
 296
 297     # Instead of having a variable for each match string just increment the
 298     # total number of matches seen.  That's simpler when testing large numbers
 299     # of instructions (as these tests to).
 300     while 1 {
 301         expect {
 302             -re "^ +\[0-9\]+ 0000 D8\[^\n\]*\n"         { set x [expr $x+1] }
 303             -re "^ +\[0-9\]+ 0001 D9\[^\n\]*\n"         { set x [expr $x+1] }
 304             -re "^ +\[0-9\]+ 0002 D1\[^\n\]*\n"         { set x [expr $x+1] }
 305             -re "^ +\[0-9\]+ 0003 D2\[^\n\]*\n"         { set x [expr $x+1] }
 306             -re "^ +\[0-9\]+ 0004 D3\[^\n\]*\n"         { set x [expr $x+1] }
 307             -re "^ +\[0-9\]+ 0005 D0\[^\n\]*\n"         { set x [expr $x+1] }
 308             -re "^ +\[0-9\]+ 0006 D5\[^\n\]*\n"         { set x [expr $x+1] }
 309             -re "^ +\[0-9\]+ 0007 D6\[^\n\]*\n"         { set x [expr $x+1] }
 310             -re "^ +\[0-9\]+ 0008 D7\[^\n\]*\n"         { set x [expr $x+1] }
 311             -re "^ +\[0-9\]+ 0009 D4\[^\n\]*\n"         { set x [expr $x+1] }
 312             -re "^ +\[0-9\]+ 000a DA\[^\n\]*\n"         { set x [expr $x+1] }
 313             -re "^ +\[0-9\]+ 000b DB\[^\n\]*\n"         { set x [expr $x+1] }
 314             -re "\[^\n\]*\n"                            { }
 315             timeout                             { perror "timeout\n"; break }
 316             eof                                 { break }
 317         }
 318     }
 319
 320     # This was intended to do any cleanup necessary.  It kinda looks like it
 321     # isn't needed, but just in case, please keep it in for now.
 322     gas_finish
 323
 324     # Did we find what we were looking for?  If not, flunk it.
 325     if [expr $x==12] then { pass $testname } else { fail $testname }
 326 }
 327
 328 proc do_mov1 {} {
 329     set testname "mov1.s: mov1 tests"
 330     set x 0
 331
 332     gas_start "mov1.s" "-al"
 333
 334     # Instead of having a variable for each match string just increment the
 335     # total number of matches seen.  That's simpler when testing large numbers
 336     # of instructions (as these tests to).
 337     while 1 {
 338         expect {
 339             -re "^ +\[0-9\]+ 0000 86\[^\n\]*\n"         { set x [expr $x+1] }
 340             -re "^ +\[0-9\]+ 0001 F1E6\[^\n\]*\n"       { set x [expr $x+1] }
 341             -re "^ +\[0-9\]+ 0003 F1D9\[^\n\]*\n"       { set x [expr $x+1] }
 342             -re "^ +\[0-9\]+ 0005 99\[^\n\]*\n"         { set x [expr $x+1] }
 343             -re "^ +\[0-9\]+ 0006 3E\[^\n\]*\n"         { set x [expr $x+1] }
 344             -re "^ +\[0-9\]+ 0007 F2F4\[^\n\]*\n"       { set x [expr $x+1] }
 345             -re "^ +\[0-9\]+ 0009 F2FB\[^\n\]*\n"       { set x [expr $x+1] }
 346             -re "^ +\[0-9\]+ 000b F2E1\[^\n\]*\n"       { set x [expr $x+1] }
 347             -re "^ +\[0-9\]+ 000d F2FA\[^\n\]*\n"       { set x [expr $x+1] }
 348             -re "^ +\[0-9\]+ 000f 76\[^\n\]*\n"         { set x [expr $x+1] }
 349             -re "^ +\[0-9\]+ 0010 F80608\[^\n\]*\n"     { set x [expr $x+1] }
 350             -re "^ +\[0-9\]+ 0013 FA060100\[^\n\]*\n"   { set x [expr $x+1] }
 351             -re "^ +\[0-9\]+ 0017 FC060001\[^\n\]*\n"   { set x [expr $x+1] }
 352             -re "^ +14 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 353             -re "^ +\[0-9\]+ 001d 5908\[^\n\]*\n"       { set x [expr $x+1] }
 354             -re "^ +\[0-9\]+ 001f FAB50100\[^\n\]*\n"   { set x [expr $x+1] }
 355             -re "^ +\[0-9\]+ 0023 F2E7\[^\n\]*\n"       { set x [expr $x+1] }
 356             -re "\[^\n\]*\n"                            { }
 357             timeout                             { perror "timeout\n"; break }
 358             eof                                 { break }
 359         }
 360     }
 361
 362     # This was intended to do any cleanup necessary.  It kinda looks like it
 363     # isn't needed, but just in case, please keep it in for now.
 364     gas_finish
 365
 366     # Did we find what we were looking for?  If not, flunk it.
 367     if [expr $x==17] then { pass $testname } else { fail $testname }
 368 }
 369
 370 proc do_mov2 {} {
 371     set testname "mov2.s: mov2 tests"
 372     set x 0
 373
 374     gas_start "mov2.s" "-al"
 375
 376     # Instead of having a variable for each match string just increment the
 377     # total number of matches seen.  That's simpler when testing large numbers
 378     # of instructions (as these tests to).
 379     while 1 {
 380         expect {
 381             -re "^ +\[0-9\]+ 0000 FCB50001\[^\n\]*\n"   { set x [expr $x+1] }
 382             -re "^ +2 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 383             -re "^ +\[0-9\]+ 0006 F325\[^\n\]*\n"       { set x [expr $x+1] }
 384             -re "^ +\[0-9\]+ 0008 318000\[^\n\]*\n"     { set x [expr $x+1] }
 385             -re "^ +\[0-9\]+ 000b FCA50001\[^\n\]*\n"   { set x [expr $x+1] }
 386             -re "^ +5 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 387             -re "^ +\[0-9\]+ 0011 F006\[^\n\]*\n"       { set x [expr $x+1] }
 388             -re "^ +\[0-9\]+ 0013 F82608\[^\n\]*\n"     { set x [expr $x+1] }
 389             -re "^ +\[0-9\]+ 0016 FA260100 \[^\n\]*\n"  { set x [expr $x+1] }
 390             -re "^ +\[0-9\]+ 001a FC260001\[^\n\]*\n"   { set x [expr $x+1] }
 391             -re "^ +9 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 392             -re "^ +\[0-9\]+ 0020 5D08\[^\n\]*\n"       { set x [expr $x+1] }
 393             -re "^ +\[0-9\]+ 0022 FAB10100\[^\n\]*\n"   { set x [expr $x+1] }
 394             -re "^ +\[0-9\]+ 0026 FCB10001\[^\n\]*\n"   { set x [expr $x+1] }
 395             -re "^ +12 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 396             -re "^ +\[0-9\]+ 002c F3A5\[^\n\]*\n"       { set x [expr $x+1] }
 397             -re "^ +\[0-9\]+ 002e FAA18000\[^\n\]*\n"   { set x [expr $x+1] }
 398             -re "^ +\[0-9\]+ 0032 FCA10001\[^\n\]*\n"   { set x [expr $x+1] }
 399             -re "^ +15 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 400             -re "^ +\[0-9\]+ 0038 F8F120\[^\n\]*\n"     { set x [expr $x+1] }
 401             -re "\[^\n\]*\n"                            { }
 402             timeout                             { perror "timeout\n"; break }
 403             eof                                 { break }
 404         }
 405     }
 406
 407     # This was intended to do any cleanup necessary.  It kinda looks like it
 408     # isn't needed, but just in case, please keep it in for now.
 409     gas_finish
 410
 411     # Did we find what we were looking for?  If not, flunk it.
 412     if [expr $x==20] then { pass $testname } else { fail $testname }
 413 }
 414
 415 proc do_mov3 {} {
 416     set testname "mov3.s: mov3 tests"
 417     set x 0
 418
 419     gas_start "mov3.s" "-al"
 420
 421     # Instead of having a variable for each match string just increment the
 422     # total number of matches seen.  That's simpler when testing large numbers
 423     # of instructions (as these tests to).
 424     while 1 {
 425         expect {
 426             -re "^ +\[0-9\]+ 0000 66\[^\n\]*\n" { set x [expr $x+1] }
 427             -re "^ +\[0-9\]+ 0001 F81620\[^\n\]*\n"     { set x [expr $x+1] }
 428             -re "^ +\[0-9\]+ 0004 FA160100\[^\n\]*\n"   { set x [expr $x+1] }
 429             -re "^ +\[0-9\]+ 0008 FC160001\[^\n\]*\n"   { set x [expr $x+1] }
 430             -re "^ +5 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 431             -re "^ +\[0-9\]+ 000e 4620\[^\n\]*\n"       { set x [expr $x+1] }
 432             -re "^ +\[0-9\]+ 0010 FA958000\[^\n\]*\n"   { set x [expr $x+1] }
 433             -re "^ +\[0-9\]+ 0014 FC950001\[^\n\]*\n"   { set x [expr $x+1] }
 434             -re "^ +8 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 435             -re "^ +\[0-9\]+ 001a F35A\[^\n\]*\n"       { set x [expr $x+1] }
 436             -re "^ +\[0-9\]+ 001c 050080\[^\n\]*\n"     { set x [expr $x+1] }
 437             -re "^ +\[0-9\]+ 001f FC850001\[^\n\]*\n"   { set x [expr $x+1] }
 438             -re "^ +11 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 439             -re "^ +\[0-9\]+ 0025 F016\[^\n\]*\n"       { set x [expr $x+1] }
 440             -re "^ +\[0-9\]+ 0027 F83620\[^\n\]*\n"     { set x [expr $x+1] }
 441             -re "^ +\[0-9\]+ 002a FA360100\[^\n\]*\n"   { set x [expr $x+1] }
 442             -re "^ +\[0-9\]+ 002e FC360001\[^\n\]*\n"   { set x [expr $x+1] }
 443             -re "^ +15 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 444             -re "^ +\[0-9\]+ 0034 4720\[^\n\]*\n"       { set x [expr $x+1] }
 445             -re "\[^\n\]*\n"                            { }
 446             timeout                             { perror "timeout\n"; break }
 447             eof                                 { break }
 448         }
 449     }
 450
 451     # This was intended to do any cleanup necessary.  It kinda looks like it
 452     # isn't needed, but just in case, please keep it in for now.
 453     gas_finish
 454
 455     # Did we find what we were looking for?  If not, flunk it.
 456     if [expr $x==19] then { pass $testname } else { fail $testname }
 457 }
 458
 459 proc do_mov4 {} {
 460     set testname "mov4.s: mov4 tests"
 461     set x 0
 462
 463     gas_start "mov4.s" "-al"
 464
 465     # Instead of having a variable for each match string just increment the
 466     # total number of matches seen.  That's simpler when testing large numbers
 467     # of instructions (as these tests to).
 468     while 1 {
 469         expect {
 470             -re "^ +\[0-9\]+ 0000 FA948000\[^\n\]*\n"   { set x [expr $x+1] }
 471             -re "^ +\[0-9\]+ 0004 FC940001\[^\n\]*\n"   { set x [expr $x+1] }
 472             -re "^ +3 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 473             -re "^ +\[0-9\]+ 000a F3DA\[^\n\]*\n"       { set x [expr $x+1] }
 474             -re "^ +\[0-9\]+ 000c FA840080\[^\n\]*\n"   { set x [expr $x+1] }
 475             -re "^ +\[0-9\]+ 0010 FC840001\[^\n\]*\n"   { set x [expr $x+1] }
 476             -re "^ +6 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 477             -re "^ +\[0-9\]+ 0016 F8F520\[^\n\]*\n"     { set x [expr $x+1] }
 478             -re "^ +\[0-9\]+ 0019 8508\[^\n\]*\n"       { set x [expr $x+1] }
 479             -re "^ +\[0-9\]+ 001b 2D0100\[^\n\]*\n"     { set x [expr $x+1] }
 480             -re "^ +\[0-9\]+ 001e FCCD0001\[^\n\]*\n"   { set x [expr $x+1] }
 481             -re "^ +10 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 482             -re "^ +\[0-9\]+ 0024 9508\[^\n\]*\n"       { set x [expr $x+1] }
 483             -re "^ +\[0-9\]+ 0026 250100\[^\n\]*\n"     { set x [expr $x+1] }
 484             -re "^ +\[0-9\]+ 0029 FCDD0001\[^\n\]*\n"   { set x [expr $x+1] }
 485             -re "^ +13 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 486             -re "\[^\n\]*\n"                            { }
 487             timeout                             { perror "timeout\n"; break }
 488             eof                                 { break }
 489         }
 490     }
 491
 492     # This was intended to do any cleanup necessary.  It kinda looks like it
 493     # isn't needed, but just in case, please keep it in for now.
 494     gas_finish
 495
 496     # Did we find what we were looking for?  If not, flunk it.
 497     if [expr $x==16] then { pass $testname } else { fail $testname }
 498 }
 499
 500 proc do_movbu {} {
 501     set testname "movbu.s: movbu tests"
 502     set x 0
 503
 504     gas_start "movbu.s" "-al"
 505
 506     # Instead of having a variable for each match string just increment the
 507     # total number of matches seen.  That's simpler when testing large numbers
 508     # of instructions (as these tests to).
 509     while 1 {
 510         expect {
 511             -re "^ +\[0-9\]+ 0000 F046\[^\n\]*\n"       { set x [expr $x+1] }
 512             -re "^ +\[0-9\]+ 0002 F84608\[^\n\]*\n"     { set x [expr $x+1] }
 513             -re "^ +\[0-9\]+ 0005 FA460100\[^\n\]*\n"   { set x [expr $x+1] }
 514             -re "^ +\[0-9\]+ 0009 FC460001\[^\n\]*\n"   { set x [expr $x+1] }
 515             -re "^ +5 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 516             -re "^ +\[0-9\]+ 000f F8B908\[^\n\]*\n"     { set x [expr $x+1] }
 517             -re "^ +\[0-9\]+ 0012 FAB90100\[^\n\]*\n"   { set x [expr $x+1] }
 518             -re "^ +\[0-9\]+ 0016 FCB90001\[^\n\]*\n"   { set x [expr $x+1] }
 519             -re "^ +8 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 520             -re "^ +\[0-9\]+ 001c F425\[^\n\]*\n"       { set x [expr $x+1] }
 521             -re "^ +\[0-9\]+ 001e 358000\[^\n\]*\n"     { set x [expr $x+1] }
 522             -re "^ +\[0-9\]+ 0021 FCA90001\[^\n\]*\n"   { set x [expr $x+1] }
 523             -re "^ +11 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 524             -re "^ +\[0-9\]+ 0027 F056\[^\n\]*\n"       { set x [expr $x+1] }
 525             -re "^ +\[0-9\]+ 0029 F85620\[^\n\]*\n"     { set x [expr $x+1] }
 526             -re "^ +\[0-9\]+ 002c FA560100\[^\n\]*\n"   { set x [expr $x+1] }
 527             -re "^ +\[0-9\]+ 0030 FC560001\[^\n\]*\n"   { set x [expr $x+1] }
 528             -re "^ +15 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 529             -re "^ +\[0-9\]+ 0036 F89620\[^\n\]*\n"     { set x [expr $x+1] }
 530             -re "^ +\[0-9\]+ 0039 FA968000\[^\n\]*\n"   { set x [expr $x+1] }
 531             -re "^ +\[0-9\]+ 003d FC960001\[^\n\]*\n"   { set x [expr $x+1] }
 532             -re "^ +18 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 533             -re "^ +\[0-9\]+ 0043 F45A\[^\n\]*\n"       { set x [expr $x+1] }
 534             -re "^ +\[0-9\]+ 0045 060080\[^\n\]*\n"     { set x [expr $x+1] }
 535             -re "^ +\[0-9\]+ 0048 FC860001\[^\n\]*\n"   { set x [expr $x+1] }
 536             -re "^ +21 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 537             -re "\[^\n\]*\n"                            { }
 538             timeout                             { perror "timeout\n"; break }
 539             eof                                 { break }
 540         }
 541     }
 542
 543     # This was intended to do any cleanup necessary.  It kinda looks like it
 544     # isn't needed, but just in case, please keep it in for now.
 545     gas_finish
 546
 547     # Did we find what we were looking for?  If not, flunk it.
 548     if [expr $x==26] then { pass $testname } else { fail $testname }
 549 }
 550
 551 proc do_movhu {} {
 552     set testname "movhu.s: movhu tests"
 553     set x 0
 554
 555     gas_start "movhu.s" "-al"
 556
 557     # Instead of having a variable for each match string just increment the
 558     # total number of matches seen.  That's simpler when testing large numbers
 559     # of instructions (as these tests to).
 560     while 1 {
 561         expect {
 562             -re "^ +\[0-9\]+ 0000 F066\[^\n\]*\n"       { set x [expr $x+1] }
 563             -re "^ +\[0-9\]+ 0002 F86608\[^\n\]*\n"     { set x [expr $x+1] }
 564             -re "^ +\[0-9\]+ 0005 FA660100\[^\n\]*\n"   { set x [expr $x+1] }
 565             -re "^ +\[0-9\]+ 0009 FC660001\[^\n\]*\n"   { set x [expr $x+1] }
 566             -re "^ +5 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 567             -re "^ +\[0-9\]+ 000f F8BD08\[^\n\]*\n"     { set x [expr $x+1] }
 568             -re "^ +\[0-9\]+ 0012 FABD0100\[^\n\]*\n"   { set x [expr $x+1] }
 569             -re "^ +\[0-9\]+ 0016 FCBD0001\[^\n\]*\n"   { set x [expr $x+1] }
 570             -re "^ +8 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 571             -re "^ +\[0-9\]+ 001c F4A5\[^\n\]*\n"       { set x [expr $x+1] }
 572             -re "^ +\[0-9\]+ 001e 398000\[^\n\]*\n"     { set x [expr $x+1] }
 573             -re "^ +\[0-9\]+ 0021 FCAD0001\[^\n\]*\n"   { set x [expr $x+1] }
 574             -re "^ +11 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 575             -re "^ +\[0-9\]+ 0027 F076\[^\n\]*\n"       { set x [expr $x+1] }
 576             -re "^ +\[0-9\]+ 0029 F87620\[^\n\]*\n"     { set x [expr $x+1] }
 577             -re "^ +\[0-9\]+ 002c FA760100\[^\n\]*\n"   { set x [expr $x+1] }
 578             -re "^ +\[0-9\]+ 0030 FC760001\[^\n\]*\n"   { set x [expr $x+1] }
 579             -re "^ +15 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 580             -re "^ +\[0-9\]+ 0036 F89720\[^\n\]*\n"     { set x [expr $x+1] }
 581             -re "^ +\[0-9\]+ 0039 FA978000\[^\n\]*\n"   { set x [expr $x+1] }
 582             -re "^ +\[0-9\]+ 003d FC970001\[^\n\]*\n"   { set x [expr $x+1] }
 583             -re "^ +18 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 584             -re "^ +\[0-9\]+ 0043 F4DA\[^\n\]*\n"       { set x [expr $x+1] }
 585             -re "^ +\[0-9\]+ 0045 070080\[^\n\]*\n"     { set x [expr $x+1] }
 586             -re "^ +\[0-9\]+ 0048 FC870001\[^\n\]*\n"   { set x [expr $x+1] }
 587             -re "^ +21 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 588             -re "\[^\n\]*\n"                            { }
 589             timeout                             { perror "timeout\n"; break }
 590             eof                                 { break }
 591         }
 592     }
 593
 594     # This was intended to do any cleanup necessary.  It kinda looks like it
 595     # isn't needed, but just in case, please keep it in for now.
 596     gas_finish
 597
 598     # Did we find what we were looking for?  If not, flunk it.
 599     if [expr $x==26] then { pass $testname } else { fail $testname }
 600 }
 601
 602 proc do_movm {} {
 603     set testname "movm.s: movm tests"
 604     set x 0
 605
 606     gas_start "movm.s" "-al"
 607
 608     # Instead of having a variable for each match string just increment the
 609     # total number of matches seen.  That's simpler when testing large numbers
 610     # of instructions (as these tests to).
 611     while 1 {
 612         expect {
 613             -re "^ +\[0-9\]+ 0000 CE00\[^\n\]*\n"       { set x [expr $x+1] }
 614             -re "^ +\[0-9\]+ 0002 CE0B\[^\n\]*\n"       { set x [expr $x+1] }
 615             -re "^ +\[0-9\]+ 0004 CF00\[^\n\]*\n"       { set x [expr $x+1] }
 616             -re "^ +\[0-9\]+ 0006 CF0B\[^\n\]*\n"       { set x [expr $x+1] }
 617             -re "\[^\n\]*\n"                            { }
 618             timeout                             { perror "timeout\n"; break }
 619             eof                                 { break }
 620         }
 621     }
 622
 623     # This was intended to do any cleanup necessary.  It kinda looks like it
 624     # isn't needed, but just in case, please keep it in for now.
 625     gas_finish
 626
 627     # Did we find what we were looking for?  If not, flunk it.
 628     if [expr $x==4] then { pass $testname } else { fail $testname }
 629 }
 630
 631 proc do_muldiv {} {
 632     set testname "muldiv.s: muldiv tests"
 633     set x 0
 634
 635     gas_start "muldiv.s" "-al"
 636
 637     # Instead of having a variable for each match string just increment the
 638     # total number of matches seen.  That's simpler when testing large numbers
 639     # of instructions (as these tests to).
 640     while 1 {
 641         expect {
 642             -re "^ +\[0-9\]+ 0000 F246\[^\n\]*\n"       { set x [expr $x+1] }
 643             -re "^ +\[0-9\]+ 0002 F25B\[^\n\]*\n"       { set x [expr $x+1] }
 644             -re "^ +\[0-9\]+ 0004 F26F\[^\n\]*\n"       { set x [expr $x+1] }
 645             -re "^ +\[0-9\]+ 0006 F27E\[^\n\]*\n"       { set x [expr $x+1] }
 646             -re "\[^\n\]*\n"                            { }
 647             timeout                             { perror "timeout\n"; break }
 648             eof                                 { break }
 649         }
 650     }
 651
 652     # This was intended to do any cleanup necessary.  It kinda looks like it
 653     # isn't needed, but just in case, please keep it in for now.
 654     gas_finish
 655
 656     # Did we find what we were looking for?  If not, flunk it.
 657     if [expr $x==4] then { pass $testname } else { fail $testname }
 658 }
 659
 660 proc do_other {} {
 661     set testname "other.s: other tests"
 662     set x 0
 663
 664     gas_start "other.s" "-al"
 665
 666     # Instead of having a variable for each match string just increment the
 667     # total number of matches seen.  That's simpler when testing large numbers
 668     # of instructions (as these tests to).
 669     while 1 {
 670         expect {
 671             -re "^ +\[0-9\]+ 0000 08\[^\n\]*\n"         { set x [expr $x+1] }
 672             -re "^ +\[0-9\]+ 0001 44\[^\n\]*\n"         { set x [expr $x+1] }
 673             -re "^ +\[0-9\]+ 0002 49\[^\n\]*\n"         { set x [expr $x+1] }
 674             -re "^ +\[0-9\]+ 0003 53\[^\n\]*\n"         { set x [expr $x+1] }
 675             -re "^ +\[0-9\]+ 0004 F0F6\[^\n\]*\n"       { set x [expr $x+1] }
 676             -re "^ +\[0-9\]+ 0006 CC0100\[^\n\]*\n"     { set x [expr $x+1] }
 677             -re "^ +\[0-9\]+ 0009 DC0001FF\[^\n\]*\n"   { set x [expr $x+1] }
 678             -re "^ +8 +FF\[^\n\]*\n"                    { set x [expr $x+1] }
 679             -re "^ +\[0-9\]+ 000e CD010005\[^\n\]*\n"   { set x [expr $x+1] }
 680             -re "^ +9 +09\[^\n\]*\n"                    { set x [expr $x+1] }
 681             -re "^ +\[0-9\]+ 0013 DD0001FF\[^\n\]*\n"   { set x [expr $x+1] }
 682             -re "^ +10 +FF0920\[^\n\]*\n"               { set x [expr $x+1] }
 683             -re "^ +\[0-9\]+ 001a F0F2\[^\n\]*\n"       { set x [expr $x+1] }
 684             -re "^ +\[0-9\]+ 001c FAFF0100\[^\n\]*\n"   { set x [expr $x+1] }
 685             -re "^ +\[0-9\]+ 0020 FCFF0001\[^\n\]*\n"   { set x [expr $x+1] }
 686             -re "^ +13 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 687             -re "^ +\[0-9\]+ 0026 DF0F07\[^\n\]*\n"     { set x [expr $x+1] }
 688             -re "^ +\[0-9\]+ 0029 DE0905\[^\n\]*\n"     { set x [expr $x+1] }
 689             -re "^ +\[0-9\]+ 002c F0FC\[^\n\]*\n"       { set x [expr $x+1] }
 690             -re "^ +\[0-9\]+ 002e F0FD\[^\n\]*\n"       { set x [expr $x+1] }
 691             -re "^ +\[0-9\]+ 0030 F0FE\[^\n\]*\n"       { set x [expr $x+1] }
 692             -re "^ +\[0-9\]+ 0032 CB\[^\n\]*\n"         { set x [expr $x+1] }
 693             -re "^ +\[0-9\]+ 0033 F0FF\[^\n\]*\n"       { set x [expr $x+1] }
 694             -re "\[^\n\]*\n"                            { }
 695             timeout                             { perror "timeout\n"; break }
 696             eof                                 { break }
 697         }
 698     }
 699
 700     # This was intended to do any cleanup necessary.  It kinda looks like it
 701     # isn't needed, but just in case, please keep it in for now.
 702     gas_finish
 703
 704     # Did we find what we were looking for?  If not, flunk it.
 705     if [expr $x==23] then { pass $testname } else { fail $testname }
 706 }
 707
 708 proc do_shift {} {
 709     set testname "shift.s: shift tests"
 710     set x 0
 711
 712     gas_start "shift.s" "-al"
 713
 714     # Instead of having a variable for each match string just increment the
 715     # total number of matches seen.  That's simpler when testing large numbers
 716     # of instructions (as these tests to).
 717     while 1 {
 718         expect {
 719             -re "^ +\[0-9\]+ 0000 F2B6\[^\n\]*\n"       { set x [expr $x+1] }
 720             -re "^ +\[0-9\]+ 0002 F8CA04\[^\n\]*\n"     { set x [expr $x+1] }
 721             -re "^ +\[0-9\]+ 0005 F2AB\[^\n\]*\n"       { set x [expr $x+1] }
 722             -re "^ +\[0-9\]+ 0007 F8C704\[^\n\]*\n"     { set x [expr $x+1] }
 723             -re "^ +\[0-9\]+ 000a F29E\[^\n\]*\n"       { set x [expr $x+1] }
 724             -re "^ +\[0-9\]+ 000c F8C204\[^\n\]*\n"     { set x [expr $x+1] }
 725             -re "^ +\[0-9\]+ 000f 56\[^\n\]*\n"         { set x [expr $x+1] }
 726             -re "^ +\[0-9\]+ 0010 F285\[^\n\]*\n"       { set x [expr $x+1] }
 727             -re "^ +\[0-9\]+ 0012 F282\[^\n\]*\n"       { set x [expr $x+1] }
 728             -re "\[^\n\]*\n"                            { }
 729             timeout                             { perror "timeout\n"; break }
 730             eof                                 { break }
 731         }
 732     }
 733
 734     # This was intended to do any cleanup necessary.  It kinda looks like it
 735     # isn't needed, but just in case, please keep it in for now.
 736     gas_finish
 737
 738     # Did we find what we were looking for?  If not, flunk it.
 739     if [expr $x==9] then { pass $testname } else { fail $testname }
 740 }
 741
 742 proc do_sub {} {
 743     set testname "sub.s: sub tests"
 744     set x 0
 745
 746     gas_start "sub.s" "-al"
 747
 748     # Instead of having a variable for each match string just increment the
 749     # total number of matches seen.  That's simpler when testing large numbers
 750     # of instructions (as these tests to).
 751     while 1 {
 752         expect {
 753             -re "^ +\[0-9\]+ 0000 F106\[^\n\]*\n"       { set x [expr $x+1] }
 754             -re "^ +\[0-9\]+ 0002 F12B\[^\n\]*\n"       { set x [expr $x+1] }
 755             -re "^ +\[0-9\]+ 0004 F11F\[^\n\]*\n"       { set x [expr $x+1] }
 756             -re "^ +\[0-9\]+ 0006 F13E\[^\n\]*\n"       { set x [expr $x+1] }
 757             -re "^ +\[0-9\]+ 0008 FCC60001 \[^\n\]*\n"  { set x [expr $x+1] }
 758             -re "^ +6 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 759             -re "^ +\[0-9\]+ 000e FCD50001\[^\n\]*\n"   { set x [expr $x+1] }
 760             -re "^ +7 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 761             -re "^ +\[0-9\]+ 0014 F186\[^\n\]*\n"       { set x [expr $x+1] }
 762             -re "\[^\n\]*\n"                            { }
 763             timeout                             { perror "timeout\n"; break }
 764             eof                                 { break }
 765         }
 766     }
 767
 768     # This was intended to do any cleanup necessary.  It kinda looks like it
 769     # isn't needed, but just in case, please keep it in for now.
 770     gas_finish
 771
 772     # Did we find what we were looking for?  If not, flunk it.
 773     if [expr $x==9] then { pass $testname } else { fail $testname }
 774 }
 775
 776 if [istarget mn10300*-*-*] then {
 777     # Test the basic instruction parser.
 778     do_add
 779     do_bcc
 780     do_bit
 781     do_cmp
 782     do_ext
 783     do_extend
 784     do_logical
 785     do_loop
 786     do_mov1
 787     do_mov2
 788     do_mov3
 789     do_mov4
 790     do_movbu
 791     do_movhu
 792     do_movm
 793     do_muldiv
 794     do_other
 795     do_shift
 796     do_sub
 797 }