gas/testsuite/gas/mn10200/basic.exp

   1 # Copyright (C) 1996, 2002, 2005, 2007 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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  16
  17 # Please email any bugs, comments, and/or additions to this file to:
  18 # dejagnu@gnu.org
  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 96\[^\n\]*\n" { set x [expr $x+1] }
  34             -re "^ +\[0-9\]+ 0001 F20B\[^\n\]*\n"       { set x [expr $x+1] }
  35             -re "^ +\[0-9\]+ 0003 F2C9\[^\n\]*\n"       { set x [expr $x+1] }
  36             -re "^ +\[0-9\]+ 0005 F24E\[^\n\]*\n"       { set x [expr $x+1] }
  37             -re "^ +\[0-9\]+ 0007 D510\[^\n\]*\n"       { set x [expr $x+1] }
  38             -re "^ +\[0-9\]+ 0009 F71A0001\[^\n\]*\n"   { set x [expr $x+1] }
  39             -re "^ +\[0-9\]+ 000d F463FFFF\[^\n\]*\n"   { set x [expr $x+1] }
  40             -re "^ +8 +01\[^\n\]*\n"                    { set x [expr $x+1] }
  41             -re "^ +\[0-9\]+ 0012 D110\[^\n\]*\n"       { set x [expr $x+1] }
  42             -re "^ +\[0-9\]+ 0014 F70A0001\[^\n\]*\n"   { set x [expr $x+1] }
  43             -re "^ +\[0-9\]+ 0018 F467FFFF\[^\n\]*\n"   { set x [expr $x+1] }
  44             -re "^ +11 +01\[^\n\]*\n"                   { set x [expr $x+1] }
  45             -re "^ +\[0-9\]+ 001d F286\[^\n\]*\n"       { set x [expr $x+1] }
  46             -re "^ +\[0-9\]+ 001f F50E10\[^\n\]*\n"     { set x [expr $x+1] }
  47             -re "\[^\n\]*\n"                            { }
  48             timeout                             { perror "timeout\n"; break }
  49             eof                                 { break }
  50         }
  51     }
  52
  53     # This was intended to do any cleanup necessary.  It kinda looks like it
  54     # isn't needed, but just in case, please keep it in for now.
  55     gas_finish
  56
  57     # Did we find what we were looking for?  If not, flunk it.
  58     if [expr $x==14] then { pass $testname } else { fail $testname }
  59 }
  60
  61 proc do_bcc {} {
  62     set testname "bcc.s: Bcc tests"
  63     set x 0
  64
  65     gas_start "bcc.s" "-al"
  66
  67     # Instead of having a variable for each match string just increment the
  68     # total number of matches seen.  That's simpler when testing large numbers
  69     # of instructions (as these tests to).
  70     while 1 {
  71         expect {
  72             -re "^ +\[0-9\]+ 0000 E800\[^\n\]*\n"       { set x [expr $x+1] }
  73             -re "^ +\[0-9\]+ 0002 E900\[^\n\]*\n"       { set x [expr $x+1] }
  74             -re "^ +\[0-9\]+ 0004 E100\[^\n\]*\n"       { set x [expr $x+1] }
  75             -re "^ +\[0-9\]+ 0006 E200\[^\n\]*\n"       { set x [expr $x+1] }
  76             -re "^ +\[0-9\]+ 0008 E300\[^\n\]*\n"       { set x [expr $x+1] }
  77             -re "^ +\[0-9\]+ 000a E000\[^\n\]*\n"       { set x [expr $x+1] }
  78             -re "^ +\[0-9\]+ 000c E500\[^\n\]*\n"       { set x [expr $x+1] }
  79             -re "^ +\[0-9\]+ 000e E600\[^\n\]*\n"       { set x [expr $x+1] }
  80             -re "^ +\[0-9\]+ 0010 E700\[^\n\]*\n"       { set x [expr $x+1] }
  81             -re "^ +\[0-9\]+ 0012 E400\[^\n\]*\n"       { set x [expr $x+1] }
  82             -re "^ +\[0-9\]+ 0014 F5FC00\[^\n\]*\n"     { set x [expr $x+1] }
  83             -re "^ +\[0-9\]+ 0017 F5FD00\[^\n\]*\n"     { set x [expr $x+1] }
  84             -re "^ +\[0-9\]+ 001a F5FE00\[^\n\]*\n"     { set x [expr $x+1] }
  85             -re "^ +\[0-9\]+ 001d F5FF00\[^\n\]*\n"     { set x [expr $x+1] }
  86             -re "^ +\[0-9\]+ 0020 EA00\[^\n\]*\n"       { set x [expr $x+1] }
  87             -re "\[^\n\]*\n"                            { }
  88             timeout                             { perror "timeout\n"; break }
  89             eof                                 { break }
  90         }
  91     }
  92
  93     # This was intended to do any cleanup necessary.  It kinda looks like it
  94     # isn't needed, but just in case, please keep it in for now.
  95     gas_finish
  96
  97     # Did we find what we were looking for?  If not, flunk it.
  98     if [expr $x==15] then { pass $testname } else { fail $testname }
  99 }
 100
 101 proc do_bccx {} {
 102     set testname "bccx.s: Bccx tests"
 103     set x 0
 104
 105     gas_start "bccx.s" "-al"
 106
 107     # Instead of having a variable for each match string just increment the
 108     # total number of matches seen.  That's simpler when testing large numbers
 109     # of instructions (as these tests to).
 110     while 1 {
 111         expect {
 112             -re "^ +\[0-9\]+ 0000 F5E800\[^\n\]*\n"     { set x [expr $x+1] }
 113             -re "^ +\[0-9\]+ 0003 F5E900\[^\n\]*\n"     { set x [expr $x+1] }
 114             -re "^ +\[0-9\]+ 0006 F5E100\[^\n\]*\n"     { set x [expr $x+1] }
 115             -re "^ +\[0-9\]+ 0009 F5E200\[^\n\]*\n"     { set x [expr $x+1] }
 116             -re "^ +\[0-9\]+ 000c F5E300\[^\n\]*\n"     { set x [expr $x+1] }
 117             -re "^ +\[0-9\]+ 000f F5E000\[^\n\]*\n"     { set x [expr $x+1] }
 118             -re "^ +\[0-9\]+ 0012 F5E500\[^\n\]*\n"     { set x [expr $x+1] }
 119             -re "^ +\[0-9\]+ 0015 F5E600\[^\n\]*\n"     { set x [expr $x+1] }
 120             -re "^ +\[0-9\]+ 0018 F5E700\[^\n\]*\n"     { set x [expr $x+1] }
 121             -re "^ +\[0-9\]+ 001b F5E400\[^\n\]*\n"     { set x [expr $x+1] }
 122             -re "^ +\[0-9\]+ 001e F5EC00\[^\n\]*\n"     { set x [expr $x+1] }
 123             -re "^ +\[0-9\]+ 0021 F5ED00\[^\n\]*\n"     { set x [expr $x+1] }
 124             -re "^ +\[0-9\]+ 0024 F5EE00\[^\n\]*\n"     { set x [expr $x+1] }
 125             -re "^ +\[0-9\]+ 0027 F5EF00\[^\n\]*\n"     { set x [expr $x+1] }
 126             -re "\[^\n\]*\n"                            { }
 127             timeout                             { perror "timeout\n"; break }
 128             eof                                 { break }
 129         }
 130     }
 131
 132     # This was intended to do any cleanup necessary.  It kinda looks like it
 133     # isn't needed, but just in case, please keep it in for now.
 134     gas_finish
 135
 136     # Did we find what we were looking for?  If not, flunk it.
 137     if [expr $x==14] then { pass $testname } else { fail $testname }
 138 }
 139
 140 proc do_bit {} {
 141     set testname "bit.s: bit tests"
 142     set x 0
 143
 144     gas_start "bit.s" "-al"
 145
 146     # Instead of having a variable for each match string just increment the
 147     # total number of matches seen.  That's simpler when testing large numbers
 148     # of instructions (as these tests to).
 149     while 1 {
 150         expect {
 151             -re "^ +\[0-9\]+ 0000 F50540\[^\n\]*\n"     { set x [expr $x+1] }
 152             -re "^ +\[0-9\]+ 0003 F7060020\[^\n\]*\n"   { set x [expr $x+1] }
 153             -re "^ +\[0-9\]+ 0007 F029\[^\n\]*\n"       { set x [expr $x+1] }
 154             -re "^ +\[0-9\]+ 0009 F039\[^\n\]*\n"       { set x [expr $x+1] }
 155             -re "^ +12 +FFFF40\[^\n\]*\n"               { set x [expr $x+1] }
 156             -re "\[^\n\]*\n"                            { }
 157             timeout                             { perror "timeout\n"; break }
 158             eof                                 { break }
 159         }
 160     }
 161
 162     # This was intended to do any cleanup necessary.  It kinda looks like it
 163     # isn't needed, but just in case, please keep it in for now.
 164     gas_finish
 165
 166     # Did we find what we were looking for?  If not, flunk it.
 167     if [expr $x==4] then { pass $testname } else { fail $testname }
 168 }
 169
 170
 171 proc do_cmp {} {
 172     set testname "cmp.s: cmp tests"
 173     set x 0
 174
 175     gas_start "cmp.s" "-al"
 176
 177     # Instead of having a variable for each match string just increment the
 178     # total number of matches seen.  That's simpler when testing large numbers
 179     # of instructions (as these tests to).
 180     while 1 {
 181         expect {
 182             -re "^ +\[0-9\]+ 0000 F396\[^\n\]*\n"       { set x [expr $x+1] }
 183             -re "^ +\[0-9\]+ 0002 F22B\[^\n\]*\n"       { set x [expr $x+1] }
 184             -re "^ +\[0-9\]+ 0004 F2EF\[^\n\]*\n"       { set x [expr $x+1] }
 185             -re "^ +\[0-9\]+ 0006 F26E\[^\n\]*\n"       { set x [expr $x+1] }
 186             -re "^ +\[0-9\]+ 0008 DB10\[^\n\]*\n"       { set x [expr $x+1] }
 187             -re "^ +\[0-9\]+ 000a F74A0001\[^\n\]*\n"   { set x [expr $x+1] }
 188             -re "^ +\[0-9\]+ 000e F479FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 189             -re "^ +8 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 190             -re "^ +\[0-9\]+ 0013 EE0001\[^\n\]*\n"     { set x [expr $x+1] }
 191             -re "^ +\[0-9\]+ 0016 F47DFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 192             -re "^ +10 +01\[^\n\]*\n"                   { set x [expr $x+1] }
 193             -re "\[^\n\]*\n"                            { }
 194             timeout                             { perror "timeout\n"; break }
 195             eof                                 { break }
 196         }
 197     }
 198
 199     # This was intended to do any cleanup necessary.  It kinda looks like it
 200     # isn't needed, but just in case, please keep it in for now.
 201     gas_finish
 202
 203     # Did we find what we were looking for?  If not, flunk it.
 204     if [expr $x==11] then { pass $testname } else { fail $testname }
 205 }
 206
 207 proc do_ext {} {
 208     set testname "ext.s: ext tests"
 209     set x 0
 210
 211     gas_start "ext.s" "-al"
 212
 213     # Instead of having a variable for each match string just increment the
 214     # total number of matches seen.  That's simpler when testing large numbers
 215     # of instructions (as these tests to).
 216     while 1 {
 217         expect {
 218             -re "^ +\[0-9\]+ 0000 F3C5\[^\n\]*\n"       { set x [expr $x+1] }
 219             -re "^ +\[0-9\]+ 0002 B2\[^\n\]*\n"         { set x [expr $x+1] }
 220             -re "^ +\[0-9\]+ 0003 B7\[^\n\]*\n"         { set x [expr $x+1] }
 221             -re "^ +\[0-9\]+ 0004 BA\[^\n\]*\n"         { set x [expr $x+1] }
 222             -re "^ +\[0-9\]+ 0005 BD\[^\n\]*\n"         { set x [expr $x+1] }
 223             -re "\[^\n\]*\n"                            { }
 224             timeout                             { perror "timeout\n"; break }
 225             eof                                 { break }
 226         }
 227     }
 228
 229     # This was intended to do any cleanup necessary.  It kinda looks like it
 230     # isn't needed, but just in case, please keep it in for now.
 231     gas_finish
 232
 233     # Did we find what we were looking for?  If not, flunk it.
 234     if [expr $x==5] then { pass $testname } else { fail $testname }
 235 }
 236
 237 proc do_extend {} {
 238     set testname "extend.s: extended instruction tests"
 239     set x 0
 240
 241     gas_start "extend.s" "-al"
 242
 243     # Instead of having a variable for each match string just increment the
 244     # total number of matches seen.  That's simpler when testing large numbers
 245     # of instructions (as these tests to).
 246     while 1 {
 247         expect {
 248             -re "^ +\[0-9\]+ 0000 F505\[^\n\]*\n"       { set x [expr $x+1] }
 249             -re "^ +\[0-9\]+ 0002 F6FA\[^\n\]*\n"       { set x [expr $x+1] }
 250             -re "^ +\[0-9\]+ 0004 F606\[^\n\]*\n"       { set x [expr $x+1] }
 251             -re "^ +\[0-9\]+ 0006 F90210\[^\n\]*\n"     { set x [expr $x+1] }
 252             -re "^ +\[0-9\]+ 0009 FB030100\[^\n\]*\n"   { set x [expr $x+1] }
 253             -re "^ +\[0-9\]+ 000d FD030001\[^\n\]*\n"   { set x [expr $x+1] }
 254             -re "^ +7 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 255             -re "^ +\[0-9\]+ 0013 F616\[^\n\]*\n"       { set x [expr $x+1] }
 256             -re "^ +\[0-9\]+ 0015 F91610\[^\n\]*\n"     { set x [expr $x+1] }
 257             -re "^ +\[0-9\]+ 0018 FB170100\[^\n\]*\n"   { set x [expr $x+1] }
 258             -re "^ +\[0-9\]+ 001c FD170001\[^\n\]*\n"   { set x [expr $x+1] }
 259             -re "^ +11 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 260             -re "^ +\[0-9\]+ 0022 F64B\[^\n\]*\n"       { set x [expr $x+1] }
 261             -re "^ +\[0-9\]+ 0024 F65E\[^\n\]*\n"       { set x [expr $x+1] }
 262             -re "^ +\[0-9\]+ 0026 F676\[^\n\]*\n"       { set x [expr $x+1] }
 263             -re "\[^\n\]*\n"                            { }
 264             timeout                             { perror "timeout\n"; break }
 265             eof                                 { break }
 266         }
 267     }
 268
 269     # This was intended to do any cleanup necessary.  It kinda looks like it
 270     # isn't needed, but just in case, please keep it in for now.
 271     gas_finish
 272
 273     # Did we find what we were looking for?  If not, flunk it.
 274     if [expr $x==15] then { pass $testname } else { fail $testname }
 275 }
 276
 277 proc do_logical {} {
 278     set testname "logical.s: logical tests"
 279     set x 0
 280
 281     gas_start "logical.s" "-al"
 282
 283     # Instead of having a variable for each match string just increment the
 284     # total number of matches seen.  That's simpler when testing large numbers
 285     # of instructions (as these tests to).
 286     while 1 {
 287         expect {
 288             -re "^ +\[0-9\]+ 0000 F306\[^\n\]*\n"       { set x [expr $x+1] }
 289             -re "^ +\[0-9\]+ 0002 F5027F\[^\n\]*\n"     { set x [expr $x+1] }
 290             -re "^ +\[0-9\]+ 0005 F703FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 291             -re "^ +\[0-9\]+ 0009 F710FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 292             -re "^ +\[0-9\]+ 000d F316\[^\n\]*\n"       { set x [expr $x+1] }
 293             -re "^ +\[0-9\]+ 000f F50A7F\[^\n\]*\n"     { set x [expr $x+1] }
 294             -re "^ +\[0-9\]+ 0012 F743FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 295             -re "^ +\[0-9\]+ 0016 F714FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 296             -re "^ +\[0-9\]+ 001a F326\[^\n\]*\n"       { set x [expr $x+1] }
 297             -re "^ +\[0-9\]+ 001c F74FFF7F\[^\n\]*\n"   { set x [expr $x+1] }
 298             -re "^ +\[0-9\]+ 0020 F3E7\[^\n\]*\n"       { set x [expr $x+1] }
 299             -re "^\[^\n\]*\n"                           { }
 300             timeout                             { perror "timeout\n"; break }
 301             eof                                 { break }
 302         }
 303     }
 304
 305     # This was intended to do any cleanup necessary.  It kinda looks like it
 306     # isn't needed, but just in case, please keep it in for now.
 307     gas_finish
 308
 309     # Did we find what we were looking for?  If not, flunk it.
 310     if [expr $x==11] then { pass $testname } else { fail $testname }
 311 }
 312
 313 proc do_loop {} {
 314     set testname "loop.s: loop tests"
 315     set x 0
 316
 317     gas_start "loop.s" "-al"
 318
 319     # Instead of having a variable for each match string just increment the
 320     # total number of matches seen.  That's simpler when testing large numbers
 321     # of instructions (as these tests to).
 322     while 1 {
 323         expect {
 324             -re "^ +\[0-9\]+ 0000 D8\[^\n\]*\n"         { set x [expr $x+1] }
 325             -re "^ +\[0-9\]+ 0001 D9\[^\n\]*\n"         { set x [expr $x+1] }
 326             -re "^ +\[0-9\]+ 0002 D1\[^\n\]*\n"         { set x [expr $x+1] }
 327             -re "^ +\[0-9\]+ 0003 D2\[^\n\]*\n"         { set x [expr $x+1] }
 328             -re "^ +\[0-9\]+ 0004 D3\[^\n\]*\n"         { set x [expr $x+1] }
 329             -re "^ +\[0-9\]+ 0005 D0\[^\n\]*\n"         { set x [expr $x+1] }
 330             -re "^ +\[0-9\]+ 0006 D5\[^\n\]*\n"         { set x [expr $x+1] }
 331             -re "^ +\[0-9\]+ 0007 D6\[^\n\]*\n"         { set x [expr $x+1] }
 332             -re "^ +\[0-9\]+ 0008 D7\[^\n\]*\n"         { set x [expr $x+1] }
 333             -re "^ +\[0-9\]+ 0009 D4\[^\n\]*\n"         { set x [expr $x+1] }
 334             -re "^ +\[0-9\]+ 000a DA\[^\n\]*\n"         { set x [expr $x+1] }
 335             -re "^ +\[0-9\]+ 000b DB\[^\n\]*\n"         { set x [expr $x+1] }
 336             -re "\[^\n\]*\n"                            { }
 337             timeout                             { perror "timeout\n"; break }
 338             eof                                 { break }
 339         }
 340     }
 341
 342     # This was intended to do any cleanup necessary.  It kinda looks like it
 343     # isn't needed, but just in case, please keep it in for now.
 344     gas_finish
 345
 346     # Did we find what we were looking for?  If not, flunk it.
 347     if [expr $x==12] then { pass $testname } else { fail $testname }
 348 }
 349
 350 proc do_mov1 {} {
 351     set testname "mov1.s: mov1 tests"
 352     set x 0
 353
 354     gas_start "mov1.s" "-al"
 355
 356     # Instead of having a variable for each match string just increment the
 357     # total number of matches seen.  That's simpler when testing large numbers
 358     # of instructions (as these tests to).
 359     while 1 {
 360         expect {
 361             -re "^ +\[0-9\]+ 0000 F236\[^\n\]*\n"       { set x [expr $x+1] }
 362             -re "^ +\[0-9\]+ 0002 F2F9\[^\n\]*\n"       { set x [expr $x+1] }
 363             -re "^ +\[0-9\]+ 0004 86\[^\n\]*\n"         { set x [expr $x+1] }
 364             -re "^ +\[0-9\]+ 0005 F279\[^\n\]*\n"       { set x [expr $x+1] }
 365             -re "^ +\[0-9\]+ 0007 F3F3\[^\n\]*\n"       { set x [expr $x+1] }
 366             -re "^ +\[0-9\]+ 0009 F3D8\[^\n\]*\n"       { set x [expr $x+1] }
 367             -re "^ +\[0-9\]+ 000b F3E1\[^\n\]*\n"       { set x [expr $x+1] }
 368             -re "^ +\[0-9\]+ 000d F3C8\[^\n\]*\n"       { set x [expr $x+1] }
 369             -re "^ +\[0-9\]+ 000f 29\[^\n\]*\n"         { set x [expr $x+1] }
 370             -re "^ +\[0-9\]+ 0010 6908\[^\n\]*\n"       { set x [expr $x+1] }
 371             -re "^ +\[0-9\]+ 0012 F7C90001\[^\n\]*\n"   { set x [expr $x+1] }
 372             -re "^ +\[0-9\]+ 0016 F489FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 373             -re "^ +13 +01\[^\n\]*\n"                   { set x [expr $x+1] }
 374             -re "\[^\n\]*\n"                            { }
 375             timeout                             { perror "timeout\n"; break }
 376             eof                                 { break }
 377         }
 378     }
 379
 380     # This was intended to do any cleanup necessary.  It kinda looks like it
 381     # isn't needed, but just in case, please keep it in for now.
 382     gas_finish
 383
 384     # Did we find what we were looking for?  If not, flunk it.
 385     if [expr $x==13] then { pass $testname } else { fail $testname }
 386 }
 387
 388 proc do_mov2 {} {
 389     set testname "mov2.s: mov2 tests"
 390     set x 0
 391
 392     gas_start "mov2.s" "-al"
 393
 394     # Instead of having a variable for each match string just increment the
 395     # total number of matches seen.  That's simpler when testing large numbers
 396     # of instructions (as these tests to).
 397     while 1 {
 398         expect {
 399             -re "^ +\[0-9\]+ 0000 F156\[^\n\]*\n"       { set x [expr $x+1] }
 400             -re "^ +\[0-9\]+ 0002 C90080\[^\n\]*\n"     { set x [expr $x+1] }
 401             -re "^ +\[0-9\]+ 0005 F4C1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 402             -re "^ +4 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 403             -re "^ +\[0-9\]+ 000a 7908\[^\n\]*\n"       { set x [expr $x+1] }
 404             -re "^ +\[0-9\]+ 000c F7B90001\[^\n\]*\n"   { set x [expr $x+1] }
 405             -re "^ +\[0-9\]+ 0010 F4F9FFFF \[^\n\]*\n"  { set x [expr $x+1] }
 406             -re "^ +7 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 407             -re "^ +\[0-9\]+ 0015 F116\[^\n\]*\n"       { set x [expr $x+1] }
 408             -re "^ +\[0-9\]+ 0017 F7310080\[^\n\]*\n"   { set x [expr $x+1] }
 409             -re "^ +\[0-9\]+ 001b F4D1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 410             -re "^ +10 +01\[^\n\]*\n"                   { set x [expr $x+1] }
 411             -re "\[^\n\]*\n"                            { }
 412             timeout                             { perror "timeout\n"; break }
 413             eof                                 { break }
 414         }
 415     }
 416
 417     # This was intended to do any cleanup necessary.  It kinda looks like it
 418     # isn't needed, but just in case, please keep it in for now.
 419     gas_finish
 420
 421     # Did we find what we were looking for?  If not, flunk it.
 422     if [expr $x==12] then { pass $testname } else { fail $testname }
 423 }
 424
 425 proc do_mov3 {} {
 426     set testname "mov3.s: mov3 tests"
 427     set x 0
 428
 429     gas_start "mov3.s" "-al"
 430
 431     # Instead of having a variable for each match string just increment the
 432     # total number of matches seen.  That's simpler when testing large numbers
 433     # of instructions (as these tests to).
 434     while 1 {
 435         expect {
 436             -re "^ +\[0-9\]+ 0000 09\[^\n\]*\n" { set x [expr $x+1] }
 437             -re "^ +\[0-9\]+ 0001 4920\[^\n\]*\n"       { set x [expr $x+1] }
 438             -re "^ +\[0-9\]+ 0003 F7890001\[^\n\]*\n"   { set x [expr $x+1] }
 439             -re "^ +\[0-9\]+ 0007 F409FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 440             -re "^ +5 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 441             -re "^ +\[0-9\]+ 000c F1E9\[^\n\]*\n"       { set x [expr $x+1] }
 442             -re "^ +\[0-9\]+ 000e C18000\[^\n\]*\n"     { set x [expr $x+1] }
 443             -re "^ +\[0-9\]+ 0011 F441FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 444             -re "^ +8 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 445             -re "^ +\[0-9\]+ 0016 5920\[^\n\]*\n"       { set x [expr $x+1] }
 446             -re "^ +\[0-9\]+ 0018 F7A90001\[^\n\]*\n"   { set x [expr $x+1] }
 447             -re "^ +\[0-9\]+ 001c F419FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 448             -re "^ +11 +01\[^\n\]*\n"                   { set x [expr $x+1] }
 449             -re "\[^\n\]*\n"                            { }
 450             timeout                             { perror "timeout\n"; break }
 451             eof                                 { break }
 452         }
 453     }
 454
 455     # This was intended to do any cleanup necessary.  It kinda looks like it
 456     # isn't needed, but just in case, please keep it in for now.
 457     gas_finish
 458
 459     # Did we find what we were looking for?  If not, flunk it.
 460     if [expr $x==13] then { pass $testname } else { fail $testname }
 461 }
 462
 463 proc do_mov4 {} {
 464     set testname "mov4.s: mov4 tests"
 465     set x 0
 466
 467     gas_start "mov4.s" "-al"
 468
 469     # Instead of having a variable for each match string just increment the
 470     # total number of matches seen.  That's simpler when testing large numbers
 471     # of instructions (as these tests to).
 472     while 1 {
 473         expect {
 474             -re "^ +\[0-9\]+ 0000 F1A9\[^\n\]*\n"       { set x [expr $x+1] }
 475             -re "^ +\[0-9\]+ 0002 F7218000\[^\n\]*\n"   { set x [expr $x+1] }
 476             -re "^ +\[0-9\]+ 0006 F451FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 477             -re "^ +4 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 478             -re "^ +\[0-9\]+ 000b 8508\[^\n\]*\n"       { set x [expr $x+1] }
 479             -re "^ +\[0-9\]+ 000d F90001\[^\n\]*\n"     { set x [expr $x+1] }
 480             -re "^ +\[0-9\]+ 0010 F471FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 481             -re "^ +7 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 482             -re "^ +\[0-9\]+ 0015 DD0001\[^\n\]*\n"     { set x [expr $x+1] }
 483             -re "^ +\[0-9\]+ 0018 F475FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 484             -re "^ +9 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 485             -re "\[^\n\]*\n"                            { }
 486             timeout                             { perror "timeout\n"; break }
 487             eof                                 { break }
 488         }
 489     }
 490
 491     # This was intended to do any cleanup necessary.  It kinda looks like it
 492     # isn't needed, but just in case, please keep it in for now.
 493     gas_finish
 494
 495     # Did we find what we were looking for?  If not, flunk it.
 496     if [expr $x==11] then { pass $testname } else { fail $testname }
 497 }
 498
 499 proc do_movx {} {
 500     set testname "movx.s: movx tests"
 501     set x 0
 502
 503     gas_start "movx.s" "-al"
 504
 505     # Instead of having a variable for each match string just increment the
 506     # total number of matches seen.  That's simpler when testing large numbers
 507     # of instructions (as these tests to).
 508     while 1 {
 509         expect {
 510             -re "^ +\[0-9\]+ 0000 F57908\[^\n\]*\n"     { set x [expr $x+1] }
 511             -re "^ +\[0-9\]+ 0003 F7790001\[^\n\]*\n"   { set x [expr $x+1] }
 512             -re "^ +\[0-9\]+ 0007 F4B9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 513             -re "^ +4 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 514             -re "^ +\[0-9\]+ 000c F55908\[^\n\]*\n"     { set x [expr $x+1] }
 515             -re "^ +\[0-9\]+ 000f F7690001\[^\n\]*\n"   { set x [expr $x+1] }
 516             -re "^ +\[0-9\]+ 0013 F439FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 517             -re "^ +7 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 518             -re "\[^\n\]*\n"                            { }
 519             timeout                             { perror "timeout\n"; break }
 520             eof                                 { break }
 521         }
 522     }
 523
 524     # This was intended to do any cleanup necessary.  It kinda looks like it
 525     # isn't needed, but just in case, please keep it in for now.
 526     gas_finish
 527
 528     # Did we find what we were looking for?  If not, flunk it.
 529     if [expr $x==8] then { pass $testname } else { fail $testname }
 530 }
 531
 532 proc do_movb {} {
 533     set testname "movb.s: movb tests"
 534     set x 0
 535
 536     gas_start "movb.s" "-al"
 537
 538     # Instead of having a variable for each match string just increment the
 539     # total number of matches seen.  That's simpler when testing large numbers
 540     # of instructions (as these tests to).
 541     while 1 {
 542         expect {
 543             -re "^ +\[0-9\]+ 0000 F52908\[^\n\]*\n"     { set x [expr $x+1] }
 544             -re "^ +\[0-9\]+ 0003 F7D90001\[^\n\]*\n"   { set x [expr $x+1] }
 545             -re "^ +\[0-9\]+ 0007 F4A9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 546             -re "^ +4 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 547             -re "^ +\[0-9\]+ 000c F06B\[^\n\]*\n"       { set x [expr $x+1] }
 548             -re "^ +\[0-9\]+ 000e F4C6FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 549             -re "^ +6 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 550             -re "^ +\[0-9\]+ 0013 19\[^\n\]*\n" { set x [expr $x+1] }
 551             -re "^ +\[0-9\]+ 0014 F51908\[^\n\]*\n"     { set x [expr $x+1] }
 552             -re "^ +\[0-9\]+ 0017 F7990001\[^\n\]*\n"   { set x [expr $x+1] }
 553             -re "^ +\[0-9\]+ 001b F429FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 554             -re "^ +10 +01\[^\n\]*\n"                   { set x [expr $x+1] }
 555             -re "^ +\[0-9\]+ 0020 F0E9\[^\n\]*\n"       { set x [expr $x+1] }
 556             -re "^ +\[0-9\]+ 0022 C50001\[^\n\]*\n"     { set x [expr $x+1] }
 557             -re "^ +\[0-9\]+ 0025 F445FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 558             -re "^ +13 +01\[^\n\]*\n"                   { set x [expr $x+1] }
 559             -re "\[^\n\]*\n"                            { }
 560             timeout                             { perror "timeout\n"; break }
 561             eof                                 { break }
 562         }
 563     }
 564
 565     # This was intended to do any cleanup necessary.  It kinda looks like it
 566     # isn't needed, but just in case, please keep it in for now.
 567     gas_finish
 568
 569     # Did we find what we were looking for?  If not, flunk it.
 570     if [expr $x==16] then { pass $testname } else { fail $testname }
 571 }
 572
 573 proc do_movbu {} {
 574     set testname "movbu.s: movbu tests"
 575     set x 0
 576
 577     gas_start "movbu.s" "-al"
 578
 579     # Instead of having a variable for each match string just increment the
 580     # total number of matches seen.  That's simpler when testing large numbers
 581     # of instructions (as these tests to).
 582     while 1 {
 583         expect {
 584             -re "^ +\[0-9\]+ 0000 39\[^\n\]*\n" { set x [expr $x+1] }
 585             -re "^ +\[0-9\]+ 0001 F53908\[^\n\]*\n"     { set x [expr $x+1] }
 586             -re "^ +\[0-9\]+ 0004 F7590001\[^\n\]*\n"   { set x [expr $x+1] }
 587             -re "^ +\[0-9\]+ 0008 F499FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 588             -re "^ +5 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 589             -re "^ +\[0-9\]+ 000d F096\[^\n\]*\n"       { set x [expr $x+1] }
 590             -re "^ +\[0-9\]+ 000f CD0080\[^\n\]*\n"     { set x [expr $x+1] }
 591             -re "^ +\[0-9\]+ 0012 F4C9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 592             -re "^ +8 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 593             -re "\[^\n\]*\n"                            { }
 594             timeout                             { perror "timeout\n"; break }
 595             eof                                 { break }
 596         }
 597     }
 598
 599     # This was intended to do any cleanup necessary.  It kinda looks like it
 600     # isn't needed, but just in case, please keep it in for now.
 601     gas_finish
 602
 603     # Did we find what we were looking for?  If not, flunk it.
 604     if [expr $x==9] then { pass $testname } else { fail $testname }
 605 }
 606
 607 proc do_movhu {} {
 608     set testname "movhu.s: movhu tests"
 609     set x 0
 610
 611     gas_start "movhu.s" "-al"
 612
 613     # Instead of having a variable for each match string just increment the
 614     # total number of matches seen.  That's simpler when testing large numbers
 615     # of instructions (as these tests to).
 616     while 1 {
 617         expect {
 618             -re "^ +\[0-9\]+ 0000 F066\[^\n\]*\n"       { set x [expr $x+1] }
 619             -re "^ +\[0-9\]+ 0002 F86608\[^\n\]*\n"     { set x [expr $x+1] }
 620             -re "^ +\[0-9\]+ 0005 FA660100\[^\n\]*\n"   { set x [expr $x+1] }
 621             -re "^ +\[0-9\]+ 0009 FC660001\[^\n\]*\n"   { set x [expr $x+1] }
 622             -re "^ +5 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 623             -re "^ +\[0-9\]+ 000f F8BD08\[^\n\]*\n"     { set x [expr $x+1] }
 624             -re "^ +\[0-9\]+ 0012 FABD0100\[^\n\]*\n"   { set x [expr $x+1] }
 625             -re "^ +\[0-9\]+ 0016 FCBD0001\[^\n\]*\n"   { set x [expr $x+1] }
 626             -re "^ +8 +FFFF\[^\n\]*\n"                  { set x [expr $x+1] }
 627             -re "^ +\[0-9\]+ 001c F4A5\[^\n\]*\n"       { set x [expr $x+1] }
 628             -re "^ +\[0-9\]+ 001e 398000\[^\n\]*\n"     { set x [expr $x+1] }
 629             -re "^ +\[0-9\]+ 0021 FCAD0001\[^\n\]*\n"   { set x [expr $x+1] }
 630             -re "^ +11 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 631             -re "^ +\[0-9\]+ 0027 F076\[^\n\]*\n"       { set x [expr $x+1] }
 632             -re "^ +\[0-9\]+ 0029 F87620\[^\n\]*\n"     { set x [expr $x+1] }
 633             -re "^ +\[0-9\]+ 002c FA760100\[^\n\]*\n"   { set x [expr $x+1] }
 634             -re "^ +\[0-9\]+ 0030 FC760001\[^\n\]*\n"   { set x [expr $x+1] }
 635             -re "^ +15 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 636             -re "^ +\[0-9\]+ 0036 F89720\[^\n\]*\n"     { set x [expr $x+1] }
 637             -re "^ +\[0-9\]+ 0039 FA978000\[^\n\]*\n"   { set x [expr $x+1] }
 638             -re "^ +\[0-9\]+ 003d FC970001\[^\n\]*\n"   { set x [expr $x+1] }
 639             -re "^ +18 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 640             -re "^ +\[0-9\]+ 0043 F4DA\[^\n\]*\n"       { set x [expr $x+1] }
 641             -re "^ +\[0-9\]+ 0045 070080\[^\n\]*\n"     { set x [expr $x+1] }
 642             -re "^ +\[0-9\]+ 0048 FC870001\[^\n\]*\n"   { set x [expr $x+1] }
 643             -re "^ +21 +FFFF\[^\n\]*\n"                 { set x [expr $x+1] }
 644             -re "\[^\n\]*\n"                            { }
 645             timeout                             { perror "timeout\n"; break }
 646             eof                                 { break }
 647         }
 648     }
 649
 650     # This was intended to do any cleanup necessary.  It kinda looks like it
 651     # isn't needed, but just in case, please keep it in for now.
 652     gas_finish
 653
 654     # Did we find what we were looking for?  If not, flunk it.
 655     if [expr $x==26] then { pass $testname } else { fail $testname }
 656 }
 657
 658 proc do_movm {} {
 659     set testname "movm.s: movm tests"
 660     set x 0
 661
 662     gas_start "movm.s" "-al"
 663
 664     # Instead of having a variable for each match string just increment the
 665     # total number of matches seen.  That's simpler when testing large numbers
 666     # of instructions (as these tests to).
 667     while 1 {
 668         expect {
 669             -re "^ +\[0-9\]+ 0000 CE30\[^\n\]*\n"       { set x [expr $x+1] }
 670             -re "^ +\[0-9\]+ 0002 CEF8\[^\n\]*\n"       { set x [expr $x+1] }
 671             -re "^ +\[0-9\]+ 0004 CF30\[^\n\]*\n"       { set x [expr $x+1] }
 672             -re "^ +\[0-9\]+ 0006 CFF8\[^\n\]*\n"       { set x [expr $x+1] }
 673             -re "\[^\n\]*\n"                            { }
 674             timeout                             { perror "timeout\n"; break }
 675             eof                                 { break }
 676         }
 677     }
 678
 679     # This was intended to do any cleanup necessary.  It kinda looks like it
 680     # isn't needed, but just in case, please keep it in for now.
 681     gas_finish
 682
 683     # Did we find what we were looking for?  If not, flunk it.
 684     if [expr $x==4] then { pass $testname } else { fail $testname }
 685 }
 686
 687 proc do_muldiv {} {
 688     set testname "muldiv.s: muldiv tests"
 689     set x 0
 690
 691     gas_start "muldiv.s" "-al"
 692
 693     # Instead of having a variable for each match string just increment the
 694     # total number of matches seen.  That's simpler when testing large numbers
 695     # of instructions (as these tests to).
 696     while 1 {
 697         expect {
 698             -re "^ +\[0-9\]+ 0000 F346\[^\n\]*\n"       { set x [expr $x+1] }
 699             -re "^ +\[0-9\]+ 0002 F35B\[^\n\]*\n"       { set x [expr $x+1] }
 700             -re "^ +\[0-9\]+ 0004 F36E\[^\n\]*\n"       { set x [expr $x+1] }
 701             -re "\[^\n\]*\n"                            { }
 702             timeout                             { perror "timeout\n"; break }
 703             eof                                 { break }
 704         }
 705     }
 706
 707     # This was intended to do any cleanup necessary.  It kinda looks like it
 708     # isn't needed, but just in case, please keep it in for now.
 709     gas_finish
 710
 711     # Did we find what we were looking for?  If not, flunk it.
 712     if [expr $x==3] then { pass $testname } else { fail $testname }
 713 }
 714
 715 proc do_other {} {
 716     set testname "other.s: other tests"
 717     set x 0
 718
 719     gas_start "other.s" "-al"
 720
 721     # Instead of having a variable for each match string just increment the
 722     # total number of matches seen.  That's simpler when testing large numbers
 723     # of instructions (as these tests to).
 724     while 1 {
 725         expect {
 726             -re "^ +\[0-9\]+ 0000 FC0001\[^\n\]*\n"     { set x [expr $x+1] }
 727             -re "^ +\[0-9\]+ 0003 F4E0FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 728             -re "^ +3 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 729             -re "^ +\[0-9\]+ 0008 F008\[^\n\]*\n"       { set x [expr $x+1] }
 730             -re "^ +\[0-9\]+ 000a FD0001\[^\n\]*\n"     { set x [expr $x+1] }
 731             -re "^ +\[0-9\]+ 000d F4E1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 732             -re "^ +6 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 733             -re "^ +\[0-9\]+ 0012 F009\[^\n\]*\n"       { set x [expr $x+1] }
 734             -re "^ +\[0-9\]+ 0014 FE\[^\n\]*\n" { set x [expr $x+1] }
 735             -re "^ +\[0-9\]+ 0015 EB\[^\n\]*\n" { set x [expr $x+1] }
 736             -re "^ +\[0-9\]+ 0016 F6\[^\n\]*\n" { set x [expr $x+1] }
 737             -re "\[^\n\]*\n"                            { }
 738             timeout                             { perror "timeout\n"; break }
 739             eof                                 { break }
 740         }
 741     }
 742
 743     # This was intended to do any cleanup necessary.  It kinda looks like it
 744     # isn't needed, but just in case, please keep it in for now.
 745     gas_finish
 746
 747     # Did we find what we were looking for?  If not, flunk it.
 748     if [expr $x==11] then { pass $testname } else { fail $testname }
 749 }
 750
 751 proc do_shift {} {
 752     set testname "shift.s: shift tests"
 753     set x 0
 754
 755     gas_start "shift.s" "-al"
 756
 757     # Instead of having a variable for each match string just increment the
 758     # total number of matches seen.  That's simpler when testing large numbers
 759     # of instructions (as these tests to).
 760     while 1 {
 761         expect {
 762             -re "^ +\[0-9\]+ 0000 F33A\[^\n\]*\n"       { set x [expr $x+1] }
 763             -re "^ +\[0-9\]+ 0002 F33F\[^\n\]*\n"       { set x [expr $x+1] }
 764             -re "^ +\[0-9\]+ 0004 F335\[^\n\]*\n"       { set x [expr $x+1] }
 765             -re "^ +\[0-9\]+ 0006 F332\[^\n\]*\n"       { set x [expr $x+1] }
 766             -re "\[^\n\]*\n"                            { }
 767             timeout                             { perror "timeout\n"; break }
 768             eof                                 { break }
 769         }
 770     }
 771
 772     # This was intended to do any cleanup necessary.  It kinda looks like it
 773     # isn't needed, but just in case, please keep it in for now.
 774     gas_finish
 775
 776     # Did we find what we were looking for?  If not, flunk it.
 777     if [expr $x==4] then { pass $testname } else { fail $testname }
 778 }
 779
 780 proc do_sub {} {
 781     set testname "sub.s: sub tests"
 782     set x 0
 783
 784     gas_start "sub.s" "-al"
 785
 786     # Instead of having a variable for each match string just increment the
 787     # total number of matches seen.  That's simpler when testing large numbers
 788     # of instructions (as these tests to).
 789     while 1 {
 790         expect {
 791             -re "^ +\[0-9\]+ 0000 A6\[^\n\]*\n" { set x [expr $x+1] }
 792             -re "^ +\[0-9\]+ 0001 F21B\[^\n\]*\n"       { set x [expr $x+1] }
 793             -re "^ +\[0-9\]+ 0003 F2DF\[^\n\]*\n"       { set x [expr $x+1] }
 794             -re "^ +\[0-9\]+ 0005 F25E\[^\n\]*\n"       { set x [expr $x+1] }
 795             -re "^ +\[0-9\]+ 0007 F71EFF7F \[^\n\]*\n"  { set x [expr $x+1] }
 796             -re "^ +\[0-9\]+ 000b F46AFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 797             -re "^ +7 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 798             -re "^ +\[0-9\]+ 0010 F70EFF7F \[^\n\]*\n"  { set x [expr $x+1] }
 799             -re "^ +\[0-9\]+ 0014 F46EFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 800             -re "^ +9 +01\[^\n\]*\n"                    { set x [expr $x+1] }
 801             -re "^ +\[0-9\]+ 0019 F296 \[^\n\]*\n"      { set x [expr $x+1] }
 802             -re "\[^\n\]*\n"                            { }
 803             timeout                             { perror "timeout\n"; break }
 804             eof                                 { break }
 805         }
 806     }
 807
 808     # This was intended to do any cleanup necessary.  It kinda looks like it
 809     # isn't needed, but just in case, please keep it in for now.
 810     gas_finish
 811
 812     # Did we find what we were looking for?  If not, flunk it.
 813     if [expr $x==11] then { pass $testname } else { fail $testname }
 814 }
 815
 816 if [istarget mn10200*-*-*] then {
 817     # Test the basic instruction parser.
 818     do_add
 819     do_bcc
 820     do_bccx
 821     do_bit
 822     do_cmp
 823     do_ext
 824     do_logical
 825     do_mov1
 826     do_mov2
 827     do_mov3
 828     do_mov4
 829     do_movb
 830     do_movx
 831     do_movbu
 832     do_muldiv
 833     do_other
 834     do_shift
 835     do_sub
 836 }