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 FAC20001\[^\n\]*\n"   { set x [expr $x+1] }
  39             -re "^ +\[0-9\]+ 000d FCC3FFFF\[^\n\]*\n"   { set x [expr $x+1] }
  40             -re "^ +8 +0100\[^\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 FAD20001\[^\n\]*\n"   { set x [expr $x+1] }
  43             -re "^ +\[0-9\]+ 0019 FCD3FFFF\[^\n\]*\n"   { set x [expr $x+1] }
  44             -re "^ +11 +0100\[^\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 FAFE0001\[^\n\]*\n"   { set x [expr $x+1] }
  47             -re "^ +\[0-9\]+ 0026 FCFEFFFF\[^\n\]*\n"   { set x [expr $x+1] }
  48             -re "^ +14 +0100\[^\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 FAEE0020\[^\n\]*\n"   { set x [expr $x+1] }
 117             -re "^ +\[0-9\]+ 0007 FCEFFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 118             -re "^ +4 +0100\[^\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 FE02FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 121             -re "^ +6 +010040\[^\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 FE00FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 125             -re "^ +9 +010040\[^\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 FE01FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 129             -re "^ +12 +010040\[^\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 FACA0001\[^\n\]*\n"   { set x [expr $x+1] }
 161             -re "^ +\[0-9\]+ 000c FCC9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 162             -re "^ +8 +0100\[^\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 FADA0001\[^\n\]*\n"   { set x [expr $x+1] }
 165             -re "^ +\[0-9\]+ 0018 FCD9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 166             -re "^ +11 +0100\[^\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 F505\[^\n\]*\n"       { set x [expr $x+1] }
 223             -re "^ +\[0-9\]+ 0002 F6FA\[^\n\]*\n"       { set x [expr $x+1] }
 224             -re "^ +\[0-9\]+ 0004 F606\[^\n\]*\n"       { set x [expr $x+1] }
 225             -re "^ +\[0-9\]+ 0006 F90210\[^\n\]*\n"     { set x [expr $x+1] }
 226             -re "^ +\[0-9\]+ 0009 FB030001\[^\n\]*\n"   { set x [expr $x+1] }
 227             -re "^ +\[0-9\]+ 000d FD03FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 228             -re "^ +7 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 229             -re "^ +\[0-9\]+ 0013 F616\[^\n\]*\n"       { set x [expr $x+1] }
 230             -re "^ +\[0-9\]+ 0015 F91610\[^\n\]*\n"     { set x [expr $x+1] }
 231             -re "^ +\[0-9\]+ 0018 FB170001\[^\n\]*\n"   { set x [expr $x+1] }
 232             -re "^ +\[0-9\]+ 001c FD17FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 233             -re "^ +11 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 234             -re "^ +\[0-9\]+ 0022 F64B\[^\n\]*\n"       { set x [expr $x+1] }
 235             -re "^ +\[0-9\]+ 0024 F65E\[^\n\]*\n"       { set x [expr $x+1] }
 236             -re "^ +\[0-9\]+ 0026 F676\[^\n\]*\n"       { set x [expr $x+1] }
 237             -re "\[^\n\]*\n"                            { }
 238             timeout                             { perror "timeout\n"; break }
 239             eof                                 { break }
 240         }
 241     }
 242
 243     # This was intended to do any cleanup necessary.  It kinda looks like it
 244     # isn't needed, but just in case, please keep it in for now.
 245     gas_finish
 246
 247     # Did we find what we were looking for?  If not, flunk it.
 248     if [expr $x==15] then { pass $testname } else { fail $testname }
 249 }
 250
 251 proc do_logical {} {
 252     set testname "logical.s: logical tests"
 253     set x 0
 254
 255     gas_start "logical.s" "-al"
 256
 257     # Instead of having a variable for each match string just increment the
 258     # total number of matches seen.  That's simpler when testing large numbers
 259     # of instructions (as these tests to).
 260     while 1 {
 261         expect {
 262             -re "^ +\[0-9\]+ 0000 F206\[^\n\]*\n"       { set x [expr $x+1] }
 263             -re "^ +\[0-9\]+ 0002 F8E27F\[^\n\]*\n"     { set x [expr $x+1] }
 264             -re "^ +\[0-9\]+ 0005 FAE3FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 265             -re "^ +\[0-9\]+ 0009 FCE3FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 266             -re "^ +5 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 267             -re "^ +\[0-9\]+ 000f FAFCFF7F\[^\n\]*\n"   { set x [expr $x+1] }
 268             -re "^ +\[0-9\]+ 0013 F216\[^\n\]*\n"       { set x [expr $x+1] }
 269             -re "^ +\[0-9\]+ 0015 F8E67F\[^\n\]*\n"     { set x [expr $x+1] }
 270             -re "^ +\[0-9\]+ 0018 FAE7FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 271             -re "^ +\[0-9\]+ 001c FCE7FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 272             -re "^ +10 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 273             -re "^ +\[0-9\]+ 0022 FAFDFF7F\[^\n\]*\n"   { set x [expr $x+1] }
 274             -re "^ +\[0-9\]+ 0026 F226\[^\n\]*\n"       { set x [expr $x+1] }
 275             -re "^ +\[0-9\]+ 0028 FAEBFF7F\[^\n\]*\n"   { set x [expr $x+1] }
 276             -re "^ +\[0-9\]+ 002c FCEBFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 277             -re "^ +14 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 278             -re "^ +\[0-9\]+ 0032 F233\[^\n\]*\n"       { set x [expr $x+1] }
 279             -re "^\[^\n\]*\n"                           { }
 280             timeout                             { perror "timeout\n"; break }
 281             eof                                 { break }
 282         }
 283     }
 284
 285     # This was intended to do any cleanup necessary.  It kinda looks like it
 286     # isn't needed, but just in case, please keep it in for now.
 287     gas_finish
 288
 289     # Did we find what we were looking for?  If not, flunk it.
 290     if [expr $x==17] then { pass $testname } else { fail $testname }
 291 }
 292
 293 proc do_loop {} {
 294     set testname "loop.s: loop tests"
 295     set x 0
 296
 297     gas_start "loop.s" "-al"
 298
 299     # Instead of having a variable for each match string just increment the
 300     # total number of matches seen.  That's simpler when testing large numbers
 301     # of instructions (as these tests to).
 302     while 1 {
 303         expect {
 304             -re "^ +\[0-9\]+ 0000 D8\[^\n\]*\n"         { set x [expr $x+1] }
 305             -re "^ +\[0-9\]+ 0001 D9\[^\n\]*\n"         { set x [expr $x+1] }
 306             -re "^ +\[0-9\]+ 0002 D1\[^\n\]*\n"         { set x [expr $x+1] }
 307             -re "^ +\[0-9\]+ 0003 D2\[^\n\]*\n"         { set x [expr $x+1] }
 308             -re "^ +\[0-9\]+ 0004 D3\[^\n\]*\n"         { set x [expr $x+1] }
 309             -re "^ +\[0-9\]+ 0005 D0\[^\n\]*\n"         { set x [expr $x+1] }
 310             -re "^ +\[0-9\]+ 0006 D5\[^\n\]*\n"         { set x [expr $x+1] }
 311             -re "^ +\[0-9\]+ 0007 D6\[^\n\]*\n"         { set x [expr $x+1] }
 312             -re "^ +\[0-9\]+ 0008 D7\[^\n\]*\n"         { set x [expr $x+1] }
 313             -re "^ +\[0-9\]+ 0009 D4\[^\n\]*\n"         { set x [expr $x+1] }
 314             -re "^ +\[0-9\]+ 000a DA\[^\n\]*\n"         { set x [expr $x+1] }
 315             -re "^ +\[0-9\]+ 000b DB\[^\n\]*\n"         { set x [expr $x+1] }
 316             -re "\[^\n\]*\n"                            { }
 317             timeout                             { perror "timeout\n"; break }
 318             eof                                 { break }
 319         }
 320     }
 321
 322     # This was intended to do any cleanup necessary.  It kinda looks like it
 323     # isn't needed, but just in case, please keep it in for now.
 324     gas_finish
 325
 326     # Did we find what we were looking for?  If not, flunk it.
 327     if [expr $x==12] then { pass $testname } else { fail $testname }
 328 }
 329
 330 proc do_mov1 {} {
 331     set testname "mov1.s: mov1 tests"
 332     set x 0
 333
 334     gas_start "mov1.s" "-al"
 335
 336     # Instead of having a variable for each match string just increment the
 337     # total number of matches seen.  That's simpler when testing large numbers
 338     # of instructions (as these tests to).
 339     while 1 {
 340         expect {
 341             -re "^ +\[0-9\]+ 0000 86\[^\n\]*\n"         { set x [expr $x+1] }
 342             -re "^ +\[0-9\]+ 0001 F1E6\[^\n\]*\n"       { set x [expr $x+1] }
 343             -re "^ +\[0-9\]+ 0003 F1D9\[^\n\]*\n"       { set x [expr $x+1] }
 344             -re "^ +\[0-9\]+ 0005 99\[^\n\]*\n"         { set x [expr $x+1] }
 345             -re "^ +\[0-9\]+ 0006 3E\[^\n\]*\n"         { set x [expr $x+1] }
 346             -re "^ +\[0-9\]+ 0007 F2F4\[^\n\]*\n"       { set x [expr $x+1] }
 347             -re "^ +\[0-9\]+ 0009 F2FB\[^\n\]*\n"       { set x [expr $x+1] }
 348             -re "^ +\[0-9\]+ 000b F2E1\[^\n\]*\n"       { set x [expr $x+1] }
 349             -re "^ +\[0-9\]+ 000d F2FA\[^\n\]*\n"       { set x [expr $x+1] }
 350             -re "^ +\[0-9\]+ 000f 76\[^\n\]*\n"         { set x [expr $x+1] }
 351             -re "^ +\[0-9\]+ 0010 F80608\[^\n\]*\n"     { set x [expr $x+1] }
 352             -re "^ +\[0-9\]+ 0013 FA060001\[^\n\]*\n"   { set x [expr $x+1] }
 353             -re "^ +\[0-9\]+ 0017 FC06FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 354             -re "^ +14 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 355             -re "^ +\[0-9\]+ 001d 5908\[^\n\]*\n"       { set x [expr $x+1] }
 356             -re "^ +\[0-9\]+ 001f FAB50001\[^\n\]*\n"   { set x [expr $x+1] }
 357             -re "^ +\[0-9\]+ 0023 F2E7\[^\n\]*\n"       { set x [expr $x+1] }
 358             -re "\[^\n\]*\n"                            { }
 359             timeout                             { perror "timeout\n"; break }
 360             eof                                 { break }
 361         }
 362     }
 363
 364     # This was intended to do any cleanup necessary.  It kinda looks like it
 365     # isn't needed, but just in case, please keep it in for now.
 366     gas_finish
 367
 368     # Did we find what we were looking for?  If not, flunk it.
 369     if [expr $x==17] then { pass $testname } else { fail $testname }
 370 }
 371
 372 proc do_mov2 {} {
 373     set testname "mov2.s: mov2 tests"
 374     set x 0
 375
 376     gas_start "mov2.s" "-al"
 377
 378     # Instead of having a variable for each match string just increment the
 379     # total number of matches seen.  That's simpler when testing large numbers
 380     # of instructions (as these tests to).
 381     while 1 {
 382         expect {
 383             -re "^ +\[0-9\]+ 0000 FCB5FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 384             -re "^ +2 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 385             -re "^ +\[0-9\]+ 0006 F325\[^\n\]*\n"       { set x [expr $x+1] }
 386             -re "^ +\[0-9\]+ 0008 310080\[^\n\]*\n"     { set x [expr $x+1] }
 387             -re "^ +\[0-9\]+ 000b FCA5FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 388             -re "^ +5 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 389             -re "^ +\[0-9\]+ 0011 F006\[^\n\]*\n"       { set x [expr $x+1] }
 390             -re "^ +\[0-9\]+ 0013 F82608\[^\n\]*\n"     { set x [expr $x+1] }
 391             -re "^ +\[0-9\]+ 0016 FA260001 \[^\n\]*\n"  { set x [expr $x+1] }
 392             -re "^ +\[0-9\]+ 001a FC26FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 393             -re "^ +9 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 394             -re "^ +\[0-9\]+ 0020 5D08\[^\n\]*\n"       { set x [expr $x+1] }
 395             -re "^ +\[0-9\]+ 0022 FAB10001\[^\n\]*\n"   { set x [expr $x+1] }
 396             -re "^ +\[0-9\]+ 0026 FCB1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 397             -re "^ +12 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 398             -re "^ +\[0-9\]+ 002c F3A5\[^\n\]*\n"       { set x [expr $x+1] }
 399             -re "^ +\[0-9\]+ 002e FAA10080\[^\n\]*\n"   { set x [expr $x+1] }
 400             -re "^ +\[0-9\]+ 0032 FCA1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 401             -re "^ +15 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 402             -re "^ +\[0-9\]+ 0038 F8F120\[^\n\]*\n"     { set x [expr $x+1] }
 403             -re "\[^\n\]*\n"                            { }
 404             timeout                             { perror "timeout\n"; break }
 405             eof                                 { break }
 406         }
 407     }
 408
 409     # This was intended to do any cleanup necessary.  It kinda looks like it
 410     # isn't needed, but just in case, please keep it in for now.
 411     gas_finish
 412
 413     # Did we find what we were looking for?  If not, flunk it.
 414     if [expr $x==20] then { pass $testname } else { fail $testname }
 415 }
 416
 417 proc do_mov3 {} {
 418     set testname "mov3.s: mov3 tests"
 419     set x 0
 420
 421     gas_start "mov3.s" "-al"
 422
 423     # Instead of having a variable for each match string just increment the
 424     # total number of matches seen.  That's simpler when testing large numbers
 425     # of instructions (as these tests to).
 426     while 1 {
 427         expect {
 428             -re "^ +\[0-9\]+ 0000 66\[^\n\]*\n" { set x [expr $x+1] }
 429             -re "^ +\[0-9\]+ 0001 F81620\[^\n\]*\n"     { set x [expr $x+1] }
 430             -re "^ +\[0-9\]+ 0004 FA160001\[^\n\]*\n"   { set x [expr $x+1] }
 431             -re "^ +\[0-9\]+ 0008 FC16FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 432             -re "^ +5 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 433             -re "^ +\[0-9\]+ 000e 4620\[^\n\]*\n"       { set x [expr $x+1] }
 434             -re "^ +\[0-9\]+ 0010 FA950080\[^\n\]*\n"   { set x [expr $x+1] }
 435             -re "^ +\[0-9\]+ 0014 FC95FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 436             -re "^ +8 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 437             -re "^ +\[0-9\]+ 001a F35A\[^\n\]*\n"       { set x [expr $x+1] }
 438             -re "^ +\[0-9\]+ 001c 058000\[^\n\]*\n"     { set x [expr $x+1] }
 439             -re "^ +\[0-9\]+ 001f FC85FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 440             -re "^ +11 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 441             -re "^ +\[0-9\]+ 0025 F016\[^\n\]*\n"       { set x [expr $x+1] }
 442             -re "^ +\[0-9\]+ 0027 F83620\[^\n\]*\n"     { set x [expr $x+1] }
 443             -re "^ +\[0-9\]+ 002a FA360001\[^\n\]*\n"   { set x [expr $x+1] }
 444             -re "^ +\[0-9\]+ 002e FC36FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 445             -re "^ +15 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 446             -re "^ +\[0-9\]+ 0034 4720\[^\n\]*\n"       { set x [expr $x+1] }
 447             -re "\[^\n\]*\n"                            { }
 448             timeout                             { perror "timeout\n"; break }
 449             eof                                 { break }
 450         }
 451     }
 452
 453     # This was intended to do any cleanup necessary.  It kinda looks like it
 454     # isn't needed, but just in case, please keep it in for now.
 455     gas_finish
 456
 457     # Did we find what we were looking for?  If not, flunk it.
 458     if [expr $x==19] then { pass $testname } else { fail $testname }
 459 }
 460
 461 proc do_mov4 {} {
 462     set testname "mov4.s: mov4 tests"
 463     set x 0
 464
 465     gas_start "mov4.s" "-al"
 466
 467     # Instead of having a variable for each match string just increment the
 468     # total number of matches seen.  That's simpler when testing large numbers
 469     # of instructions (as these tests to).
 470     while 1 {
 471         expect {
 472             -re "^ +\[0-9\]+ 0000 FA940080\[^\n\]*\n"   { set x [expr $x+1] }
 473             -re "^ +\[0-9\]+ 0004 FC94FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 474             -re "^ +3 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 475             -re "^ +\[0-9\]+ 000a F3DA\[^\n\]*\n"       { set x [expr $x+1] }
 476             -re "^ +\[0-9\]+ 000c FA848000\[^\n\]*\n"   { set x [expr $x+1] }
 477             -re "^ +\[0-9\]+ 0010 FC84FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 478             -re "^ +6 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 479             -re "^ +\[0-9\]+ 0016 F8F520\[^\n\]*\n"     { set x [expr $x+1] }
 480             -re "^ +\[0-9\]+ 0019 8508\[^\n\]*\n"       { set x [expr $x+1] }
 481             -re "^ +\[0-9\]+ 001b 2D0001\[^\n\]*\n"     { set x [expr $x+1] }
 482             -re "^ +\[0-9\]+ 001e FCCDFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 483             -re "^ +10 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 484             -re "^ +\[0-9\]+ 0024 9508\[^\n\]*\n"       { set x [expr $x+1] }
 485             -re "^ +\[0-9\]+ 0026 250001\[^\n\]*\n"     { set x [expr $x+1] }
 486             -re "^ +\[0-9\]+ 0029 FCDDFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 487             -re "^ +13 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 488             -re "\[^\n\]*\n"                            { }
 489             timeout                             { perror "timeout\n"; break }
 490             eof                                 { break }
 491         }
 492     }
 493
 494     # This was intended to do any cleanup necessary.  It kinda looks like it
 495     # isn't needed, but just in case, please keep it in for now.
 496     gas_finish
 497
 498     # Did we find what we were looking for?  If not, flunk it.
 499     if [expr $x==16] then { pass $testname } else { fail $testname }
 500 }
 501
 502 proc do_movbu {} {
 503     set testname "movbu.s: movbu tests"
 504     set x 0
 505
 506     gas_start "movbu.s" "-al"
 507
 508     # Instead of having a variable for each match string just increment the
 509     # total number of matches seen.  That's simpler when testing large numbers
 510     # of instructions (as these tests to).
 511     while 1 {
 512         expect {
 513             -re "^ +\[0-9\]+ 0000 F046\[^\n\]*\n"       { set x [expr $x+1] }
 514             -re "^ +\[0-9\]+ 0002 F84608\[^\n\]*\n"     { set x [expr $x+1] }
 515             -re "^ +\[0-9\]+ 0005 FA460001\[^\n\]*\n"   { set x [expr $x+1] }
 516             -re "^ +\[0-9\]+ 0009 FC46FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 517             -re "^ +5 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 518             -re "^ +\[0-9\]+ 000f F8B908\[^\n\]*\n"     { set x [expr $x+1] }
 519             -re "^ +\[0-9\]+ 0012 FAB90001\[^\n\]*\n"   { set x [expr $x+1] }
 520             -re "^ +\[0-9\]+ 0016 FCB9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 521             -re "^ +8 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 522             -re "^ +\[0-9\]+ 001c F425\[^\n\]*\n"       { set x [expr $x+1] }
 523             -re "^ +\[0-9\]+ 001e 350080\[^\n\]*\n"     { set x [expr $x+1] }
 524             -re "^ +\[0-9\]+ 0021 FCA9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 525             -re "^ +11 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 526             -re "^ +\[0-9\]+ 0027 F056\[^\n\]*\n"       { set x [expr $x+1] }
 527             -re "^ +\[0-9\]+ 0029 F85620\[^\n\]*\n"     { set x [expr $x+1] }
 528             -re "^ +\[0-9\]+ 002c FA560001\[^\n\]*\n"   { set x [expr $x+1] }
 529             -re "^ +\[0-9\]+ 0030 FC56FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 530             -re "^ +15 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 531             -re "^ +\[0-9\]+ 0036 F89620\[^\n\]*\n"     { set x [expr $x+1] }
 532             -re "^ +\[0-9\]+ 0039 FA960080\[^\n\]*\n"   { set x [expr $x+1] }
 533             -re "^ +\[0-9\]+ 003d FC96FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 534             -re "^ +18 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 535             -re "^ +\[0-9\]+ 0043 F45A\[^\n\]*\n"       { set x [expr $x+1] }
 536             -re "^ +\[0-9\]+ 0045 068000\[^\n\]*\n"     { set x [expr $x+1] }
 537             -re "^ +\[0-9\]+ 0048 FC86FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 538             -re "^ +21 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 539             -re "\[^\n\]*\n"                            { }
 540             timeout                             { perror "timeout\n"; break }
 541             eof                                 { break }
 542         }
 543     }
 544
 545     # This was intended to do any cleanup necessary.  It kinda looks like it
 546     # isn't needed, but just in case, please keep it in for now.
 547     gas_finish
 548
 549     # Did we find what we were looking for?  If not, flunk it.
 550     if [expr $x==26] then { pass $testname } else { fail $testname }
 551 }
 552
 553 proc do_movhu {} {
 554     set testname "movhu.s: movhu tests"
 555     set x 0
 556
 557     gas_start "movhu.s" "-al"
 558
 559     # Instead of having a variable for each match string just increment the
 560     # total number of matches seen.  That's simpler when testing large numbers
 561     # of instructions (as these tests to).
 562     while 1 {
 563         expect {
 564             -re "^ +\[0-9\]+ 0000 F066\[^\n\]*\n"       { set x [expr $x+1] }
 565             -re "^ +\[0-9\]+ 0002 F86608\[^\n\]*\n"     { set x [expr $x+1] }
 566             -re "^ +\[0-9\]+ 0005 FA660001\[^\n\]*\n"   { set x [expr $x+1] }
 567             -re "^ +\[0-9\]+ 0009 FC66FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 568             -re "^ +5 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 569             -re "^ +\[0-9\]+ 000f F8BD08\[^\n\]*\n"     { set x [expr $x+1] }
 570             -re "^ +\[0-9\]+ 0012 FABD0001\[^\n\]*\n"   { set x [expr $x+1] }
 571             -re "^ +\[0-9\]+ 0016 FCBDFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 572             -re "^ +8 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 573             -re "^ +\[0-9\]+ 001c F4A5\[^\n\]*\n"       { set x [expr $x+1] }
 574             -re "^ +\[0-9\]+ 001e 390080\[^\n\]*\n"     { set x [expr $x+1] }
 575             -re "^ +\[0-9\]+ 0021 FCADFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 576             -re "^ +11 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 577             -re "^ +\[0-9\]+ 0027 F076\[^\n\]*\n"       { set x [expr $x+1] }
 578             -re "^ +\[0-9\]+ 0029 F87620\[^\n\]*\n"     { set x [expr $x+1] }
 579             -re "^ +\[0-9\]+ 002c FA760001\[^\n\]*\n"   { set x [expr $x+1] }
 580             -re "^ +\[0-9\]+ 0030 FC76FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 581             -re "^ +15 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 582             -re "^ +\[0-9\]+ 0036 F89720\[^\n\]*\n"     { set x [expr $x+1] }
 583             -re "^ +\[0-9\]+ 0039 FA970080\[^\n\]*\n"   { set x [expr $x+1] }
 584             -re "^ +\[0-9\]+ 003d FC97FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 585             -re "^ +18 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 586             -re "^ +\[0-9\]+ 0043 F4DA\[^\n\]*\n"       { set x [expr $x+1] }
 587             -re "^ +\[0-9\]+ 0045 078000\[^\n\]*\n"     { set x [expr $x+1] }
 588             -re "^ +\[0-9\]+ 0048 FC87FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 589             -re "^ +21 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 590             -re "\[^\n\]*\n"                            { }
 591             timeout                             { perror "timeout\n"; break }
 592             eof                                 { break }
 593         }
 594     }
 595
 596     # This was intended to do any cleanup necessary.  It kinda looks like it
 597     # isn't needed, but just in case, please keep it in for now.
 598     gas_finish
 599
 600     # Did we find what we were looking for?  If not, flunk it.
 601     if [expr $x==26] then { pass $testname } else { fail $testname }
 602 }
 603
 604 proc do_movm {} {
 605     set testname "movm.s: movm tests"
 606     set x 0
 607
 608     gas_start "movm.s" "-al"
 609
 610     # Instead of having a variable for each match string just increment the
 611     # total number of matches seen.  That's simpler when testing large numbers
 612     # of instructions (as these tests to).
 613     while 1 {
 614         expect {
 615             -re "^ +\[0-9\]+ 0000 CE30\[^\n\]*\n"       { set x [expr $x+1] }
 616             -re "^ +\[0-9\]+ 0002 CEF8\[^\n\]*\n"       { set x [expr $x+1] }
 617             -re "^ +\[0-9\]+ 0004 CF30\[^\n\]*\n"       { set x [expr $x+1] }
 618             -re "^ +\[0-9\]+ 0006 CFF8\[^\n\]*\n"       { set x [expr $x+1] }
 619             -re "\[^\n\]*\n"                            { }
 620             timeout                             { perror "timeout\n"; break }
 621             eof                                 { break }
 622         }
 623     }
 624
 625     # This was intended to do any cleanup necessary.  It kinda looks like it
 626     # isn't needed, but just in case, please keep it in for now.
 627     gas_finish
 628
 629     # Did we find what we were looking for?  If not, flunk it.
 630     if [expr $x==4] then { pass $testname } else { fail $testname }
 631 }
 632
 633 proc do_muldiv {} {
 634     set testname "muldiv.s: muldiv tests"
 635     set x 0
 636
 637     gas_start "muldiv.s" "-al"
 638
 639     # Instead of having a variable for each match string just increment the
 640     # total number of matches seen.  That's simpler when testing large numbers
 641     # of instructions (as these tests to).
 642     while 1 {
 643         expect {
 644             -re "^ +\[0-9\]+ 0000 F246\[^\n\]*\n"       { set x [expr $x+1] }
 645             -re "^ +\[0-9\]+ 0002 F25B\[^\n\]*\n"       { set x [expr $x+1] }
 646             -re "^ +\[0-9\]+ 0004 F26F\[^\n\]*\n"       { set x [expr $x+1] }
 647             -re "^ +\[0-9\]+ 0006 F27E\[^\n\]*\n"       { set x [expr $x+1] }
 648             -re "\[^\n\]*\n"                            { }
 649             timeout                             { perror "timeout\n"; break }
 650             eof                                 { break }
 651         }
 652     }
 653
 654     # This was intended to do any cleanup necessary.  It kinda looks like it
 655     # isn't needed, but just in case, please keep it in for now.
 656     gas_finish
 657
 658     # Did we find what we were looking for?  If not, flunk it.
 659     if [expr $x==4] then { pass $testname } else { fail $testname }
 660 }
 661
 662 proc do_other {} {
 663     set testname "other.s: other tests"
 664     set x 0
 665
 666     gas_start "other.s" "-al"
 667
 668     # Instead of having a variable for each match string just increment the
 669     # total number of matches seen.  That's simpler when testing large numbers
 670     # of instructions (as these tests to).
 671     while 1 {
 672         expect {
 673             -re "^ +\[0-9\]+ 0000 08\[^\n\]*\n"         { set x [expr $x+1] }
 674             -re "^ +\[0-9\]+ 0001 44\[^\n\]*\n"         { set x [expr $x+1] }
 675             -re "^ +\[0-9\]+ 0002 49\[^\n\]*\n"         { set x [expr $x+1] }
 676             -re "^ +\[0-9\]+ 0003 53\[^\n\]*\n"         { set x [expr $x+1] }
 677             -re "^ +\[0-9\]+ 0004 F0F6\[^\n\]*\n"       { set x [expr $x+1] }
 678             -re "^ +\[0-9\]+ 0006 CC0001\[^\n\]*\n"     { set x [expr $x+1] }
 679             -re "^ +\[0-9\]+ 0009 DCFFFF01\[^\n\]*\n"   { set x [expr $x+1] }
 680             -re "^ +8 +00\[^\n\]*\n"                    { set x [expr $x+1] }
 681             -re "^ +\[0-9\]+ 000e CD000130\[^\n\]*\n"   { set x [expr $x+1] }
 682             -re "^ +9 +09\[^\n\]*\n"                    { set x [expr $x+1] }
 683             -re "^ +\[0-9\]+ 0013 DDFFFF01\[^\n\]*\n"   { set x [expr $x+1] }
 684             -re "^ +10 +003020\[^\n\]*\n"               { set x [expr $x+1] }
 685             -re "^ +\[0-9\]+ 001a F0F2\[^\n\]*\n"       { set x [expr $x+1] }
 686             -re "^ +\[0-9\]+ 001c FAFF0001\[^\n\]*\n"   { set x [expr $x+1] }
 687             -re "^ +\[0-9\]+ 0020 FCFFFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 688             -re "^ +13 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 689             -re "^ +\[0-9\]+ 0026 DF3007\[^\n\]*\n"     { set x [expr $x+1] }
 690             -re "^ +\[0-9\]+ 0029 DE3005\[^\n\]*\n"     { set x [expr $x+1] }
 691             -re "^ +\[0-9\]+ 002c F0FC\[^\n\]*\n"       { set x [expr $x+1] }
 692             -re "^ +\[0-9\]+ 002e F0FD\[^\n\]*\n"       { set x [expr $x+1] }
 693             -re "^ +\[0-9\]+ 0030 F0FE\[^\n\]*\n"       { set x [expr $x+1] }
 694             -re "^ +\[0-9\]+ 0032 CB\[^\n\]*\n"         { set x [expr $x+1] }
 695             -re "^ +\[0-9\]+ 0033 F0FF\[^\n\]*\n"       { set x [expr $x+1] }
 696             -re "\[^\n\]*\n"                            { }
 697             timeout                             { perror "timeout\n"; break }
 698             eof                                 { break }
 699         }
 700     }
 701
 702     # This was intended to do any cleanup necessary.  It kinda looks like it
 703     # isn't needed, but just in case, please keep it in for now.
 704     gas_finish
 705
 706     # Did we find what we were looking for?  If not, flunk it.
 707     if [expr $x==23] then { pass $testname } else { fail $testname }
 708 }
 709
 710 proc do_shift {} {
 711     set testname "shift.s: shift tests"
 712     set x 0
 713
 714     gas_start "shift.s" "-al"
 715
 716     # Instead of having a variable for each match string just increment the
 717     # total number of matches seen.  That's simpler when testing large numbers
 718     # of instructions (as these tests to).
 719     while 1 {
 720         expect {
 721             -re "^ +\[0-9\]+ 0000 F2B6\[^\n\]*\n"       { set x [expr $x+1] }
 722             -re "^ +\[0-9\]+ 0002 F8CA04\[^\n\]*\n"     { set x [expr $x+1] }
 723             -re "^ +\[0-9\]+ 0005 F2AB\[^\n\]*\n"       { set x [expr $x+1] }
 724             -re "^ +\[0-9\]+ 0007 F8C704\[^\n\]*\n"     { set x [expr $x+1] }
 725             -re "^ +\[0-9\]+ 000a F29E\[^\n\]*\n"       { set x [expr $x+1] }
 726             -re "^ +\[0-9\]+ 000c F8C204\[^\n\]*\n"     { set x [expr $x+1] }
 727             -re "^ +\[0-9\]+ 000f 56\[^\n\]*\n"         { set x [expr $x+1] }
 728             -re "^ +\[0-9\]+ 0010 F285\[^\n\]*\n"       { set x [expr $x+1] }
 729             -re "^ +\[0-9\]+ 0012 F282\[^\n\]*\n"       { set x [expr $x+1] }
 730             -re "\[^\n\]*\n"                            { }
 731             timeout                             { perror "timeout\n"; break }
 732             eof                                 { break }
 733         }
 734     }
 735
 736     # This was intended to do any cleanup necessary.  It kinda looks like it
 737     # isn't needed, but just in case, please keep it in for now.
 738     gas_finish
 739
 740     # Did we find what we were looking for?  If not, flunk it.
 741     if [expr $x==9] then { pass $testname } else { fail $testname }
 742 }
 743
 744 proc do_sub {} {
 745     set testname "sub.s: sub tests"
 746     set x 0
 747
 748     gas_start "sub.s" "-al"
 749
 750     # Instead of having a variable for each match string just increment the
 751     # total number of matches seen.  That's simpler when testing large numbers
 752     # of instructions (as these tests to).
 753     while 1 {
 754         expect {
 755             -re "^ +\[0-9\]+ 0000 F106\[^\n\]*\n"       { set x [expr $x+1] }
 756             -re "^ +\[0-9\]+ 0002 F12B\[^\n\]*\n"       { set x [expr $x+1] }
 757             -re "^ +\[0-9\]+ 0004 F11F\[^\n\]*\n"       { set x [expr $x+1] }
 758             -re "^ +\[0-9\]+ 0006 F13E\[^\n\]*\n"       { set x [expr $x+1] }
 759             -re "^ +\[0-9\]+ 0008 FCC6FFFF \[^\n\]*\n"  { set x [expr $x+1] }
 760             -re "^ +6 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 761             -re "^ +\[0-9\]+ 000e FCD5FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 762             -re "^ +7 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 763             -re "^ +\[0-9\]+ 0014 F186\[^\n\]*\n"       { set x [expr $x+1] }
 764             -re "\[^\n\]*\n"                            { }
 765             timeout                             { perror "timeout\n"; break }
 766             eof                                 { break }
 767         }
 768     }
 769
 770     # This was intended to do any cleanup necessary.  It kinda looks like it
 771     # isn't needed, but just in case, please keep it in for now.
 772     gas_finish
 773
 774     # Did we find what we were looking for?  If not, flunk it.
 775     if [expr $x==9] then { pass $testname } else { fail $testname }
 776 }
 777
 778 proc do_udf {} {
 779     set testname "udf.s: udf tests part 1"
 780     set x 0
 781
 782     gas_start "udf.s" "-al"
 783
 784     # Instead of having a variable for each match string just increment the
 785     # total number of matches seen.  That's simpler when testing large numbers
 786     # of instructions (as these tests to).
 787     while 1 {
 788         expect {
 789             -re "^ +\[0-9\]+ 0000 F601\[^\n\]*\n"       { set x [expr $x+1] }
 790             -re "^ +\[0-9\]+ 0002 F611\[^\n\]*\n"       { set x [expr $x+1] }
 791             -re "^ +\[0-9\]+ 0004 F621\[^\n\]*\n"       { set x [expr $x+1] }
 792             -re "^ +\[0-9\]+ 0006 F631\[^\n\]*\n"       { set x [expr $x+1] }
 793             -re "^ +\[0-9\]+ 0008 F641\[^\n\]*\n"       { set x [expr $x+1] }
 794             -re "^ +\[0-9\]+ 000a F651\[^\n\]*\n"       { set x [expr $x+1] }
 795             -re "^ +\[0-9\]+ 000c F661\[^\n\]*\n"       { set x [expr $x+1] }
 796             -re "^ +\[0-9\]+ 000e F671\[^\n\]*\n"       { set x [expr $x+1] }
 797             -re "^ +\[0-9\]+ 0010 F681\[^\n\]*\n"       { set x [expr $x+1] }
 798             -re "^ +\[0-9\]+ 0012 F691\[^\n\]*\n"       { set x [expr $x+1] }
 799             -re "^ +\[0-9\]+ 0014 F6A1\[^\n\]*\n"       { set x [expr $x+1] }
 800             -re "^ +\[0-9\]+ 0016 F6B1\[^\n\]*\n"       { set x [expr $x+1] }
 801             -re "^ +\[0-9\]+ 0018 F6C1\[^\n\]*\n"       { set x [expr $x+1] }
 802             -re "^ +\[0-9\]+ 001a F6D1\[^\n\]*\n"       { set x [expr $x+1] }
 803             -re "^ +\[0-9\]+ 001c F6E1\[^\n\]*\n"       { set x [expr $x+1] }
 804             -re "^ +\[0-9\]+ 001e F6F1\[^\n\]*\n"       { set x [expr $x+1] }
 805             -re "^ +\[0-9\]+ 0020 F501\[^\n\]*\n"       { set x [expr $x+1] }
 806             -re "^ +\[0-9\]+ 0022 F511\[^\n\]*\n"       { set x [expr $x+1] }
 807             -re "^ +\[0-9\]+ 0024 F521\[^\n\]*\n"       { set x [expr $x+1] }
 808             -re "^ +\[0-9\]+ 0026 F531\[^\n\]*\n"       { set x [expr $x+1] }
 809             -re "^ +\[0-9\]+ 0028 F541\[^\n\]*\n"       { set x [expr $x+1] }
 810             -re "^ +\[0-9\]+ 002a F551\[^\n\]*\n"       { set x [expr $x+1] }
 811             -re "^ +\[0-9\]+ 002c F561\[^\n\]*\n"       { set x [expr $x+1] }
 812             -re "^ +\[0-9\]+ 002e F571\[^\n\]*\n"       { set x [expr $x+1] }
 813             -re "^ +\[0-9\]+ 0030 F581\[^\n\]*\n"       { set x [expr $x+1] }
 814             -re "^ +\[0-9\]+ 0032 F591\[^\n\]*\n"       { set x [expr $x+1] }
 815             -re "^ +\[0-9\]+ 0034 F5A1\[^\n\]*\n"       { set x [expr $x+1] }
 816             -re "^ +\[0-9\]+ 0036 F5B1\[^\n\]*\n"       { set x [expr $x+1] }
 817             -re "^ +\[0-9\]+ 0038 F5C1\[^\n\]*\n"       { set x [expr $x+1] }
 818             -re "^ +\[0-9\]+ 003a F5D1\[^\n\]*\n"       { set x [expr $x+1] }
 819             -re "^ +\[0-9\]+ 003c F5E1\[^\n\]*\n"       { set x [expr $x+1] }
 820             -re "^ +\[0-9\]+ 003e F5F1\[^\n\]*\n"       { set x [expr $x+1] }
 821             -re "^ +\[0-9\]+ 0040 F9017F\[^\n\]*\n"     { set x [expr $x+1] }
 822             -re "^ +\[0-9\]+ 0043 F9117F\[^\n\]*\n"     { set x [expr $x+1] }
 823             -re "^ +\[0-9\]+ 0046 F9217F\[^\n\]*\n"     { set x [expr $x+1] }
 824             -re "^ +\[0-9\]+ 0049 F9317F\[^\n\]*\n"     { set x [expr $x+1] }
 825             -re "^ +\[0-9\]+ 004c F9417F\[^\n\]*\n"     { set x [expr $x+1] }
 826             -re "^ +\[0-9\]+ 004f F9517F\[^\n\]*\n"     { set x [expr $x+1] }
 827             -re "^ +\[0-9\]+ 0052 F9617F\[^\n\]*\n"     { set x [expr $x+1] }
 828             -re "^ +\[0-9\]+ 0055 F9717F\[^\n\]*\n"     { set x [expr $x+1] }
 829             -re "^ +\[0-9\]+ 0058 F9817F\[^\n\]*\n"     { set x [expr $x+1] }
 830             -re "^ +\[0-9\]+ 005b F9917F\[^\n\]*\n"     { set x [expr $x+1] }
 831             -re "^ +\[0-9\]+ 005e F9A17F\[^\n\]*\n"     { set x [expr $x+1] }
 832             -re "^ +\[0-9\]+ 0061 F9B17F\[^\n\]*\n"     { set x [expr $x+1] }
 833             -re "^ +\[0-9\]+ 0064 F9C17F\[^\n\]*\n"     { set x [expr $x+1] }
 834             -re "^ +\[0-9\]+ 0067 F9D17F\[^\n\]*\n"     { set x [expr $x+1] }
 835             -re "^ +\[0-9\]+ 006a F9E17F\[^\n\]*\n"     { set x [expr $x+1] }
 836             -re "^ +\[0-9\]+ 006d F9F17F\[^\n\]*\n"     { set x [expr $x+1] }
 837             -re "^ +\[0-9\]+ 0070 FB01FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 838             -re "^ +\[0-9\]+ 0074 FB11FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 839             -re "^ +\[0-9\]+ 0078 FB21FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 840             -re "^ +\[0-9\]+ 007c FB31FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 841             -re "^ +\[0-9\]+ 0080 FB41FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 842             -re "^ +\[0-9\]+ 0084 FB51FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 843             -re "^ +\[0-9\]+ 0088 FB61FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 844             -re "^ +\[0-9\]+ 008c FB71FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 845             -re "^ +\[0-9\]+ 0090 FB81FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 846             -re "^ +\[0-9\]+ 0094 FB91FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 847             -re "^ +\[0-9\]+ 0098 FBA1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 848             -re "^ +\[0-9\]+ 009c FBB1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 849             -re "^ +\[0-9\]+ 00a0 FBC1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 850             -re "^ +\[0-9\]+ 00a4 FBD1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 851             -re "^ +\[0-9\]+ 00a8 FBE1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 852             -re "^ +\[0-9\]+ 00ac FBF1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 853             -re "^ +\[0-9\]+ 00b0 FD01FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 854             -re "^ +66 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 855             -re "^ +\[0-9\]+ 00b6 FD11FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 856             -re "^ +67 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 857             -re "^ +\[0-9\]+ 00bc FD21FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 858             -re "^ +68 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 859             -re "^ +\[0-9\]+ 00c2 FD31FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 860             -re "^ +69 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 861             -re "^ +\[0-9\]+ 00c8 FD41FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 862             -re "^ +70 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 863             -re "^ +\[0-9\]+ 00ce FD51FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 864             -re "^ +71 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 865             -re "^ +\[0-9\]+ 00d4 FD61FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 866             -re "^ +72 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 867             -re "^ +\[0-9\]+ 00da FD71FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 868             -re "^ +73 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 869             -re "^ +\[0-9\]+ 00e0 FD81FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 870             -re "^ +74 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 871             -re "^ +\[0-9\]+ 00e6 FD91FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 872             -re "^ +75 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 873             -re "^ +\[0-9\]+ 00ec FDA1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 874             -re "^ +76 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 875             -re "^ +\[0-9\]+ 00f2 FDB1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 876             -re "^ +77 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 877             -re "^ +\[0-9\]+ 00f8 FDC1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 878             -re "^ +78 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 879             -re "^ +\[0-9\]+ 00fe FDD1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 880             -re "^ +79 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 881             -re "^ +\[0-9\]+ 0104 FDE1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 882             -re "^ +80 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 883             -re "^ +\[0-9\]+ 010a FDF1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 884             -re "^ +81 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 885             -re "^ +\[0-9\]+ 0110 F90580\[^\n\]*\n"     { set x [expr $x+1] }
 886             -re "^ +\[0-9\]+ 0113 F91580\[^\n\]*\n"     { set x [expr $x+1] }
 887             -re "^ +\[0-9\]+ 0116 F92580\[^\n\]*\n"     { set x [expr $x+1] }
 888             -re "^ +\[0-9\]+ 0119 F93580\[^\n\]*\n"     { set x [expr $x+1] }
 889             -re "^ +\[0-9\]+ 011c F94580\[^\n\]*\n"     { set x [expr $x+1] }
 890             -re "^ +\[0-9\]+ 011f F95580\[^\n\]*\n"     { set x [expr $x+1] }
 891             -re "^ +\[0-9\]+ 0122 F96580\[^\n\]*\n"     { set x [expr $x+1] }
 892             -re "^ +\[0-9\]+ 0125 F97580\[^\n\]*\n"     { set x [expr $x+1] }
 893             -re "^ +\[0-9\]+ 0128 F98580\[^\n\]*\n"     { set x [expr $x+1] }
 894             -re "^ +\[0-9\]+ 012b F99580\[^\n\]*\n"     { set x [expr $x+1] }
 895             -re "^ +\[0-9\]+ 012e F9A580\[^\n\]*\n"     { set x [expr $x+1] }
 896             -re "^ +\[0-9\]+ 0131 F9B580\[^\n\]*\n"     { set x [expr $x+1] }
 897             -re "^ +\[0-9\]+ 0134 F9C580\[^\n\]*\n"     { set x [expr $x+1] }
 898             -re "^ +\[0-9\]+ 0137 F9D580\[^\n\]*\n"     { set x [expr $x+1] }
 899             -re "^ +\[0-9\]+ 013a F9E580\[^\n\]*\n"     { set x [expr $x+1] }
 900             -re "^ +\[0-9\]+ 013d F9F580\[^\n\]*\n"     { set x [expr $x+1] }
 901             -re "^ +\[0-9\]+ 0140 FB050080\[^\n\]*\n"   { set x [expr $x+1] }
 902             -re "^ +\[0-9\]+ 0144 FB150080\[^\n\]*\n"   { set x [expr $x+1] }
 903             -re "^ +\[0-9\]+ 0148 FB250080\[^\n\]*\n"   { set x [expr $x+1] }
 904             -re "^ +\[0-9\]+ 014c FB350080\[^\n\]*\n"   { set x [expr $x+1] }
 905             -re "^ +\[0-9\]+ 0150 FB450080\[^\n\]*\n"   { set x [expr $x+1] }
 906             -re "^ +\[0-9\]+ 0154 FB550080\[^\n\]*\n"   { set x [expr $x+1] }
 907             -re "^ +\[0-9\]+ 0158 FB650080\[^\n\]*\n"   { set x [expr $x+1] }
 908             -re "^ +\[0-9\]+ 015c FB750080\[^\n\]*\n"   { set x [expr $x+1] }
 909             -re "^ +\[0-9\]+ 0160 FB850080\[^\n\]*\n"   { set x [expr $x+1] }
 910             -re "^ +\[0-9\]+ 0164 FB950080\[^\n\]*\n"   { set x [expr $x+1] }
 911             -re "^ +\[0-9\]+ 0168 FBA50080\[^\n\]*\n"   { set x [expr $x+1] }
 912             -re "^ +\[0-9\]+ 016c FBB50080\[^\n\]*\n"   { set x [expr $x+1] }
 913             -re "^ +\[0-9\]+ 0170 FBC50080\[^\n\]*\n"   { set x [expr $x+1] }
 914             -re "^ +\[0-9\]+ 0174 FBD50080\[^\n\]*\n"   { set x [expr $x+1] }
 915             -re "^ +\[0-9\]+ 0178 FBE50080\[^\n\]*\n"   { set x [expr $x+1] }
 916             -re "^ +\[0-9\]+ 017c FBF50080\[^\n\]*\n"   { set x [expr $x+1] }
 917             -re "^ +\[0-9\]+ 0180 FD050000\[^\n\]*\n"   { set x [expr $x+1] }
 918             -re "^ +114 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 919             -re "^ +\[0-9\]+ 0186 FD150000\[^\n\]*\n"   { set x [expr $x+1] }
 920             -re "^ +115 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 921             -re "^ +\[0-9\]+ 018c FD250000\[^\n\]*\n"   { set x [expr $x+1] }
 922             -re "^ +116 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 923             -re "^ +\[0-9\]+ 0192 FD350000\[^\n\]*\n"   { set x [expr $x+1] }
 924             -re "^ +117 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 925             -re "^ +\[0-9\]+ 0198 FD450000\[^\n\]*\n"   { set x [expr $x+1] }
 926             -re "^ +118 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 927             -re "^ +\[0-9\]+ 019e FD550000\[^\n\]*\n"   { set x [expr $x+1] }
 928             -re "^ +119 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 929             -re "^ +\[0-9\]+ 01a4 FD650000\[^\n\]*\n"   { set x [expr $x+1] }
 930             -re "^ +120 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 931             -re "^ +\[0-9\]+ 01aa FD750000\[^\n\]*\n"   { set x [expr $x+1] }
 932             -re "^ +121 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 933             -re "^ +\[0-9\]+ 01b0 FD850000\[^\n\]*\n"   { set x [expr $x+1] }
 934             -re "^ +122 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 935             -re "^ +\[0-9\]+ 01b6 FD950000\[^\n\]*\n"   { set x [expr $x+1] }
 936             -re "^ +123 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 937             -re "^ +\[0-9\]+ 01bc FDA50000\[^\n\]*\n"   { set x [expr $x+1] }
 938             -re "^ +124 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 939             -re "^ +\[0-9\]+ 01c2 FDB50000\[^\n\]*\n"   { set x [expr $x+1] }
 940             -re "^ +125 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 941             -re "^ +\[0-9\]+ 01c8 FDC50000\[^\n\]*\n"   { set x [expr $x+1] }
 942             -re "^ +126 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 943             -re "^ +\[0-9\]+ 01ce FDD50000\[^\n\]*\n"   { set x [expr $x+1] }
 944             -re "^ +127 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 945             -re "^ +\[0-9\]+ 01d4 FDE50000\[^\n\]*\n"   { set x [expr $x+1] }
 946             -re "^ +128 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 947             -re "^ +\[0-9\]+ 01da FDF50000\[^\n\]*\n"   { set x [expr $x+1] }
 948             -re "^ +129 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 949             -re "\[^\n\]*\n"                            { }
 950             timeout                             { perror "timeout\n"; break }
 951             eof                                 { break }
 952         }
 953     }
 954
 955     # This was intended to do any cleanup necessary.  It kinda looks like it
 956     # isn't needed, but just in case, please keep it in for now.
 957     gas_finish
 958
 959     # Did we find what we were looking for?  If not, flunk it.
 960     if [expr $x==160] then { pass $testname } else { fail $testname }
 961 }
 962
 963
 964 if [istarget mn10300*-*-*] then {
 965     # Test the basic instruction parser.
 966     do_add
 967     do_bcc
 968     do_bit
 969     do_cmp
 970     do_ext
 971     do_extend
 972     do_logical
 973     do_loop
 974     do_mov1
 975     do_mov2
 976     do_mov3
 977     do_mov4
 978     do_movbu
 979     do_movhu
 980     do_movm
 981     do_muldiv
 982     do_other
 983     do_shift
 984     do_sub
 985     do_udf
 986 }