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\[^\n\]*\n"    { set x [expr $x+1] }
  40             -re "^ +\[0-9\]+ 0013 2110\[^\n\]*\n"       { set x [expr $x+1] }
  41             -re "^ +\[0-9\]+ 0015 FAD20100\[^\n\]*\n"   { set x [expr $x+1] }
  42             -re "^ +\[0-9\]+ 0019\[^\n\]*\n"    { set x [expr $x+1] }
  43             -re "^ +\[0-9\]+ 001f F8FE10\[^\n\]*\n"     { set x [expr $x+1] }
  44             -re "^ +\[0-9\]+ 0022 FAFE0100\[^\n\]*\n"   { set x [expr $x+1] }
  45             -re "^ +\[0-9\]+ 0026\[^\n\]*\n"    { set x [expr $x+1] }
  46             -re "^ +\[0-9\]+ 002c F146\[^\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 C800\[^\n\]*\n"       { set x [expr $x+1] }
  73             -re "^ +\[0-9\]+ 0002 C900\[^\n\]*\n"       { set x [expr $x+1] }
  74             -re "^ +\[0-9\]+ 0004 C100\[^\n\]*\n"       { set x [expr $x+1] }
  75             -re "^ +\[0-9\]+ 0006 C200\[^\n\]*\n"       { set x [expr $x+1] }
  76             -re "^ +\[0-9\]+ 0008 C300\[^\n\]*\n"       { set x [expr $x+1] }
  77             -re "^ +\[0-9\]+ 000a C000\[^\n\]*\n"       { set x [expr $x+1] }
  78             -re "^ +\[0-9\]+ 000c C500\[^\n\]*\n"       { set x [expr $x+1] }
  79             -re "^ +\[0-9\]+ 000e C600\[^\n\]*\n"       { set x [expr $x+1] }
  80             -re "^ +\[0-9\]+ 0010 C700\[^\n\]*\n"       { set x [expr $x+1] }
  81             -re "^ +\[0-9\]+ 0012 C400\[^\n\]*\n"       { set x [expr $x+1] }
  82             -re "^ +\[0-9\]+ 0014 F8E800\[^\n\]*\n"     { set x [expr $x+1] }
  83             -re "^ +\[0-9\]+ 0017 F8E900\[^\n\]*\n"     { set x [expr $x+1] }
  84             -re "^ +\[0-9\]+ 001a F8EA00\[^\n\]*\n"     { set x [expr $x+1] }
  85             -re "^ +\[0-9\]+ 001d F8EB00\[^\n\]*\n"     { set x [expr $x+1] }
  86             -re "^ +\[0-9\]+ 0020 CA00\[^\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_bit {} {
 102     set testname "bit.s: bit tests"
 103     set x 0
 104
 105     gas_start "bit.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 F8ED40\[^\n\]*\n"     { set x [expr $x+1] }
 113             -re "^ +\[0-9\]+ 0003 FAEE2000\[^\n\]*\n"   { set x [expr $x+1] }
 114             -re "^ +\[0-9\]+ 0007\[^\n\]*\n"    { set x [expr $x+1] }
 115             -re "^ +\[0-9\]+ 000d\[^\n\]*\n"    { set x [expr $x+1] }
 116             -re "^ +\[0-9\]+ 0011\[^\n\]*\n"    { set x [expr $x+1] }
 117             -re "^ +\[0-9\]+ 0018 F086\[^\n\]*\n"       { set x [expr $x+1] }
 118             -re "^ +\[0-9\]+ 001a\[^\n\]*\n"    { set x [expr $x+1] }
 119             -re "^ +\[0-9\]+ 001e\[^\n\]*\n"    { set x [expr $x+1] }
 120             -re "^ +\[0-9\]+ 0025 F096\[^\n\]*\n"       { set x [expr $x+1] }
 121             -re "^ +\[0-9\]+ 0027\[^\n\]*\n"    { set x [expr $x+1] }
 122             -re "^ +\[0-9\]+ 002b\[^\n\]*\n"    { set x [expr $x+1] }
 123             -re "\[^\n\]*\n"                            { }
 124             timeout                             { perror "timeout\n"; break }
 125             eof                                 { break }
 126         }
 127     }
 128
 129     # This was intended to do any cleanup necessary.  It kinda looks like it
 130     # isn't needed, but just in case, please keep it in for now.
 131     gas_finish
 132
 133     # Did we find what we were looking for?  If not, flunk it.
 134     if [expr $x==11] then { pass $testname } else { fail $testname }
 135 }
 136
 137 proc do_cmp {} {
 138     set testname "cmp.s: cmp tests"
 139     set x 0
 140
 141     gas_start "cmp.s" "-al"
 142
 143     # Instead of having a variable for each match string just increment the
 144     # total number of matches seen.  That's simpler when testing large numbers
 145     # of instructions (as these tests to).
 146     while 1 {
 147         expect {
 148             -re "^ +\[0-9\]+ 0000 A6\[^\n\]*\n" { set x [expr $x+1] }
 149             -re "^ +\[0-9\]+ 0001 F1AB\[^\n\]*\n"       { set x [expr $x+1] }
 150             -re "^ +\[0-9\]+ 0003 F19F\[^\n\]*\n"       { set x [expr $x+1] }
 151             -re "^ +\[0-9\]+ 0005 BE\[^\n\]*\n" { set x [expr $x+1] }
 152             -re "^ +\[0-9\]+ 0006 AF10\[^\n\]*\n"       { set x [expr $x+1] }
 153             -re "^ +\[0-9\]+ 0008 FACA0100\[^\n\]*\n"   { set x [expr $x+1] }
 154             -re "^ +\[0-9\]+ 000c\[^\n\]*\n"    { set x [expr $x+1] }
 155             -re "^ +\[0-9\]+ 0012 BF10\[^\n\]*\n"       { set x [expr $x+1] }
 156             -re "^ +\[0-9\]+ 0014 FADA0100\[^\n\]*\n"   { set x [expr $x+1] }
 157             -re "^ +\[0-9\]+ 0018\[^\n\]*\n"    { set x [expr $x+1] }
 158             -re "\[^\n\]*\n"                            { }
 159             timeout                             { perror "timeout\n"; break }
 160             eof                                 { break }
 161         }
 162     }
 163
 164     # This was intended to do any cleanup necessary.  It kinda looks like it
 165     # isn't needed, but just in case, please keep it in for now.
 166     gas_finish
 167
 168     # Did we find what we were looking for?  If not, flunk it.
 169     if [expr $x==10] then { pass $testname } else { fail $testname }
 170 }
 171
 172 proc do_ext {} {
 173     set testname "ext.s: ext tests"
 174     set x 0
 175
 176     gas_start "ext.s" "-al"
 177
 178     # Instead of having a variable for each match string just increment the
 179     # total number of matches seen.  That's simpler when testing large numbers
 180     # of instructions (as these tests to).
 181     while 1 {
 182         expect {
 183             -re "^ +\[0-9\]+ 0000 F2D1\[^\n\]*\n"       { set x [expr $x+1] }
 184             -re "^ +\[0-9\]+ 0002 12\[^\n\]*\n" { set x [expr $x+1] }
 185             -re "^ +\[0-9\]+ 0003 17\[^\n\]*\n" { set x [expr $x+1] }
 186             -re "^ +\[0-9\]+ 0004 1A\[^\n\]*\n" { set x [expr $x+1] }
 187             -re "^ +\[0-9\]+ 0005 1D\[^\n\]*\n" { set x [expr $x+1] }
 188             -re "\[^\n\]*\n"                            { }
 189             timeout                             { perror "timeout\n"; break }
 190             eof                                 { break }
 191         }
 192     }
 193
 194     # This was intended to do any cleanup necessary.  It kinda looks like it
 195     # isn't needed, but just in case, please keep it in for now.
 196     gas_finish
 197
 198     # Did we find what we were looking for?  If not, flunk it.
 199     if [expr $x==5] then { pass $testname } else { fail $testname }
 200 }
 201
 202 proc do_extend {} {
 203     set testname "extend.s: extended instruction tests"
 204     set x 0
 205
 206     gas_start "extend.s" "-al"
 207
 208     # Instead of having a variable for each match string just increment the
 209     # total number of matches seen.  That's simpler when testing large numbers
 210     # of instructions (as these tests to).
 211     while 1 {
 212         expect {
 213             -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
 214             -re "^ +\[0-9\]+ 0002\[^\n\]*\n"    { set x [expr $x+1] }
 215             -re "^ +\[0-9\]+ 0004\[^\n\]*\n"    { set x [expr $x+1] }
 216             -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
 217             -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
 218             -re "^ +\[0-9\]+ 000d\[^\n\]*\n"    { set x [expr $x+1] }
 219             -re "^ +\[0-9\]+ 0013\[^\n\]*\n"    { set x [expr $x+1] }
 220             -re "^ +\[0-9\]+ 0015\[^\n\]*\n"    { set x [expr $x+1] }
 221             -re "^ +\[0-9\]+ 0018\[^\n\]*\n"    { set x [expr $x+1] }
 222             -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
 223             -re "^ +\[0-9\]+ 0022\[^\n\]*\n"    { set x [expr $x+1] }
 224             -re "^ +\[0-9\]+ 0024\[^\n\]*\n"    { set x [expr $x+1] }
 225             -re "^ +\[0-9\]+ 0026\[^\n\]*\n"    { set x [expr $x+1] }
 226             -re "\[^\n\]*\n"                            { }
 227             timeout                             { perror "timeout\n"; break }
 228             eof                                 { break }
 229         }
 230     }
 231
 232     # This was intended to do any cleanup necessary.  It kinda looks like it
 233     # isn't needed, but just in case, please keep it in for now.
 234     gas_finish
 235
 236     # Did we find what we were looking for?  If not, flunk it.
 237     if [expr $x==13] then { pass $testname } else { fail $testname }
 238 }
 239
 240 proc do_logical {} {
 241     set testname "logical.s: logical tests"
 242     set x 0
 243
 244     gas_start "logical.s" "-al"
 245
 246     # Instead of having a variable for each match string just increment the
 247     # total number of matches seen.  That's simpler when testing large numbers
 248     # of instructions (as these tests to).
 249     while 1 {
 250         expect {
 251             -re "^ +\[0-9\]+ 0000 F206\[^\n\]*\n"       { set x [expr $x+1] }
 252             -re "^ +\[0-9\]+ 0002 F8E27F\[^\n\]*\n"     { set x [expr $x+1] }
 253             -re "^ +\[0-9\]+ 0005 FAE37FFF\[^\n\]*\n"   { set x [expr $x+1] }
 254             -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
 255             -re "^ +\[0-9\]+ 000f FAFC7FFF\[^\n\]*\n"   { set x [expr $x+1] }
 256             -re "^ +\[0-9\]+ 0013 F216\[^\n\]*\n"       { set x [expr $x+1] }
 257             -re "^ +\[0-9\]+ 0015 F8E67F\[^\n\]*\n"     { set x [expr $x+1] }
 258             -re "^ +\[0-9\]+ 0018 FAE77FFF\[^\n\]*\n"   { set x [expr $x+1] }
 259             -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
 260             -re "^ +\[0-9\]+ 0022 FAFD7FFF\[^\n\]*\n"   { set x [expr $x+1] }
 261             -re "^ +\[0-9\]+ 0026 F226\[^\n\]*\n"       { set x [expr $x+1] }
 262             -re "^ +\[0-9\]+ 0028 FAEB7FFF\[^\n\]*\n"   { set x [expr $x+1] }
 263             -re "^ +\[0-9\]+ 002c\[^\n\]*\n"    { set x [expr $x+1] }
 264             -re "^ +\[0-9\]+ 0032 F233\[^\n\]*\n"       { set x [expr $x+1] }
 265             -re "\[^\n\]*\n"                            { }
 266             timeout                             { perror "timeout\n"; break }
 267             eof                                 { break }
 268         }
 269     }
 270
 271     # This was intended to do any cleanup necessary.  It kinda looks like it
 272     # isn't needed, but just in case, please keep it in for now.
 273     gas_finish
 274
 275     # Did we find what we were looking for?  If not, flunk it.
 276     if [expr $x==14] then { pass $testname } else { fail $testname }
 277 }
 278
 279 proc do_loop {} {
 280     set testname "loop.s: loop tests"
 281     set x 0
 282
 283     gas_start "loop.s" "-al"
 284
 285     # Instead of having a variable for each match string just increment the
 286     # total number of matches seen.  That's simpler when testing large numbers
 287     # of instructions (as these tests to).
 288     while 1 {
 289         expect {
 290             -re "^ +\[0-9\]+ 0000 D8\[^\n\]*\n" { set x [expr $x+1] }
 291             -re "^ +\[0-9\]+ 0001 D9\[^\n\]*\n" { set x [expr $x+1] }
 292             -re "^ +\[0-9\]+ 0002 D1\[^\n\]*\n" { set x [expr $x+1] }
 293             -re "^ +\[0-9\]+ 0003 D2\[^\n\]*\n" { set x [expr $x+1] }
 294             -re "^ +\[0-9\]+ 0004 D3\[^\n\]*\n" { set x [expr $x+1] }
 295             -re "^ +\[0-9\]+ 0005 D0\[^\n\]*\n" { set x [expr $x+1] }
 296             -re "^ +\[0-9\]+ 0006 D5\[^\n\]*\n" { set x [expr $x+1] }
 297             -re "^ +\[0-9\]+ 0007 D6\[^\n\]*\n" { set x [expr $x+1] }
 298             -re "^ +\[0-9\]+ 0008 D7\[^\n\]*\n" { set x [expr $x+1] }
 299             -re "^ +\[0-9\]+ 0009 D4\[^\n\]*\n" { set x [expr $x+1] }
 300             -re "^ +\[0-9\]+ 000a DA\[^\n\]*\n" { set x [expr $x+1] }
 301             -re "^ +\[0-9\]+ 000b DB\[^\n\]*\n" { set x [expr $x+1] }
 302             -re "\[^\n\]*\n"                            { }
 303             timeout                             { perror "timeout\n"; break }
 304             eof                                 { break }
 305         }
 306     }
 307
 308     # This was intended to do any cleanup necessary.  It kinda looks like it
 309     # isn't needed, but just in case, please keep it in for now.
 310     gas_finish
 311
 312     # Did we find what we were looking for?  If not, flunk it.
 313     if [expr $x==12] then { pass $testname } else { fail $testname }
 314 }
 315
 316 proc do_mov1 {} {
 317     set testname "mov1.s: mov1 tests"
 318     set x 0
 319
 320     gas_start "mov1.s" "-al"
 321
 322     # Instead of having a variable for each match string just increment the
 323     # total number of matches seen.  That's simpler when testing large numbers
 324     # of instructions (as these tests to).
 325     while 1 {
 326         expect {
 327             -re "^ +\[0-9\]+ 0000 86\[^\n\]*\n" { set x [expr $x+1] }
 328             -re "^ +\[0-9\]+ 0001 F1E6\[^\n\]*\n"       { set x [expr $x+1] }
 329             -re "^ +\[0-9\]+ 0003 F1D9\[^\n\]*\n"       { set x [expr $x+1] }
 330             -re "^ +\[0-9\]+ 0005 99\[^\n\]*\n" { set x [expr $x+1] }
 331             -re "^ +\[0-9\]+ 0006 3E\[^\n\]*\n" { set x [expr $x+1] }
 332             -re "^ +\[0-9\]+ 0007 F2F4\[^\n\]*\n"       { set x [expr $x+1] }
 333             -re "^ +\[0-9\]+ 0009 F2FB\[^\n\]*\n"       { set x [expr $x+1] }
 334             -re "^ +\[0-9\]+ 000b F2E1\[^\n\]*\n"       { set x [expr $x+1] }
 335             -re "^ +\[0-9\]+ 000d F2FA\[^\n\]*\n"       { set x [expr $x+1] }
 336             -re "^ +\[0-9\]+ 000f 76\[^\n\]*\n" { set x [expr $x+1] }
 337             -re "^ +\[0-9\]+ 0010 F80608\[^\n\]*\n"     { set x [expr $x+1] }
 338             -re "^ +\[0-9\]+ 0013 FA060100\[^\n\]*\n"   { set x [expr $x+1] }
 339             -re "^ +\[0-9\]+ 0017\[^\n\]*\n"    { set x [expr $x+1] }
 340             -re "^ +\[0-9\]+ 001d 5908\[^\n\]*\n"       { set x [expr $x+1] }
 341             -re "^ +\[0-9\]+ 001f FAB50100\[^\n\]*\n"   { set x [expr $x+1] }
 342             -re "^ +\[0-9\]+ 0023 F2E7\[^\n\]*\n"       { set x [expr $x+1] }
 343             -re "\[^\n\]*\n"                            { }
 344             timeout                             { perror "timeout\n"; break }
 345             eof                                 { break }
 346         }
 347     }
 348
 349     # This was intended to do any cleanup necessary.  It kinda looks like it
 350     # isn't needed, but just in case, please keep it in for now.
 351     gas_finish
 352
 353     # Did we find what we were looking for?  If not, flunk it.
 354     if [expr $x==16] then { pass $testname } else { fail $testname }
 355 }
 356
 357 proc do_mov2 {} {
 358     set testname "mov2.s: mov2 tests"
 359     set x 0
 360
 361     gas_start "mov2.s" "-al"
 362
 363     # Instead of having a variable for each match string just increment the
 364     # total number of matches seen.  That's simpler when testing large numbers
 365     # of instructions (as these tests to).
 366     while 1 {
 367         expect {
 368             -re "^ +\[0-9\]+ 0000\[^\n\]*\n"    { set x [expr $x+1] }
 369             -re "^ +\[0-9\]+ 0006\[^\n\]*\n"    { set x [expr $x+1] }
 370             -re "^ +\[0-9\]+ 0008 318000\[^\n\]*\n"     { set x [expr $x+1] }
 371             -re "^ +\[0-9\]+ 000b\[^\n\]*\n"    { set x [expr $x+1] }
 372             -re "^ +\[0-9\]+ 0011 F006\[^\n\]*\n"       { set x [expr $x+1] }
 373             -re "^ +\[0-9\]+ 0013 F82608\[^\n\]*\n"     { set x [expr $x+1] }
 374             -re "^ +\[0-9\]+ 0016 FA260100 \[^\n\]*\n"  { set x [expr $x+1] }
 375             -re "^ +\[0-9\]+ 001a\[^\n\]*\n"    { set x [expr $x+1] }
 376             -re "^ +\[0-9\]+ 0020 5D08\[^\n\]*\n"       { set x [expr $x+1] }
 377             -re "^ +\[0-9\]+ 0022 FAB10100\[^\n\]*\n"   { set x [expr $x+1] }
 378             -re "^ +\[0-9\]+ 0026\[^\n\]*\n"    { set x [expr $x+1] }
 379             -re "^ +\[0-9\]+ 002c\[^\n\]*\n"    { set x [expr $x+1] }
 380             -re "^ +\[0-9\]+ 002e FAA18000\[^\n\]*\n"   { set x [expr $x+1] }
 381             -re "^ +\[0-9\]+ 0032\[^\n\]*\n"    { set x [expr $x+1] }
 382             -re "^ +\[0-9\]+ 0038 F8F120\[^\n\]*\n"     { set x [expr $x+1] }
 383             -re "\[^\n\]*\n"                            { }
 384             timeout                             { perror "timeout\n"; break }
 385             eof                                 { break }
 386         }
 387     }
 388
 389     # This was intended to do any cleanup necessary.  It kinda looks like it
 390     # isn't needed, but just in case, please keep it in for now.
 391     gas_finish
 392
 393     # Did we find what we were looking for?  If not, flunk it.
 394     if [expr $x==15] then { pass $testname } else { fail $testname }
 395 }
 396
 397 proc do_mov3 {} {
 398     set testname "mov3.s: mov3 tests"
 399     set x 0
 400
 401     gas_start "mov3.s" "-al"
 402
 403     # Instead of having a variable for each match string just increment the
 404     # total number of matches seen.  That's simpler when testing large numbers
 405     # of instructions (as these tests to).
 406     while 1 {
 407         expect {
 408             -re "^ +\[0-9\]+ 0000 66\[^\n\]*\n" { set x [expr $x+1] }
 409             -re "^ +\[0-9\]+ 0001 F81620\[^\n\]*\n"     { set x [expr $x+1] }
 410             -re "^ +\[0-9\]+ 0004 FA160100\[^\n\]*\n"   { set x [expr $x+1] }
 411             -re "^ +\[0-9\]+ 0008\[^\n\]*\n"    { set x [expr $x+1] }
 412             -re "^ +\[0-9\]+ 000e 4620\[^\n\]*\n"       { set x [expr $x+1] }
 413             -re "^ +\[0-9\]+ 0010 FA958000\[^\n\]*\n"   { set x [expr $x+1] }
 414             -re "^ +\[0-9\]+ 0014\[^\n\]*\n"    { set x [expr $x+1] }
 415             -re "^ +\[0-9\]+ 001a\[^\n\]*\n"    { set x [expr $x+1] }
 416             -re "^ +\[0-9\]+ 001c 050080\[^\n\]*\n"     { set x [expr $x+1] }
 417             -re "^ +\[0-9\]+ 001f\[^\n\]*\n"    { set x [expr $x+1] }
 418             -re "^ +\[0-9\]+ 0025 F016\[^\n\]*\n"       { set x [expr $x+1] }
 419             -re "^ +\[0-9\]+ 0027 F83620\[^\n\]*\n"     { set x [expr $x+1] }
 420             -re "^ +\[0-9\]+ 002a FA360100\[^\n\]*\n"   { set x [expr $x+1] }
 421             -re "^ +\[0-9\]+ 002e\[^\n\]*\n"    { set x [expr $x+1] }
 422             -re "^ +\[0-9\]+ 0034 4720\[^\n\]*\n"       { set x [expr $x+1] }
 423             -re "\[^\n\]*\n"                            { }
 424             timeout                             { perror "timeout\n"; break }
 425             eof                                 { break }
 426         }
 427     }
 428
 429     # This was intended to do any cleanup necessary.  It kinda looks like it
 430     # isn't needed, but just in case, please keep it in for now.
 431     gas_finish
 432
 433     # Did we find what we were looking for?  If not, flunk it.
 434     if [expr $x==15] then { pass $testname } else { fail $testname }
 435 }
 436
 437 proc do_mov4 {} {
 438     set testname "mov4.s: mov4 tests"
 439     set x 0
 440
 441     gas_start "mov4.s" "-al"
 442
 443     # Instead of having a variable for each match string just increment the
 444     # total number of matches seen.  That's simpler when testing large numbers
 445     # of instructions (as these tests to).
 446     while 1 {
 447         expect {
 448             -re "^ +\[0-9\]+ 0000 FA948000\[^\n\]*\n"   { set x [expr $x+1] }
 449             -re "^ +\[0-9\]+ 0004\[^\n\]*\n"    { set x [expr $x+1] }
 450             -re "^ +\[0-9\]+ 000a\[^\n\]*\n"    { set x [expr $x+1] }
 451             -re "^ +\[0-9\]+ 000c FA840080\[^\n\]*\n"   { set x [expr $x+1] }
 452             -re "^ +\[0-9\]+ 0010\[^\n\]*\n"    { set x [expr $x+1] }
 453             -re "^ +\[0-9\]+ 0016 F8F520\[^\n\]*\n"     { set x [expr $x+1] }
 454             -re "^ +\[0-9\]+ 0019 8508\[^\n\]*\n"       { set x [expr $x+1] }
 455             -re "^ +\[0-9\]+ 001b 2D0100\[^\n\]*\n"     { set x [expr $x+1] }
 456             -re "^ +\[0-9\]+ 001e\[^\n\]*\n"    { set x [expr $x+1] }
 457             -re "^ +\[0-9\]+ 0024 9508\[^\n\]*\n"       { set x [expr $x+1] }
 458             -re "^ +\[0-9\]+ 0026 250100\[^\n\]*\n"     { set x [expr $x+1] }
 459             -re "^ +\[0-9\]+ 0029\[^\n\]*\n"    { set x [expr $x+1] }
 460             -re "\[^\n\]*\n"                            { }
 461             timeout                             { perror "timeout\n"; break }
 462             eof                                 { break }
 463         }
 464     }
 465
 466     # This was intended to do any cleanup necessary.  It kinda looks like it
 467     # isn't needed, but just in case, please keep it in for now.
 468     gas_finish
 469
 470     # Did we find what we were looking for?  If not, flunk it.
 471     if [expr $x==12] then { pass $testname } else { fail $testname }
 472 }
 473
 474 proc do_movbu {} {
 475     set testname "movbu.s: movbu tests"
 476     set x 0
 477
 478     gas_start "movbu.s" "-al"
 479
 480     # Instead of having a variable for each match string just increment the
 481     # total number of matches seen.  That's simpler when testing large numbers
 482     # of instructions (as these tests to).
 483     while 1 {
 484         expect {
 485             -re "^ +\[0-9\]+ 0000 F046\[^\n\]*\n"       { set x [expr $x+1] }
 486             -re "^ +\[0-9\]+ 0002 F84608\[^\n\]*\n"     { set x [expr $x+1] }
 487             -re "^ +\[0-9\]+ 0005 FA460100\[^\n\]*\n"   { set x [expr $x+1] }
 488             -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
 489             -re "^ +\[0-9\]+ 000f F8B908\[^\n\]*\n"     { set x [expr $x+1] }
 490             -re "^ +\[0-9\]+ 0012 FAB90100\[^\n\]*\n"   { set x [expr $x+1] }
 491             -re "^ +\[0-9\]+ 0016\[^\n\]*\n"    { set x [expr $x+1] }
 492             -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
 493             -re "^ +\[0-9\]+ 001e 358000\[^\n\]*\n"     { set x [expr $x+1] }
 494             -re "^ +\[0-9\]+ 0021\[^\n\]*\n"    { set x [expr $x+1] }
 495             -re "^ +\[0-9\]+ 0027 F056\[^\n\]*\n"       { set x [expr $x+1] }
 496             -re "^ +\[0-9\]+ 0029 F85620\[^\n\]*\n"     { set x [expr $x+1] }
 497             -re "^ +\[0-9\]+ 002c FA560100\[^\n\]*\n"   { set x [expr $x+1] }
 498             -re "^ +\[0-9\]+ 0030\[^\n\]*\n"    { set x [expr $x+1] }
 499             -re "^ +\[0-9\]+ 0036 F89620\[^\n\]*\n"     { set x [expr $x+1] }
 500             -re "^ +\[0-9\]+ 0039 FA968000\[^\n\]*\n"   { set x [expr $x+1] }
 501             -re "^ +\[0-9\]+ 003d\[^\n\]*\n"    { set x [expr $x+1] }
 502             -re "^ +\[0-9\]+ 0043\[^\n\]*\n"    { set x [expr $x+1] }
 503             -re "^ +\[0-9\]+ 0045 060080\[^\n\]*\n"     { set x [expr $x+1] }
 504             -re "^ +\[0-9\]+ 0048\[^\n\]*\n"    { set x [expr $x+1] }
 505             -re "\[^\n\]*\n"                            { }
 506             timeout                             { perror "timeout\n"; break }
 507             eof                                 { break }
 508         }
 509     }
 510
 511     # This was intended to do any cleanup necessary.  It kinda looks like it
 512     # isn't needed, but just in case, please keep it in for now.
 513     gas_finish
 514
 515     # Did we find what we were looking for?  If not, flunk it.
 516     if [expr $x==20] then { pass $testname } else { fail $testname }
 517 }
 518
 519 proc do_movhu {} {
 520     set testname "movhu.s: movhu tests"
 521     set x 0
 522
 523     gas_start "movhu.s" "-al"
 524
 525     # Instead of having a variable for each match string just increment the
 526     # total number of matches seen.  That's simpler when testing large numbers
 527     # of instructions (as these tests to).
 528     while 1 {
 529         expect {
 530             -re "^ +\[0-9\]+ 0000 F066\[^\n\]*\n"       { set x [expr $x+1] }
 531             -re "^ +\[0-9\]+ 0002 F86608\[^\n\]*\n"     { set x [expr $x+1] }
 532             -re "^ +\[0-9\]+ 0005 FA660100\[^\n\]*\n"   { set x [expr $x+1] }
 533             -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
 534             -re "^ +\[0-9\]+ 000f F8BD08\[^\n\]*\n"     { set x [expr $x+1] }
 535             -re "^ +\[0-9\]+ 0012 FABD0100\[^\n\]*\n"   { set x [expr $x+1] }
 536             -re "^ +\[0-9\]+ 0016\[^\n\]*\n"    { set x [expr $x+1] }
 537             -re "^ +\[0-9\]+ 001c\[^\n\]*\n"    { set x [expr $x+1] }
 538             -re "^ +\[0-9\]+ 001e 398000\[^\n\]*\n"     { set x [expr $x+1] }
 539             -re "^ +\[0-9\]+ 0021\[^\n\]*\n"    { set x [expr $x+1] }
 540             -re "^ +\[0-9\]+ 0027 F076\[^\n\]*\n"       { set x [expr $x+1] }
 541             -re "^ +\[0-9\]+ 0029 F87620\[^\n\]*\n"     { set x [expr $x+1] }
 542             -re "^ +\[0-9\]+ 002c FA760100\[^\n\]*\n"   { set x [expr $x+1] }
 543             -re "^ +\[0-9\]+ 0030\[^\n\]*\n"    { set x [expr $x+1] }
 544             -re "^ +\[0-9\]+ 0036 F89720\[^\n\]*\n"     { set x [expr $x+1] }
 545             -re "^ +\[0-9\]+ 0039 FA978000\[^\n\]*\n"   { set x [expr $x+1] }
 546             -re "^ +\[0-9\]+ 003d\[^\n\]*\n"    { set x [expr $x+1] }
 547             -re "^ +\[0-9\]+ 0043\[^\n\]*\n"    { set x [expr $x+1] }
 548             -re "^ +\[0-9\]+ 0045 070080\[^\n\]*\n"     { set x [expr $x+1] }
 549             -re "^ +\[0-9\]+ 0048\[^\n\]*\n"    { set x [expr $x+1] }
 550             -re "\[^\n\]*\n"                            { }
 551             timeout                             { perror "timeout\n"; break }
 552             eof                                 { break }
 553         }
 554     }
 555
 556     # This was intended to do any cleanup necessary.  It kinda looks like it
 557     # isn't needed, but just in case, please keep it in for now.
 558     gas_finish
 559
 560     # Did we find what we were looking for?  If not, flunk it.
 561     if [expr $x==20] then { pass $testname } else { fail $testname }
 562 }
 563
 564 proc do_movm {} {
 565     set testname "movm.s: movm tests"
 566     set x 0
 567
 568     gas_start "movm.s" "-al"
 569
 570     # Instead of having a variable for each match string just increment the
 571     # total number of matches seen.  That's simpler when testing large numbers
 572     # of instructions (as these tests to).
 573     while 1 {
 574         expect {
 575             -re "^ +\[0-9\]+ 0000 CE00\[^\n\]*\n"       { set x [expr $x+1] }
 576             -re "^ +\[0-9\]+ 0002 CE0B\[^\n\]*\n"       { set x [expr $x+1] }
 577             -re "^ +\[0-9\]+ 0004 CF00\[^\n\]*\n"       { set x [expr $x+1] }
 578             -re "^ +\[0-9\]+ 0006 CF0B\[^\n\]*\n"       { set x [expr $x+1] }
 579             -re "\[^\n\]*\n"                            { }
 580             timeout                             { perror "timeout\n"; break }
 581             eof                                 { break }
 582         }
 583     }
 584
 585     # This was intended to do any cleanup necessary.  It kinda looks like it
 586     # isn't needed, but just in case, please keep it in for now.
 587     gas_finish
 588
 589     # Did we find what we were looking for?  If not, flunk it.
 590     if [expr $x==4] then { pass $testname } else { fail $testname }
 591 }
 592
 593 proc do_muldiv {} {
 594     set testname "muldiv.s: muldiv tests"
 595     set x 0
 596
 597     gas_start "muldiv.s" "-al"
 598
 599     # Instead of having a variable for each match string just increment the
 600     # total number of matches seen.  That's simpler when testing large numbers
 601     # of instructions (as these tests to).
 602     while 1 {
 603         expect {
 604             -re "^ +\[0-9\]+ 0000 F246\[^\n\]*\n"       { set x [expr $x+1] }
 605             -re "^ +\[0-9\]+ 0002 F25B\[^\n\]*\n"       { set x [expr $x+1] }
 606             -re "^ +\[0-9\]+ 0004 F26F\[^\n\]*\n"       { set x [expr $x+1] }
 607             -re "^ +\[0-9\]+ 0006 F27E\[^\n\]*\n"       { set x [expr $x+1] }
 608             -re "\[^\n\]*\n"                            { }
 609             timeout                             { perror "timeout\n"; break }
 610             eof                                 { break }
 611         }
 612     }
 613
 614     # This was intended to do any cleanup necessary.  It kinda looks like it
 615     # isn't needed, but just in case, please keep it in for now.
 616     gas_finish
 617
 618     # Did we find what we were looking for?  If not, flunk it.
 619     if [expr $x==4] then { pass $testname } else { fail $testname }
 620 }
 621
 622 proc do_other {} {
 623     set testname "other.s: other tests"
 624     set x 0
 625
 626     gas_start "other.s" "-al"
 627
 628     # Instead of having a variable for each match string just increment the
 629     # total number of matches seen.  That's simpler when testing large numbers
 630     # of instructions (as these tests to).
 631     while 1 {
 632         expect {
 633             -re "^ +\[0-9\]+ 0000 08\[^\n\]*\n" { set x [expr $x+1] }
 634             -re "^ +\[0-9\]+ 0001 44\[^\n\]*\n" { set x [expr $x+1] }
 635             -re "^ +\[0-9\]+ 0002 49\[^\n\]*\n" { set x [expr $x+1] }
 636             -re "^ +\[0-9\]+ 0003 53\[^\n\]*\n" { set x [expr $x+1] }
 637             -re "^ +\[0-9\]+ 0004 F0F6\[^\n\]*\n"       { set x [expr $x+1] }
 638             -re "^ +\[0-9\]+ 0006 CC0100\[^\n\]*\n"     { set x [expr $x+1] }
 639             -re "^ +\[0-9\]+ 0009\[^\n\]*\n"    { set x [expr $x+1] }
 640             -re "^ +\[0-9\]+ 000e\[^\n\]*\n"    { set x [expr $x+1] }
 641             -re "^ +\[0-9\]+ 0013\[^\n\]*\n"    { set x [expr $x+1] }
 642             -re "^ +\[0-9\]+ 001a F0F2\[^\n\]*\n"       { set x [expr $x+1] }
 643             -re "^ +\[0-9\]+ 001c FAFF0100\[^\n\]*\n"   { set x [expr $x+1] }
 644             -re "^ +\[0-9\]+ 0020\[^\n\]*\n"    { set x [expr $x+1] }
 645             -re "^ +\[0-9\]+ 0026\[^\n\]*\n"    { set x [expr $x+1] }
 646             -re "^ +\[0-9\]+ 0029\[^\n\]*\n"    { set x [expr $x+1] }
 647             -re "^ +\[0-9\]+ 002c F0FC\[^\n\]*\n"       { set x [expr $x+1] }
 648             -re "^ +\[0-9\]+ 002e F0FD\[^\n\]*\n"       { set x [expr $x+1] }
 649             -re "^ +\[0-9\]+ 0030 F0FE\[^\n\]*\n"       { set x [expr $x+1] }
 650             -re "^ +\[0-9\]+ 0032 CB\[^\n\]*\n" { set x [expr $x+1] }
 651             -re "^ +\[0-9\]+ 0033 F0FF\[^\n\]*\n"       { set x [expr $x+1] }
 652             -re "\[^\n\]*\n"                            { }
 653             timeout                             { perror "timeout\n"; break }
 654             eof                                 { break }
 655         }
 656     }
 657
 658     # This was intended to do any cleanup necessary.  It kinda looks like it
 659     # isn't needed, but just in case, please keep it in for now.
 660     gas_finish
 661
 662     # Did we find what we were looking for?  If not, flunk it.
 663     if [expr $x==19] then { pass $testname } else { fail $testname }
 664 }
 665
 666 proc do_shift {} {
 667     set testname "shift.s: shift tests"
 668     set x 0
 669
 670     gas_start "shift.s" "-al"
 671
 672     # Instead of having a variable for each match string just increment the
 673     # total number of matches seen.  That's simpler when testing large numbers
 674     # of instructions (as these tests to).
 675     while 1 {
 676         expect {
 677             -re "^ +\[0-9\]+ 0000 F2B6\[^\n\]*\n"       { set x [expr $x+1] }
 678             -re "^ +\[0-9\]+ 0002 F8CA04\[^\n\]*\n"     { set x [expr $x+1] }
 679             -re "^ +\[0-9\]+ 0005 F2AB\[^\n\]*\n"       { set x [expr $x+1] }
 680             -re "^ +\[0-9\]+ 0007 F8C704\[^\n\]*\n"     { set x [expr $x+1] }
 681             -re "^ +\[0-9\]+ 000a F29E\[^\n\]*\n"       { set x [expr $x+1] }
 682             -re "^ +\[0-9\]+ 000c F8C204\[^\n\]*\n"     { set x [expr $x+1] }
 683             -re "^ +\[0-9\]+ 000f 56\[^\n\]*\n" { set x [expr $x+1] }
 684             -re "^ +\[0-9\]+ 0010 F285\[^\n\]*\n"       { set x [expr $x+1] }
 685             -re "^ +\[0-9\]+ 0012 F282\[^\n\]*\n"       { set x [expr $x+1] }
 686             -re "\[^\n\]*\n"                            { }
 687             timeout                             { perror "timeout\n"; break }
 688             eof                                 { break }
 689         }
 690     }
 691
 692     # This was intended to do any cleanup necessary.  It kinda looks like it
 693     # isn't needed, but just in case, please keep it in for now.
 694     gas_finish
 695
 696     # Did we find what we were looking for?  If not, flunk it.
 697     if [expr $x==9] then { pass $testname } else { fail $testname }
 698 }
 699
 700 proc do_sub {} {
 701     set testname "sub.s: sub tests"
 702     set x 0
 703
 704     gas_start "sub.s" "-al"
 705
 706     # Instead of having a variable for each match string just increment the
 707     # total number of matches seen.  That's simpler when testing large numbers
 708     # of instructions (as these tests to).
 709     while 1 {
 710         expect {
 711             -re "^ +\[0-9\]+ 0000 F106\[^\n\]*\n"       { set x [expr $x+1] }
 712             -re "^ +\[0-9\]+ 0002 F12B\[^\n\]*\n"       { set x [expr $x+1] }
 713             -re "^ +\[0-9\]+ 0004 F11F\[^\n\]*\n"       { set x [expr $x+1] }
 714             -re "^ +\[0-9\]+ 0006 F13E\[^\n\]*\n"       { set x [expr $x+1] }
 715             -re "^ +\[0-9\]+ 0008\[^\n\]*\n"    { set x [expr $x+1] }
 716             -re "^ +\[0-9\]+ 000e\[^\n\]*\n"    { set x [expr $x+1] }
 717             -re "^ +\[0-9\]+ 0014 F186\[^\n\]*\n"       { set x [expr $x+1] }
 718             -re "\[^\n\]*\n"                            { }
 719             timeout                             { perror "timeout\n"; break }
 720             eof                                 { break }
 721         }
 722     }
 723
 724     # This was intended to do any cleanup necessary.  It kinda looks like it
 725     # isn't needed, but just in case, please keep it in for now.
 726     gas_finish
 727
 728     # Did we find what we were looking for?  If not, flunk it.
 729     if [expr $x==7] then { pass $testname } else { fail $testname }
 730 }
 731
 732 if [istarget mn10300*-*-*] then {
 733     # Test the basic instruction parser.
 734     do_add
 735     do_bcc
 736     do_bit
 737     do_cmp
 738     do_ext
 739     do_extend
 740     do_logical
 741     do_loop
 742     do_mov1
 743     do_mov2
 744     do_mov3
 745     do_mov4
 746     do_movbu
 747     do_movhu
 748     do_movm
 749     do_muldiv
 750     do_other
 751     do_shift
 752     do_sub
 753 }