gas/testsuite/gas/mn10300/basic.exp

   1 # Copyright (C) 1996, 2000, 2002, 2004, 2005, 2007
   2 # Free Software Foundation, Inc.
   3
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 # Please email any bugs, comments, and/or additions to this file to:
  19 # dejagnu@gnu.org
  20
  21 # Written by Cygnus Support.
  22
  23 proc do_add {} {
  24     set testname "add.s: Add operations"
  25     set x 0
  26
  27     gas_start "add.s" "-al"
  28
  29     # Instead of having a variable for each match string just increment the
  30     # total number of matches seen.  That's simpler when testing large numbers
  31     # of instructions (as these tests to).
  32     while 1 {
  33         expect {
  34             -re "^ +\[0-9\]+ 0000 E6\[^\n\]*\n" { set x [expr $x+1] }
  35             -re "^ +\[0-9\]+ 0001 F16B\[^\n\]*\n"       { set x [expr $x+1] }
  36             -re "^ +\[0-9\]+ 0003 F17E\[^\n\]*\n"       { set x [expr $x+1] }
  37             -re "^ +\[0-9\]+ 0005 F159\[^\n\]*\n"       { set x [expr $x+1] }
  38             -re "^ +\[0-9\]+ 0007 2910\[^\n\]*\n"       { set x [expr $x+1] }
  39             -re "^ +\[0-9\]+ 0009 FAC20001\[^\n\]*\n"   { set x [expr $x+1] }
  40             -re "^ +\[0-9\]+ 000d FCC3FFFF\[^\n\]*\n"   { set x [expr $x+1] }
  41             -re "^ +8 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
  42             -re "^ +\[0-9\]+ 0013 2110\[^\n\]*\n"       { set x [expr $x+1] }
  43             -re "^ +\[0-9\]+ 0015 FAD20001\[^\n\]*\n"   { set x [expr $x+1] }
  44             -re "^ +\[0-9\]+ 0019 FCD3FFFF\[^\n\]*\n"   { set x [expr $x+1] }
  45             -re "^ +11 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
  46             -re "^ +\[0-9\]+ 001f F8FE10\[^\n\]*\n"     { set x [expr $x+1] }
  47             -re "^ +\[0-9\]+ 0022 FAFE0001\[^\n\]*\n"   { set x [expr $x+1] }
  48             -re "^ +\[0-9\]+ 0026 FCFEFFFF\[^\n\]*\n"   { set x [expr $x+1] }
  49             -re "^ +14 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
  50             -re "^ +\[0-9\]+ 002c F146\[^\n\]*\n"       { set x [expr $x+1] }
  51             -re "\[^\n\]*\n"                            { }
  52             timeout                             { perror "timeout\n"; break }
  53             eof                                 { break }
  54         }
  55     }
  56
  57     # This was intended to do any cleanup necessary.  It kinda looks like it
  58     # isn't needed, but just in case, please keep it in for now.
  59     gas_finish
  60
  61     # Did we find what we were looking for?  If not, flunk it.
  62     if [expr $x==17] then { pass $testname } else { fail $testname }
  63 }
  64
  65 proc do_bcc {} {
  66     set testname "bcc.s: Bcc tests"
  67     set x 0
  68
  69     gas_start "bcc.s" "-al"
  70
  71     # Instead of having a variable for each match string just increment the
  72     # total number of matches seen.  That's simpler when testing large numbers
  73     # of instructions (as these tests to).
  74     while 1 {
  75         expect {
  76             -re "^ +\[0-9\]+ 0000 C800\[^\n\]*\n"       { set x [expr $x+1] }
  77             -re "^ +\[0-9\]+ 0002 C900\[^\n\]*\n"       { set x [expr $x+1] }
  78             -re "^ +\[0-9\]+ 0004 C100\[^\n\]*\n"       { set x [expr $x+1] }
  79             -re "^ +\[0-9\]+ 0006 C200\[^\n\]*\n"       { set x [expr $x+1] }
  80             -re "^ +\[0-9\]+ 0008 C300\[^\n\]*\n"       { set x [expr $x+1] }
  81             -re "^ +\[0-9\]+ 000a C000\[^\n\]*\n"       { set x [expr $x+1] }
  82             -re "^ +\[0-9\]+ 000c C500\[^\n\]*\n"       { set x [expr $x+1] }
  83             -re "^ +\[0-9\]+ 000e C600\[^\n\]*\n"       { set x [expr $x+1] }
  84             -re "^ +\[0-9\]+ 0010 C700\[^\n\]*\n"       { set x [expr $x+1] }
  85             -re "^ +\[0-9\]+ 0012 C400\[^\n\]*\n"       { set x [expr $x+1] }
  86             -re "^ +\[0-9\]+ 0014 F8E800\[^\n\]*\n"     { set x [expr $x+1] }
  87             -re "^ +\[0-9\]+ 0017 F8E900\[^\n\]*\n"     { set x [expr $x+1] }
  88             -re "^ +\[0-9\]+ 001a F8EA00\[^\n\]*\n"     { set x [expr $x+1] }
  89             -re "^ +\[0-9\]+ 001d F8EB00\[^\n\]*\n"     { set x [expr $x+1] }
  90             -re "^ +\[0-9\]+ 0020 CA00\[^\n\]*\n"       { set x [expr $x+1] }
  91             -re "\[^\n\]*\n"                            { }
  92             timeout                             { perror "timeout\n"; break }
  93             eof                                 { break }
  94         }
  95     }
  96
  97     # This was intended to do any cleanup necessary.  It kinda looks like it
  98     # isn't needed, but just in case, please keep it in for now.
  99     gas_finish
 100
 101     # Did we find what we were looking for?  If not, flunk it.
 102     if [expr $x==15] then { pass $testname } else { fail $testname }
 103 }
 104
 105 proc do_bit {} {
 106     set testname "bit.s: bit tests"
 107     set x 0
 108
 109     gas_start "bit.s" "-al"
 110
 111     # Instead of having a variable for each match string just increment the
 112     # total number of matches seen.  That's simpler when testing large numbers
 113     # of instructions (as these tests to).
 114     while 1 {
 115         expect {
 116             -re "^ +\[0-9\]+ 0000 F8ED40\[^\n\]*\n"     { set x [expr $x+1] }
 117             -re "^ +\[0-9\]+ 0003 FAEE0020\[^\n\]*\n"   { set x [expr $x+1] }
 118             -re "^ +\[0-9\]+ 0007 FCEFFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 119             -re "^ +4 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 120             -re "^ +\[0-9\]+ 000d FAF90840\[^\n\]*\n"   { set x [expr $x+1] }
 121             -re "^ +\[0-9\]+ 0011 FE02FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 122             -re "^ +6 +010040\[^\n\]*\n"                { set x [expr $x+1] }
 123             -re "^ +\[0-9\]+ 0018 F086\[^\n\]*\n"       { set x [expr $x+1] }
 124             -re "^ +\[0-9\]+ 001a FAF10840\[^\n\]*\n"   { set x [expr $x+1] }
 125             -re "^ +\[0-9\]+ 001e FE00FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 126             -re "^ +9 +010040\[^\n\]*\n"                { set x [expr $x+1] }
 127             -re "^ +\[0-9\]+ 0025 F096\[^\n\]*\n"       { set x [expr $x+1] }
 128             -re "^ +\[0-9\]+ 0027 FAF50840\[^\n\]*\n"   { set x [expr $x+1] }
 129             -re "^ +\[0-9\]+ 002b FE01FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 130             -re "^ +12 +010040\[^\n\]*\n"               { set x [expr $x+1] }
 131             -re "\[^\n\]*\n"                            { }
 132             timeout                             { perror "timeout\n"; break }
 133             eof                                 { break }
 134         }
 135     }
 136
 137     # This was intended to do any cleanup necessary.  It kinda looks like it
 138     # isn't needed, but just in case, please keep it in for now.
 139     gas_finish
 140
 141     # Did we find what we were looking for?  If not, flunk it.
 142     if [expr $x==15] then { pass $testname } else { fail $testname }
 143 }
 144
 145 proc do_cmp {} {
 146     set testname "cmp.s: cmp tests"
 147     set x 0
 148
 149     gas_start "cmp.s" "-al"
 150
 151     # Instead of having a variable for each match string just increment the
 152     # total number of matches seen.  That's simpler when testing large numbers
 153     # of instructions (as these tests to).
 154     while 1 {
 155         expect {
 156             -re "^ +\[0-9\]+ 0000 A6\[^\n\]*\n"         { set x [expr $x+1] }
 157             -re "^ +\[0-9\]+ 0001 F1AB\[^\n\]*\n"       { set x [expr $x+1] }
 158             -re "^ +\[0-9\]+ 0003 F19F\[^\n\]*\n"       { set x [expr $x+1] }
 159             -re "^ +\[0-9\]+ 0005 BE\[^\n\]*\n"         { set x [expr $x+1] }
 160             -re "^ +\[0-9\]+ 0006 AF10\[^\n\]*\n"       { set x [expr $x+1] }
 161             -re "^ +\[0-9\]+ 0008 FACA0001\[^\n\]*\n"   { set x [expr $x+1] }
 162             -re "^ +\[0-9\]+ 000c FCC9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 163             -re "^ +8 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 164             -re "^ +\[0-9\]+ 0012 BF10\[^\n\]*\n"       { set x [expr $x+1] }
 165             -re "^ +\[0-9\]+ 0014 FADA0001\[^\n\]*\n"   { set x [expr $x+1] }
 166             -re "^ +\[0-9\]+ 0018 FCD9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 167             -re "^ +11 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 168             -re "\[^\n\]*\n"                            { }
 169             timeout                             { perror "timeout\n"; break }
 170             eof                                 { break }
 171         }
 172     }
 173
 174     # This was intended to do any cleanup necessary.  It kinda looks like it
 175     # isn't needed, but just in case, please keep it in for now.
 176     gas_finish
 177
 178     # Did we find what we were looking for?  If not, flunk it.
 179     if [expr $x==12] then { pass $testname } else { fail $testname }
 180 }
 181
 182 proc do_ext {} {
 183     set testname "ext.s: ext tests"
 184     set x 0
 185
 186     gas_start "ext.s" "-al"
 187
 188     # Instead of having a variable for each match string just increment the
 189     # total number of matches seen.  That's simpler when testing large numbers
 190     # of instructions (as these tests to).
 191     while 1 {
 192         expect {
 193             -re "^ +\[0-9\]+ 0000 F2D1\[^\n\]*\n"       { set x [expr $x+1] }
 194             -re "^ +\[0-9\]+ 0002 12\[^\n\]*\n"         { set x [expr $x+1] }
 195             -re "^ +\[0-9\]+ 0003 17\[^\n\]*\n"         { set x [expr $x+1] }
 196             -re "^ +\[0-9\]+ 0004 1A\[^\n\]*\n"         { set x [expr $x+1] }
 197             -re "^ +\[0-9\]+ 0005 1D\[^\n\]*\n"         { set x [expr $x+1] }
 198             -re "\[^\n\]*\n"                            { }
 199             timeout                             { perror "timeout\n"; break }
 200             eof                                 { break }
 201         }
 202     }
 203
 204     # This was intended to do any cleanup necessary.  It kinda looks like it
 205     # isn't needed, but just in case, please keep it in for now.
 206     gas_finish
 207
 208     # Did we find what we were looking for?  If not, flunk it.
 209     if [expr $x==5] then { pass $testname } else { fail $testname }
 210 }
 211
 212 proc do_extend {} {
 213     set testname "extend.s: extended instruction tests"
 214     set x 0
 215
 216     gas_start "extend.s" "-al"
 217
 218     # Instead of having a variable for each match string just increment the
 219     # total number of matches seen.  That's simpler when testing large numbers
 220     # of instructions (as these tests to).
 221     while 1 {
 222         expect {
 223             -re "^ +\[0-9\]+ 0000 F505\[^\n\]*\n"       { set x [expr $x+1] }
 224             -re "^ +\[0-9\]+ 0002 F6FA\[^\n\]*\n"       { set x [expr $x+1] }
 225             -re "^ +\[0-9\]+ 0004 F606\[^\n\]*\n"       { set x [expr $x+1] }
 226             -re "^ +\[0-9\]+ 0006 F90210\[^\n\]*\n"     { set x [expr $x+1] }
 227             -re "^ +\[0-9\]+ 0009 FB030001\[^\n\]*\n"   { set x [expr $x+1] }
 228             -re "^ +\[0-9\]+ 000d FD03FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 229             -re "^ +7 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 230             -re "^ +\[0-9\]+ 0013 F616\[^\n\]*\n"       { set x [expr $x+1] }
 231             -re "^ +\[0-9\]+ 0015 F91610\[^\n\]*\n"     { set x [expr $x+1] }
 232             -re "^ +\[0-9\]+ 0018 FB170001\[^\n\]*\n"   { set x [expr $x+1] }
 233             -re "^ +\[0-9\]+ 001c FD17FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 234             -re "^ +11 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 235             -re "^ +\[0-9\]+ 0022 F64B\[^\n\]*\n"       { set x [expr $x+1] }
 236             -re "^ +\[0-9\]+ 0024 F65E\[^\n\]*\n"       { set x [expr $x+1] }
 237             -re "^ +\[0-9\]+ 0026 F676\[^\n\]*\n"       { set x [expr $x+1] }
 238             -re "\[^\n\]*\n"                            { }
 239             timeout                             { perror "timeout\n"; break }
 240             eof                                 { break }
 241         }
 242     }
 243
 244     # This was intended to do any cleanup necessary.  It kinda looks like it
 245     # isn't needed, but just in case, please keep it in for now.
 246     gas_finish
 247
 248     # Did we find what we were looking for?  If not, flunk it.
 249     if [expr $x==15] then { pass $testname } else { fail $testname }
 250 }
 251
 252 proc do_logical {} {
 253     set testname "logical.s: logical tests"
 254     set x 0
 255
 256     gas_start "logical.s" "-al"
 257
 258     # Instead of having a variable for each match string just increment the
 259     # total number of matches seen.  That's simpler when testing large numbers
 260     # of instructions (as these tests to).
 261     while 1 {
 262         expect {
 263             -re "^ +\[0-9\]+ 0000 F206\[^\n\]*\n"       { set x [expr $x+1] }
 264             -re "^ +\[0-9\]+ 0002 F8E27F\[^\n\]*\n"     { set x [expr $x+1] }
 265             -re "^ +\[0-9\]+ 0005 FAE3FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 266             -re "^ +\[0-9\]+ 0009 FCE3FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 267             -re "^ +5 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 268             -re "^ +\[0-9\]+ 000f FAFCFF7F\[^\n\]*\n"   { set x [expr $x+1] }
 269             -re "^ +\[0-9\]+ 0013 F216\[^\n\]*\n"       { set x [expr $x+1] }
 270             -re "^ +\[0-9\]+ 0015 F8E67F\[^\n\]*\n"     { set x [expr $x+1] }
 271             -re "^ +\[0-9\]+ 0018 FAE7FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 272             -re "^ +\[0-9\]+ 001c FCE7FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 273             -re "^ +10 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 274             -re "^ +\[0-9\]+ 0022 FAFDFF7F\[^\n\]*\n"   { set x [expr $x+1] }
 275             -re "^ +\[0-9\]+ 0026 F226\[^\n\]*\n"       { set x [expr $x+1] }
 276             -re "^ +\[0-9\]+ 0028 FAEBFF7F\[^\n\]*\n"   { set x [expr $x+1] }
 277             -re "^ +\[0-9\]+ 002c FCEBFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 278             -re "^ +14 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 279             -re "^ +\[0-9\]+ 0032 F233\[^\n\]*\n"       { set x [expr $x+1] }
 280             -re "^\[^\n\]*\n"                           { }
 281             timeout                             { perror "timeout\n"; break }
 282             eof                                 { break }
 283         }
 284     }
 285
 286     # This was intended to do any cleanup necessary.  It kinda looks like it
 287     # isn't needed, but just in case, please keep it in for now.
 288     gas_finish
 289
 290     # Did we find what we were looking for?  If not, flunk it.
 291     if [expr $x==17] then { pass $testname } else { fail $testname }
 292 }
 293
 294 proc do_loop {} {
 295     set testname "loop.s: loop tests"
 296     set x 0
 297
 298     gas_start "loop.s" "-al"
 299
 300     # Instead of having a variable for each match string just increment the
 301     # total number of matches seen.  That's simpler when testing large numbers
 302     # of instructions (as these tests to).
 303     while 1 {
 304         expect {
 305             -re "^ +\[0-9\]+ 0000 D8\[^\n\]*\n"         { set x [expr $x+1] }
 306             -re "^ +\[0-9\]+ 0001 D9\[^\n\]*\n"         { set x [expr $x+1] }
 307             -re "^ +\[0-9\]+ 0002 D1\[^\n\]*\n"         { set x [expr $x+1] }
 308             -re "^ +\[0-9\]+ 0003 D2\[^\n\]*\n"         { set x [expr $x+1] }
 309             -re "^ +\[0-9\]+ 0004 D3\[^\n\]*\n"         { set x [expr $x+1] }
 310             -re "^ +\[0-9\]+ 0005 D0\[^\n\]*\n"         { set x [expr $x+1] }
 311             -re "^ +\[0-9\]+ 0006 D5\[^\n\]*\n"         { set x [expr $x+1] }
 312             -re "^ +\[0-9\]+ 0007 D6\[^\n\]*\n"         { set x [expr $x+1] }
 313             -re "^ +\[0-9\]+ 0008 D7\[^\n\]*\n"         { set x [expr $x+1] }
 314             -re "^ +\[0-9\]+ 0009 D4\[^\n\]*\n"         { set x [expr $x+1] }
 315             -re "^ +\[0-9\]+ 000a DA\[^\n\]*\n"         { set x [expr $x+1] }
 316             -re "^ +\[0-9\]+ 000b DB\[^\n\]*\n"         { set x [expr $x+1] }
 317             -re "\[^\n\]*\n"                            { }
 318             timeout                             { perror "timeout\n"; break }
 319             eof                                 { break }
 320         }
 321     }
 322
 323     # This was intended to do any cleanup necessary.  It kinda looks like it
 324     # isn't needed, but just in case, please keep it in for now.
 325     gas_finish
 326
 327     # Did we find what we were looking for?  If not, flunk it.
 328     if [expr $x==12] then { pass $testname } else { fail $testname }
 329 }
 330
 331 proc do_mov1 {} {
 332     set testname "mov1.s: mov1 tests"
 333     set x 0
 334
 335     gas_start "mov1.s" "-al"
 336
 337     # Instead of having a variable for each match string just increment the
 338     # total number of matches seen.  That's simpler when testing large numbers
 339     # of instructions (as these tests to).
 340     while 1 {
 341         expect {
 342             -re "^ +\[0-9\]+ 0000 86\[^\n\]*\n"         { set x [expr $x+1] }
 343             -re "^ +\[0-9\]+ 0001 F1E6\[^\n\]*\n"       { set x [expr $x+1] }
 344             -re "^ +\[0-9\]+ 0003 F1D9\[^\n\]*\n"       { set x [expr $x+1] }
 345             -re "^ +\[0-9\]+ 0005 99\[^\n\]*\n"         { set x [expr $x+1] }
 346             -re "^ +\[0-9\]+ 0006 3E\[^\n\]*\n"         { set x [expr $x+1] }
 347             -re "^ +\[0-9\]+ 0007 F2F4\[^\n\]*\n"       { set x [expr $x+1] }
 348             -re "^ +\[0-9\]+ 0009 F2FB\[^\n\]*\n"       { set x [expr $x+1] }
 349             -re "^ +\[0-9\]+ 000b F2E1\[^\n\]*\n"       { set x [expr $x+1] }
 350             -re "^ +\[0-9\]+ 000d F2FA\[^\n\]*\n"       { set x [expr $x+1] }
 351             -re "^ +\[0-9\]+ 000f 76\[^\n\]*\n"         { set x [expr $x+1] }
 352             -re "^ +\[0-9\]+ 0010 F80608\[^\n\]*\n"     { set x [expr $x+1] }
 353             -re "^ +\[0-9\]+ 0013 FA060001\[^\n\]*\n"   { set x [expr $x+1] }
 354             -re "^ +\[0-9\]+ 0017 FC06FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 355             -re "^ +14 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 356             -re "^ +\[0-9\]+ 001d 5908\[^\n\]*\n"       { set x [expr $x+1] }
 357             -re "^ +\[0-9\]+ 001f FAB50001\[^\n\]*\n"   { set x [expr $x+1] }
 358             -re "^ +\[0-9\]+ 0023 F2E7\[^\n\]*\n"       { set x [expr $x+1] }
 359             -re "\[^\n\]*\n"                            { }
 360             timeout                             { perror "timeout\n"; break }
 361             eof                                 { break }
 362         }
 363     }
 364
 365     # This was intended to do any cleanup necessary.  It kinda looks like it
 366     # isn't needed, but just in case, please keep it in for now.
 367     gas_finish
 368
 369     # Did we find what we were looking for?  If not, flunk it.
 370     if [expr $x==17] then { pass $testname } else { fail $testname }
 371 }
 372
 373 proc do_mov2 {} {
 374     set testname "mov2.s: mov2 tests"
 375     set x 0
 376
 377     gas_start "mov2.s" "-al"
 378
 379     # Instead of having a variable for each match string just increment the
 380     # total number of matches seen.  That's simpler when testing large numbers
 381     # of instructions (as these tests to).
 382     while 1 {
 383         expect {
 384             -re "^ +\[0-9\]+ 0000 FCB5FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 385             -re "^ +2 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 386             -re "^ +\[0-9\]+ 0006 F325\[^\n\]*\n"       { set x [expr $x+1] }
 387             -re "^ +\[0-9\]+ 0008 310080\[^\n\]*\n"     { set x [expr $x+1] }
 388             -re "^ +\[0-9\]+ 000b FCA5FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 389             -re "^ +5 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 390             -re "^ +\[0-9\]+ 0011 F006\[^\n\]*\n"       { set x [expr $x+1] }
 391             -re "^ +\[0-9\]+ 0013 F82608\[^\n\]*\n"     { set x [expr $x+1] }
 392             -re "^ +\[0-9\]+ 0016 FA260001 \[^\n\]*\n"  { set x [expr $x+1] }
 393             -re "^ +\[0-9\]+ 001a FC26FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 394             -re "^ +9 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 395             -re "^ +\[0-9\]+ 0020 5D08\[^\n\]*\n"       { set x [expr $x+1] }
 396             -re "^ +\[0-9\]+ 0022 FAB10001\[^\n\]*\n"   { set x [expr $x+1] }
 397             -re "^ +\[0-9\]+ 0026 FCB1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 398             -re "^ +12 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 399             -re "^ +\[0-9\]+ 002c F3A5\[^\n\]*\n"       { set x [expr $x+1] }
 400             -re "^ +\[0-9\]+ 002e FAA10080\[^\n\]*\n"   { set x [expr $x+1] }
 401             -re "^ +\[0-9\]+ 0032 FCA1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 402             -re "^ +15 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 403             -re "^ +\[0-9\]+ 0038 F8F120\[^\n\]*\n"     { set x [expr $x+1] }
 404             -re "\[^\n\]*\n"                            { }
 405             timeout                             { perror "timeout\n"; break }
 406             eof                                 { break }
 407         }
 408     }
 409
 410     # This was intended to do any cleanup necessary.  It kinda looks like it
 411     # isn't needed, but just in case, please keep it in for now.
 412     gas_finish
 413
 414     # Did we find what we were looking for?  If not, flunk it.
 415     if [expr $x==20] then { pass $testname } else { fail $testname }
 416 }
 417
 418 proc do_mov3 {} {
 419     set testname "mov3.s: mov3 tests"
 420     set x 0
 421
 422     gas_start "mov3.s" "-al"
 423
 424     # Instead of having a variable for each match string just increment the
 425     # total number of matches seen.  That's simpler when testing large numbers
 426     # of instructions (as these tests to).
 427     while 1 {
 428         expect {
 429             -re "^ +\[0-9\]+ 0000 66\[^\n\]*\n" { set x [expr $x+1] }
 430             -re "^ +\[0-9\]+ 0001 F81620\[^\n\]*\n"     { set x [expr $x+1] }
 431             -re "^ +\[0-9\]+ 0004 FA160001\[^\n\]*\n"   { set x [expr $x+1] }
 432             -re "^ +\[0-9\]+ 0008 FC16FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 433             -re "^ +5 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 434             -re "^ +\[0-9\]+ 000e 4620\[^\n\]*\n"       { set x [expr $x+1] }
 435             -re "^ +\[0-9\]+ 0010 FA950080\[^\n\]*\n"   { set x [expr $x+1] }
 436             -re "^ +\[0-9\]+ 0014 FC95FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 437             -re "^ +8 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 438             -re "^ +\[0-9\]+ 001a F35A\[^\n\]*\n"       { set x [expr $x+1] }
 439             -re "^ +\[0-9\]+ 001c 058000\[^\n\]*\n"     { set x [expr $x+1] }
 440             -re "^ +\[0-9\]+ 001f FC85FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 441             -re "^ +11 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 442             -re "^ +\[0-9\]+ 0025 F016\[^\n\]*\n"       { set x [expr $x+1] }
 443             -re "^ +\[0-9\]+ 0027 F83620\[^\n\]*\n"     { set x [expr $x+1] }
 444             -re "^ +\[0-9\]+ 002a FA360001\[^\n\]*\n"   { set x [expr $x+1] }
 445             -re "^ +\[0-9\]+ 002e FC36FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 446             -re "^ +15 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 447             -re "^ +\[0-9\]+ 0034 4720\[^\n\]*\n"       { set x [expr $x+1] }
 448             -re "\[^\n\]*\n"                            { }
 449             timeout                             { perror "timeout\n"; break }
 450             eof                                 { break }
 451         }
 452     }
 453
 454     # This was intended to do any cleanup necessary.  It kinda looks like it
 455     # isn't needed, but just in case, please keep it in for now.
 456     gas_finish
 457
 458     # Did we find what we were looking for?  If not, flunk it.
 459     if [expr $x==19] then { pass $testname } else { fail $testname }
 460 }
 461
 462 proc do_mov4 {} {
 463     set testname "mov4.s: mov4 tests"
 464     set x 0
 465
 466     gas_start "mov4.s" "-al"
 467
 468     # Instead of having a variable for each match string just increment the
 469     # total number of matches seen.  That's simpler when testing large numbers
 470     # of instructions (as these tests to).
 471     while 1 {
 472         expect {
 473             -re "^ +\[0-9\]+ 0000 FA940080\[^\n\]*\n"   { set x [expr $x+1] }
 474             -re "^ +\[0-9\]+ 0004 FC94FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 475             -re "^ +3 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 476             -re "^ +\[0-9\]+ 000a F3DA\[^\n\]*\n"       { set x [expr $x+1] }
 477             -re "^ +\[0-9\]+ 000c FA848000\[^\n\]*\n"   { set x [expr $x+1] }
 478             -re "^ +\[0-9\]+ 0010 FC84FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 479             -re "^ +6 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 480             -re "^ +\[0-9\]+ 0016 F8F520\[^\n\]*\n"     { set x [expr $x+1] }
 481             -re "^ +\[0-9\]+ 0019 8508\[^\n\]*\n"       { set x [expr $x+1] }
 482             -re "^ +\[0-9\]+ 001b 2D0001\[^\n\]*\n"     { set x [expr $x+1] }
 483             -re "^ +\[0-9\]+ 001e FCCDFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 484             -re "^ +10 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 485             -re "^ +\[0-9\]+ 0024 9508\[^\n\]*\n"       { set x [expr $x+1] }
 486             -re "^ +\[0-9\]+ 0026 250001\[^\n\]*\n"     { set x [expr $x+1] }
 487             -re "^ +\[0-9\]+ 0029 FCDDFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 488             -re "^ +13 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 489             -re "\[^\n\]*\n"                            { }
 490             timeout                             { perror "timeout\n"; break }
 491             eof                                 { break }
 492         }
 493     }
 494
 495     # This was intended to do any cleanup necessary.  It kinda looks like it
 496     # isn't needed, but just in case, please keep it in for now.
 497     gas_finish
 498
 499     # Did we find what we were looking for?  If not, flunk it.
 500     if [expr $x==16] then { pass $testname } else { fail $testname }
 501 }
 502
 503 proc do_mov5 {} {
 504     set testname "mov5.s: mov5 tests"
 505     set x 0
 506
 507     gas_start "mov5.s" "-al"
 508
 509     # Instead of having a variable for each match string just increment the
 510     # total number of matches seen.  That's simpler when testing large numbers
 511     # of instructions (as these tests to).
 512     while 1 {
 513         expect {
 514             -re "^ +\[0-9\]+ 0000 FBF80008\[^\n\]*\n"   { set x [expr $x+1] }
 515             -re "^ +\[0-9\]+ 0004 FDF80000\[^\n\]*\n"   { set x [expr $x+1] }
 516             -re "^ +4 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 517             -re "^ +\[0-9\]+ 000a FDF800FF\[^\n\]*\n"   { set x [expr $x+1] }
 518             -re "^ +5 +FF7F\[^\n\]*\n"                  { set x [expr $x+1] }
 519             -re "^ +\[0-9\]+ 0010 FEF80080\[^\n\]*\n"   { set x [expr $x+1] }
 520             -re "^ +6 +FFFFFF\[^\n\]*\n"                { set x [expr $x+1] }
 521             -re "^ +\[0-9\]+ 0017 FEF80000\[^\n\]*\n"   { set x [expr $x+1] }
 522             -re "^ +7 +0080FF\[^\n\]*\n"                { set x [expr $x+1] }
 523             -re "\[^\n\]*\n"                            { }
 524             timeout                             { perror "timeout\n"; break }
 525             eof                                 { break }
 526         }
 527     }
 528
 529     # This was intended to do any cleanup necessary.  It kinda looks like it
 530     # isn't needed, but just in case, please keep it in for now.
 531     gas_finish
 532
 533     # Did we find what we were looking for?  If not, flunk it.
 534     if [expr $x==9] then { pass $testname } else { fail $testname }
 535 }
 536
 537 proc do_movbu {} {
 538     set testname "movbu.s: movbu tests"
 539     set x 0
 540
 541     gas_start "movbu.s" "-al"
 542
 543     # Instead of having a variable for each match string just increment the
 544     # total number of matches seen.  That's simpler when testing large numbers
 545     # of instructions (as these tests to).
 546     while 1 {
 547         expect {
 548             -re "^ +\[0-9\]+ 0000 F046\[^\n\]*\n"       { set x [expr $x+1] }
 549             -re "^ +\[0-9\]+ 0002 F84608\[^\n\]*\n"     { set x [expr $x+1] }
 550             -re "^ +\[0-9\]+ 0005 FA460001\[^\n\]*\n"   { set x [expr $x+1] }
 551             -re "^ +\[0-9\]+ 0009 FC46FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 552             -re "^ +5 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 553             -re "^ +\[0-9\]+ 000f F8B908\[^\n\]*\n"     { set x [expr $x+1] }
 554             -re "^ +\[0-9\]+ 0012 FAB90001\[^\n\]*\n"   { set x [expr $x+1] }
 555             -re "^ +\[0-9\]+ 0016 FCB9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 556             -re "^ +8 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 557             -re "^ +\[0-9\]+ 001c F425\[^\n\]*\n"       { set x [expr $x+1] }
 558             -re "^ +\[0-9\]+ 001e 350080\[^\n\]*\n"     { set x [expr $x+1] }
 559             -re "^ +\[0-9\]+ 0021 FCA9FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 560             -re "^ +11 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 561             -re "^ +\[0-9\]+ 0027 F056\[^\n\]*\n"       { set x [expr $x+1] }
 562             -re "^ +\[0-9\]+ 0029 F85620\[^\n\]*\n"     { set x [expr $x+1] }
 563             -re "^ +\[0-9\]+ 002c FA560001\[^\n\]*\n"   { set x [expr $x+1] }
 564             -re "^ +\[0-9\]+ 0030 FC56FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 565             -re "^ +15 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 566             -re "^ +\[0-9\]+ 0036 F89620\[^\n\]*\n"     { set x [expr $x+1] }
 567             -re "^ +\[0-9\]+ 0039 FA960080\[^\n\]*\n"   { set x [expr $x+1] }
 568             -re "^ +\[0-9\]+ 003d FC96FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 569             -re "^ +18 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 570             -re "^ +\[0-9\]+ 0043 F45A\[^\n\]*\n"       { set x [expr $x+1] }
 571             -re "^ +\[0-9\]+ 0045 068000\[^\n\]*\n"     { set x [expr $x+1] }
 572             -re "^ +\[0-9\]+ 0048 FC86FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 573             -re "^ +21 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 574             -re "\[^\n\]*\n"                            { }
 575             timeout                             { perror "timeout\n"; break }
 576             eof                                 { break }
 577         }
 578     }
 579
 580     # This was intended to do any cleanup necessary.  It kinda looks like it
 581     # isn't needed, but just in case, please keep it in for now.
 582     gas_finish
 583
 584     # Did we find what we were looking for?  If not, flunk it.
 585     if [expr $x==26] then { pass $testname } else { fail $testname }
 586 }
 587
 588 proc do_movhu {} {
 589     set testname "movhu.s: movhu tests"
 590     set x 0
 591
 592     gas_start "movhu.s" "-al"
 593
 594     # Instead of having a variable for each match string just increment the
 595     # total number of matches seen.  That's simpler when testing large numbers
 596     # of instructions (as these tests to).
 597     while 1 {
 598         expect {
 599             -re "^ +\[0-9\]+ 0000 F066\[^\n\]*\n"       { set x [expr $x+1] }
 600             -re "^ +\[0-9\]+ 0002 F86608\[^\n\]*\n"     { set x [expr $x+1] }
 601             -re "^ +\[0-9\]+ 0005 FA660001\[^\n\]*\n"   { set x [expr $x+1] }
 602             -re "^ +\[0-9\]+ 0009 FC66FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 603             -re "^ +5 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 604             -re "^ +\[0-9\]+ 000f F8BD08\[^\n\]*\n"     { set x [expr $x+1] }
 605             -re "^ +\[0-9\]+ 0012 FABD0001\[^\n\]*\n"   { set x [expr $x+1] }
 606             -re "^ +\[0-9\]+ 0016 FCBDFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 607             -re "^ +8 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 608             -re "^ +\[0-9\]+ 001c F4A5\[^\n\]*\n"       { set x [expr $x+1] }
 609             -re "^ +\[0-9\]+ 001e 390080\[^\n\]*\n"     { set x [expr $x+1] }
 610             -re "^ +\[0-9\]+ 0021 FCADFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 611             -re "^ +11 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 612             -re "^ +\[0-9\]+ 0027 F076\[^\n\]*\n"       { set x [expr $x+1] }
 613             -re "^ +\[0-9\]+ 0029 F87620\[^\n\]*\n"     { set x [expr $x+1] }
 614             -re "^ +\[0-9\]+ 002c FA760001\[^\n\]*\n"   { set x [expr $x+1] }
 615             -re "^ +\[0-9\]+ 0030 FC76FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 616             -re "^ +15 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 617             -re "^ +\[0-9\]+ 0036 F89720\[^\n\]*\n"     { set x [expr $x+1] }
 618             -re "^ +\[0-9\]+ 0039 FA970080\[^\n\]*\n"   { set x [expr $x+1] }
 619             -re "^ +\[0-9\]+ 003d FC97FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 620             -re "^ +18 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 621             -re "^ +\[0-9\]+ 0043 F4DA\[^\n\]*\n"       { set x [expr $x+1] }
 622             -re "^ +\[0-9\]+ 0045 078000\[^\n\]*\n"     { set x [expr $x+1] }
 623             -re "^ +\[0-9\]+ 0048 FC87FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 624             -re "^ +21 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 625             -re "\[^\n\]*\n"                            { }
 626             timeout                             { perror "timeout\n"; break }
 627             eof                                 { break }
 628         }
 629     }
 630
 631     # This was intended to do any cleanup necessary.  It kinda looks like it
 632     # isn't needed, but just in case, please keep it in for now.
 633     gas_finish
 634
 635     # Did we find what we were looking for?  If not, flunk it.
 636     if [expr $x==26] then { pass $testname } else { fail $testname }
 637 }
 638
 639 proc do_movm {} {
 640     set testname "movm.s: movm tests"
 641     set x 0
 642
 643     gas_start "movm.s" "-al"
 644
 645     # Instead of having a variable for each match string just increment the
 646     # total number of matches seen.  That's simpler when testing large numbers
 647     # of instructions (as these tests to).
 648     while 1 {
 649         expect {
 650             -re "^ +\[0-9\]+ 0000 CE30\[^\n\]*\n"       { set x [expr $x+1] }
 651             -re "^ +\[0-9\]+ 0002 CEF8\[^\n\]*\n"       { set x [expr $x+1] }
 652             -re "^ +\[0-9\]+ 0004 CF30\[^\n\]*\n"       { set x [expr $x+1] }
 653             -re "^ +\[0-9\]+ 0006 CFF8\[^\n\]*\n"       { set x [expr $x+1] }
 654             -re "\[^\n\]*\n"                            { }
 655             timeout                             { perror "timeout\n"; break }
 656             eof                                 { break }
 657         }
 658     }
 659
 660     # This was intended to do any cleanup necessary.  It kinda looks like it
 661     # isn't needed, but just in case, please keep it in for now.
 662     gas_finish
 663
 664     # Did we find what we were looking for?  If not, flunk it.
 665     if [expr $x==4] then { pass $testname } else { fail $testname }
 666 }
 667
 668 proc do_muldiv {} {
 669     set testname "muldiv.s: muldiv tests"
 670     set x 0
 671
 672     gas_start "muldiv.s" "-al"
 673
 674     # Instead of having a variable for each match string just increment the
 675     # total number of matches seen.  That's simpler when testing large numbers
 676     # of instructions (as these tests to).
 677     while 1 {
 678         expect {
 679             -re "^ +\[0-9\]+ 0000 F246\[^\n\]*\n"       { set x [expr $x+1] }
 680             -re "^ +\[0-9\]+ 0002 F25B\[^\n\]*\n"       { set x [expr $x+1] }
 681             -re "^ +\[0-9\]+ 0004 F26F\[^\n\]*\n"       { set x [expr $x+1] }
 682             -re "^ +\[0-9\]+ 0006 F27E\[^\n\]*\n"       { set x [expr $x+1] }
 683             -re "\[^\n\]*\n"                            { }
 684             timeout                             { perror "timeout\n"; break }
 685             eof                                 { break }
 686         }
 687     }
 688
 689     # This was intended to do any cleanup necessary.  It kinda looks like it
 690     # isn't needed, but just in case, please keep it in for now.
 691     gas_finish
 692
 693     # Did we find what we were looking for?  If not, flunk it.
 694     if [expr $x==4] then { pass $testname } else { fail $testname }
 695 }
 696
 697 proc do_other {} {
 698     set testname "other.s: other tests"
 699     set x 0
 700
 701     gas_start "other.s" "-al"
 702
 703     # Instead of having a variable for each match string just increment the
 704     # total number of matches seen.  That's simpler when testing large numbers
 705     # of instructions (as these tests to).
 706     while 1 {
 707         expect {
 708             -re "^ +\[0-9\]+ 0000 08\[^\n\]*\n"         { set x [expr $x+1] }
 709             -re "^ +\[0-9\]+ 0001 44\[^\n\]*\n"         { set x [expr $x+1] }
 710             -re "^ +\[0-9\]+ 0002 49\[^\n\]*\n"         { set x [expr $x+1] }
 711             -re "^ +\[0-9\]+ 0003 53\[^\n\]*\n"         { set x [expr $x+1] }
 712             -re "^ +\[0-9\]+ 0004 F0F6\[^\n\]*\n"       { set x [expr $x+1] }
 713             -re "^ +\[0-9\]+ 0006 CC0001\[^\n\]*\n"     { set x [expr $x+1] }
 714             -re "^ +\[0-9\]+ 0009 DCFFFF01\[^\n\]*\n"   { set x [expr $x+1] }
 715             -re "^ +8 +00\[^\n\]*\n"                    { set x [expr $x+1] }
 716             -re "^ +\[0-9\]+ 000e CD000130\[^\n\]*\n"   { set x [expr $x+1] }
 717             -re "^ +9 +09\[^\n\]*\n"                    { set x [expr $x+1] }
 718             -re "^ +\[0-9\]+ 0013 DDFFFF01\[^\n\]*\n"   { set x [expr $x+1] }
 719             -re "^ +10 +003020\[^\n\]*\n"               { set x [expr $x+1] }
 720             -re "^ +\[0-9\]+ 001a F0F2\[^\n\]*\n"       { set x [expr $x+1] }
 721             -re "^ +\[0-9\]+ 001c FAFF0001\[^\n\]*\n"   { set x [expr $x+1] }
 722             -re "^ +\[0-9\]+ 0020 FCFFFFFF\[^\n\]*\n"   { set x [expr $x+1] }
 723             -re "^ +13 +0100\[^\n\]*\n"                 { set x [expr $x+1] }
 724             -re "^ +\[0-9\]+ 0026 DF3007\[^\n\]*\n"     { set x [expr $x+1] }
 725             -re "^ +\[0-9\]+ 0029 DE3005\[^\n\]*\n"     { set x [expr $x+1] }
 726             -re "^ +\[0-9\]+ 002c F0FC\[^\n\]*\n"       { set x [expr $x+1] }
 727             -re "^ +\[0-9\]+ 002e F0FD\[^\n\]*\n"       { set x [expr $x+1] }
 728             -re "^ +\[0-9\]+ 0030 F0FE\[^\n\]*\n"       { set x [expr $x+1] }
 729             -re "^ +\[0-9\]+ 0032 CB\[^\n\]*\n"         { set x [expr $x+1] }
 730             -re "^ +\[0-9\]+ 0033 F0FF\[^\n\]*\n"       { set x [expr $x+1] }
 731             -re "\[^\n\]*\n"                            { }
 732             timeout                             { perror "timeout\n"; break }
 733             eof                                 { break }
 734         }
 735     }
 736
 737     # This was intended to do any cleanup necessary.  It kinda looks like it
 738     # isn't needed, but just in case, please keep it in for now.
 739     gas_finish
 740
 741     # Did we find what we were looking for?  If not, flunk it.
 742     if [expr $x==23] then { pass $testname } else { fail $testname }
 743 }
 744
 745 proc do_shift {} {
 746     set testname "shift.s: shift tests"
 747     set x 0
 748
 749     gas_start "shift.s" "-al"
 750
 751     # Instead of having a variable for each match string just increment the
 752     # total number of matches seen.  That's simpler when testing large numbers
 753     # of instructions (as these tests to).
 754     while 1 {
 755         expect {
 756             -re "^ +\[0-9\]+ 0000 F2B6\[^\n\]*\n"       { set x [expr $x+1] }
 757             -re "^ +\[0-9\]+ 0002 F8CA04\[^\n\]*\n"     { set x [expr $x+1] }
 758             -re "^ +\[0-9\]+ 0005 F2AB\[^\n\]*\n"       { set x [expr $x+1] }
 759             -re "^ +\[0-9\]+ 0007 F8C704\[^\n\]*\n"     { set x [expr $x+1] }
 760             -re "^ +\[0-9\]+ 000a F29E\[^\n\]*\n"       { set x [expr $x+1] }
 761             -re "^ +\[0-9\]+ 000c F8C204\[^\n\]*\n"     { set x [expr $x+1] }
 762             -re "^ +\[0-9\]+ 000f 56\[^\n\]*\n"         { set x [expr $x+1] }
 763             -re "^ +\[0-9\]+ 0010 F285\[^\n\]*\n"       { set x [expr $x+1] }
 764             -re "^ +\[0-9\]+ 0012 F282\[^\n\]*\n"       { set x [expr $x+1] }
 765             -re "\[^\n\]*\n"                            { }
 766             timeout                             { perror "timeout\n"; break }
 767             eof                                 { break }
 768         }
 769     }
 770
 771     # This was intended to do any cleanup necessary.  It kinda looks like it
 772     # isn't needed, but just in case, please keep it in for now.
 773     gas_finish
 774
 775     # Did we find what we were looking for?  If not, flunk it.
 776     if [expr $x==9] then { pass $testname } else { fail $testname }
 777 }
 778
 779 proc do_sub {} {
 780     set testname "sub.s: sub tests"
 781     set x 0
 782
 783     gas_start "sub.s" "-al"
 784
 785     # Instead of having a variable for each match string just increment the
 786     # total number of matches seen.  That's simpler when testing large numbers
 787     # of instructions (as these tests to).
 788     while 1 {
 789         expect {
 790             -re "^ +\[0-9\]+ 0000 F106\[^\n\]*\n"       { set x [expr $x+1] }
 791             -re "^ +\[0-9\]+ 0002 F12B\[^\n\]*\n"       { set x [expr $x+1] }
 792             -re "^ +\[0-9\]+ 0004 F11F\[^\n\]*\n"       { set x [expr $x+1] }
 793             -re "^ +\[0-9\]+ 0006 F13E\[^\n\]*\n"       { set x [expr $x+1] }
 794             -re "^ +\[0-9\]+ 0008 FCC6FFFF \[^\n\]*\n"  { set x [expr $x+1] }
 795             -re "^ +6 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 796             -re "^ +\[0-9\]+ 000e FCD5FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 797             -re "^ +7 +0100\[^\n\]*\n"                  { set x [expr $x+1] }
 798             -re "^ +\[0-9\]+ 0014 F186\[^\n\]*\n"       { set x [expr $x+1] }
 799             -re "\[^\n\]*\n"                            { }
 800             timeout                             { perror "timeout\n"; break }
 801             eof                                 { break }
 802         }
 803     }
 804
 805     # This was intended to do any cleanup necessary.  It kinda looks like it
 806     # isn't needed, but just in case, please keep it in for now.
 807     gas_finish
 808
 809     # Did we find what we were looking for?  If not, flunk it.
 810     if [expr $x==9] then { pass $testname } else { fail $testname }
 811 }
 812
 813 proc do_udf {} {
 814     set testname "udf.s: udf tests part 1"
 815     set x 0
 816
 817     gas_start "udf.s" "-al"
 818
 819     # Instead of having a variable for each match string just increment the
 820     # total number of matches seen.  That's simpler when testing large numbers
 821     # of instructions (as these tests to).
 822     while 1 {
 823         expect {
 824             -re "^ +\[0-9\]+ 0000 F601\[^\n\]*\n"       { set x [expr $x+1] }
 825             -re "^ +\[0-9\]+ 0002 F611\[^\n\]*\n"       { set x [expr $x+1] }
 826             -re "^ +\[0-9\]+ 0004 F621\[^\n\]*\n"       { set x [expr $x+1] }
 827             -re "^ +\[0-9\]+ 0006 F631\[^\n\]*\n"       { set x [expr $x+1] }
 828             -re "^ +\[0-9\]+ 0008 F641\[^\n\]*\n"       { set x [expr $x+1] }
 829             -re "^ +\[0-9\]+ 000a F651\[^\n\]*\n"       { set x [expr $x+1] }
 830             -re "^ +\[0-9\]+ 000c F661\[^\n\]*\n"       { set x [expr $x+1] }
 831             -re "^ +\[0-9\]+ 000e F671\[^\n\]*\n"       { set x [expr $x+1] }
 832             -re "^ +\[0-9\]+ 0010 F681\[^\n\]*\n"       { set x [expr $x+1] }
 833             -re "^ +\[0-9\]+ 0012 F691\[^\n\]*\n"       { set x [expr $x+1] }
 834             -re "^ +\[0-9\]+ 0014 F6A1\[^\n\]*\n"       { set x [expr $x+1] }
 835             -re "^ +\[0-9\]+ 0016 F6B1\[^\n\]*\n"       { set x [expr $x+1] }
 836             -re "^ +\[0-9\]+ 0018 F6C1\[^\n\]*\n"       { set x [expr $x+1] }
 837             -re "^ +\[0-9\]+ 001a F6D1\[^\n\]*\n"       { set x [expr $x+1] }
 838             -re "^ +\[0-9\]+ 001c F6E1\[^\n\]*\n"       { set x [expr $x+1] }
 839             -re "^ +\[0-9\]+ 001e F6F1\[^\n\]*\n"       { set x [expr $x+1] }
 840             -re "^ +\[0-9\]+ 0020 F501\[^\n\]*\n"       { set x [expr $x+1] }
 841             -re "^ +\[0-9\]+ 0022 F511\[^\n\]*\n"       { set x [expr $x+1] }
 842             -re "^ +\[0-9\]+ 0024 F521\[^\n\]*\n"       { set x [expr $x+1] }
 843             -re "^ +\[0-9\]+ 0026 F531\[^\n\]*\n"       { set x [expr $x+1] }
 844             -re "^ +\[0-9\]+ 0028 F541\[^\n\]*\n"       { set x [expr $x+1] }
 845             -re "^ +\[0-9\]+ 002a F551\[^\n\]*\n"       { set x [expr $x+1] }
 846             -re "^ +\[0-9\]+ 002c F561\[^\n\]*\n"       { set x [expr $x+1] }
 847             -re "^ +\[0-9\]+ 002e F571\[^\n\]*\n"       { set x [expr $x+1] }
 848             -re "^ +\[0-9\]+ 0030 F581\[^\n\]*\n"       { set x [expr $x+1] }
 849             -re "^ +\[0-9\]+ 0032 F591\[^\n\]*\n"       { set x [expr $x+1] }
 850             -re "^ +\[0-9\]+ 0034 F5A1\[^\n\]*\n"       { set x [expr $x+1] }
 851             -re "^ +\[0-9\]+ 0036 F5B1\[^\n\]*\n"       { set x [expr $x+1] }
 852             -re "^ +\[0-9\]+ 0038 F5C1\[^\n\]*\n"       { set x [expr $x+1] }
 853             -re "^ +\[0-9\]+ 003a F5D1\[^\n\]*\n"       { set x [expr $x+1] }
 854             -re "^ +\[0-9\]+ 003c F5E1\[^\n\]*\n"       { set x [expr $x+1] }
 855             -re "^ +\[0-9\]+ 003e F5F1\[^\n\]*\n"       { set x [expr $x+1] }
 856             -re "^ +\[0-9\]+ 0040 F9017F\[^\n\]*\n"     { set x [expr $x+1] }
 857             -re "^ +\[0-9\]+ 0043 F9117F\[^\n\]*\n"     { set x [expr $x+1] }
 858             -re "^ +\[0-9\]+ 0046 F9217F\[^\n\]*\n"     { set x [expr $x+1] }
 859             -re "^ +\[0-9\]+ 0049 F9317F\[^\n\]*\n"     { set x [expr $x+1] }
 860             -re "^ +\[0-9\]+ 004c F9417F\[^\n\]*\n"     { set x [expr $x+1] }
 861             -re "^ +\[0-9\]+ 004f F9517F\[^\n\]*\n"     { set x [expr $x+1] }
 862             -re "^ +\[0-9\]+ 0052 F9617F\[^\n\]*\n"     { set x [expr $x+1] }
 863             -re "^ +\[0-9\]+ 0055 F9717F\[^\n\]*\n"     { set x [expr $x+1] }
 864             -re "^ +\[0-9\]+ 0058 F9817F\[^\n\]*\n"     { set x [expr $x+1] }
 865             -re "^ +\[0-9\]+ 005b F9917F\[^\n\]*\n"     { set x [expr $x+1] }
 866             -re "^ +\[0-9\]+ 005e F9A17F\[^\n\]*\n"     { set x [expr $x+1] }
 867             -re "^ +\[0-9\]+ 0061 F9B17F\[^\n\]*\n"     { set x [expr $x+1] }
 868             -re "^ +\[0-9\]+ 0064 F9C17F\[^\n\]*\n"     { set x [expr $x+1] }
 869             -re "^ +\[0-9\]+ 0067 F9D17F\[^\n\]*\n"     { set x [expr $x+1] }
 870             -re "^ +\[0-9\]+ 006a F9E17F\[^\n\]*\n"     { set x [expr $x+1] }
 871             -re "^ +\[0-9\]+ 006d F9F17F\[^\n\]*\n"     { set x [expr $x+1] }
 872             -re "^ +\[0-9\]+ 0070 FB01FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 873             -re "^ +\[0-9\]+ 0074 FB11FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 874             -re "^ +\[0-9\]+ 0078 FB21FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 875             -re "^ +\[0-9\]+ 007c FB31FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 876             -re "^ +\[0-9\]+ 0080 FB41FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 877             -re "^ +\[0-9\]+ 0084 FB51FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 878             -re "^ +\[0-9\]+ 0088 FB61FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 879             -re "^ +\[0-9\]+ 008c FB71FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 880             -re "^ +\[0-9\]+ 0090 FB81FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 881             -re "^ +\[0-9\]+ 0094 FB91FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 882             -re "^ +\[0-9\]+ 0098 FBA1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 883             -re "^ +\[0-9\]+ 009c FBB1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 884             -re "^ +\[0-9\]+ 00a0 FBC1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 885             -re "^ +\[0-9\]+ 00a4 FBD1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 886             -re "^ +\[0-9\]+ 00a8 FBE1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 887             -re "^ +\[0-9\]+ 00ac FBF1FF7F\[^\n\]*\n"   { set x [expr $x+1] }
 888             -re "^ +\[0-9\]+ 00b0 FD01FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 889             -re "^ +66 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 890             -re "^ +\[0-9\]+ 00b6 FD11FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 891             -re "^ +67 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 892             -re "^ +\[0-9\]+ 00bc FD21FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 893             -re "^ +68 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 894             -re "^ +\[0-9\]+ 00c2 FD31FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 895             -re "^ +69 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 896             -re "^ +\[0-9\]+ 00c8 FD41FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 897             -re "^ +70 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 898             -re "^ +\[0-9\]+ 00ce FD51FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 899             -re "^ +71 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 900             -re "^ +\[0-9\]+ 00d4 FD61FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 901             -re "^ +72 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 902             -re "^ +\[0-9\]+ 00da FD71FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 903             -re "^ +73 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 904             -re "^ +\[0-9\]+ 00e0 FD81FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 905             -re "^ +74 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 906             -re "^ +\[0-9\]+ 00e6 FD91FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 907             -re "^ +75 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 908             -re "^ +\[0-9\]+ 00ec FDA1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 909             -re "^ +76 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 910             -re "^ +\[0-9\]+ 00f2 FDB1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 911             -re "^ +77 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 912             -re "^ +\[0-9\]+ 00f8 FDC1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 913             -re "^ +78 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 914             -re "^ +\[0-9\]+ 00fe FDD1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 915             -re "^ +79 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 916             -re "^ +\[0-9\]+ 0104 FDE1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 917             -re "^ +80 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 918             -re "^ +\[0-9\]+ 010a FDF1FFFF\[^\n\]*\n"   { set x [expr $x+1] }
 919             -re "^ +81 +0000\[^\n\]*\n"                 { set x [expr $x+1] }
 920             -re "^ +\[0-9\]+ 0110 F90580\[^\n\]*\n"     { set x [expr $x+1] }
 921             -re "^ +\[0-9\]+ 0113 F91580\[^\n\]*\n"     { set x [expr $x+1] }
 922             -re "^ +\[0-9\]+ 0116 F92580\[^\n\]*\n"     { set x [expr $x+1] }
 923             -re "^ +\[0-9\]+ 0119 F93580\[^\n\]*\n"     { set x [expr $x+1] }
 924             -re "^ +\[0-9\]+ 011c F94580\[^\n\]*\n"     { set x [expr $x+1] }
 925             -re "^ +\[0-9\]+ 011f F95580\[^\n\]*\n"     { set x [expr $x+1] }
 926             -re "^ +\[0-9\]+ 0122 F96580\[^\n\]*\n"     { set x [expr $x+1] }
 927             -re "^ +\[0-9\]+ 0125 F97580\[^\n\]*\n"     { set x [expr $x+1] }
 928             -re "^ +\[0-9\]+ 0128 F98580\[^\n\]*\n"     { set x [expr $x+1] }
 929             -re "^ +\[0-9\]+ 012b F99580\[^\n\]*\n"     { set x [expr $x+1] }
 930             -re "^ +\[0-9\]+ 012e F9A580\[^\n\]*\n"     { set x [expr $x+1] }
 931             -re "^ +\[0-9\]+ 0131 F9B580\[^\n\]*\n"     { set x [expr $x+1] }
 932             -re "^ +\[0-9\]+ 0134 F9C580\[^\n\]*\n"     { set x [expr $x+1] }
 933             -re "^ +\[0-9\]+ 0137 F9D580\[^\n\]*\n"     { set x [expr $x+1] }
 934             -re "^ +\[0-9\]+ 013a F9E580\[^\n\]*\n"     { set x [expr $x+1] }
 935             -re "^ +\[0-9\]+ 013d F9F580\[^\n\]*\n"     { set x [expr $x+1] }
 936             -re "^ +\[0-9\]+ 0140 FB050080\[^\n\]*\n"   { set x [expr $x+1] }
 937             -re "^ +\[0-9\]+ 0144 FB150080\[^\n\]*\n"   { set x [expr $x+1] }
 938             -re "^ +\[0-9\]+ 0148 FB250080\[^\n\]*\n"   { set x [expr $x+1] }
 939             -re "^ +\[0-9\]+ 014c FB350080\[^\n\]*\n"   { set x [expr $x+1] }
 940             -re "^ +\[0-9\]+ 0150 FB450080\[^\n\]*\n"   { set x [expr $x+1] }
 941             -re "^ +\[0-9\]+ 0154 FB550080\[^\n\]*\n"   { set x [expr $x+1] }
 942             -re "^ +\[0-9\]+ 0158 FB650080\[^\n\]*\n"   { set x [expr $x+1] }
 943             -re "^ +\[0-9\]+ 015c FB750080\[^\n\]*\n"   { set x [expr $x+1] }
 944             -re "^ +\[0-9\]+ 0160 FB850080\[^\n\]*\n"   { set x [expr $x+1] }
 945             -re "^ +\[0-9\]+ 0164 FB950080\[^\n\]*\n"   { set x [expr $x+1] }
 946             -re "^ +\[0-9\]+ 0168 FBA50080\[^\n\]*\n"   { set x [expr $x+1] }
 947             -re "^ +\[0-9\]+ 016c FBB50080\[^\n\]*\n"   { set x [expr $x+1] }
 948             -re "^ +\[0-9\]+ 0170 FBC50080\[^\n\]*\n"   { set x [expr $x+1] }
 949             -re "^ +\[0-9\]+ 0174 FBD50080\[^\n\]*\n"   { set x [expr $x+1] }
 950             -re "^ +\[0-9\]+ 0178 FBE50080\[^\n\]*\n"   { set x [expr $x+1] }
 951             -re "^ +\[0-9\]+ 017c FBF50080\[^\n\]*\n"   { set x [expr $x+1] }
 952             -re "^ +\[0-9\]+ 0180 FD050000\[^\n\]*\n"   { set x [expr $x+1] }
 953             -re "^ +114 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 954             -re "^ +\[0-9\]+ 0186 FD150000\[^\n\]*\n"   { set x [expr $x+1] }
 955             -re "^ +115 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 956             -re "^ +\[0-9\]+ 018c FD250000\[^\n\]*\n"   { set x [expr $x+1] }
 957             -re "^ +116 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 958             -re "^ +\[0-9\]+ 0192 FD350000\[^\n\]*\n"   { set x [expr $x+1] }
 959             -re "^ +117 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 960             -re "^ +\[0-9\]+ 0198 FD450000\[^\n\]*\n"   { set x [expr $x+1] }
 961             -re "^ +118 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 962             -re "^ +\[0-9\]+ 019e FD550000\[^\n\]*\n"   { set x [expr $x+1] }
 963             -re "^ +119 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 964             -re "^ +\[0-9\]+ 01a4 FD650000\[^\n\]*\n"   { set x [expr $x+1] }
 965             -re "^ +120 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 966             -re "^ +\[0-9\]+ 01aa FD750000\[^\n\]*\n"   { set x [expr $x+1] }
 967             -re "^ +121 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 968             -re "^ +\[0-9\]+ 01b0 FD850000\[^\n\]*\n"   { set x [expr $x+1] }
 969             -re "^ +122 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 970             -re "^ +\[0-9\]+ 01b6 FD950000\[^\n\]*\n"   { set x [expr $x+1] }
 971             -re "^ +123 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 972             -re "^ +\[0-9\]+ 01bc FDA50000\[^\n\]*\n"   { set x [expr $x+1] }
 973             -re "^ +124 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 974             -re "^ +\[0-9\]+ 01c2 FDB50000\[^\n\]*\n"   { set x [expr $x+1] }
 975             -re "^ +125 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 976             -re "^ +\[0-9\]+ 01c8 FDC50000\[^\n\]*\n"   { set x [expr $x+1] }
 977             -re "^ +126 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 978             -re "^ +\[0-9\]+ 01ce FDD50000\[^\n\]*\n"   { set x [expr $x+1] }
 979             -re "^ +127 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 980             -re "^ +\[0-9\]+ 01d4 FDE50000\[^\n\]*\n"   { set x [expr $x+1] }
 981             -re "^ +128 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 982             -re "^ +\[0-9\]+ 01da FDF50000\[^\n\]*\n"   { set x [expr $x+1] }
 983             -re "^ +129 +0100\[^\n\]*\n"                { set x [expr $x+1] }
 984             -re "\[^\n\]*\n"                            { }
 985             timeout                             { perror "timeout\n"; break }
 986             eof                                 { break }
 987         }
 988     }
 989
 990     # This was intended to do any cleanup necessary.  It kinda looks like it
 991     # isn't needed, but just in case, please keep it in for now.
 992     gas_finish
 993
 994     # Did we find what we were looking for?  If not, flunk it.
 995     if [expr $x==160] then { pass $testname } else { fail $testname }
 996 }
 997
 998 proc do_am33_1 {} {
 999     set testname "am33.s: am33 tests part 1"
1000     set x 0
1001
1002     gas_start "am33.s" "-al"
1003
1004     # Instead of having a variable for each match string just increment the
1005     # total number of matches seen.  That's simpler when testing large numbers
1006     # of instructions (as these tests to).
1007     while 1 {
1008         expect {
1009             -re "^ +\[0-9\]+ 0000 CD000134\[^\n\]*\n"   { set x [expr $x+1] }
1010             -re "^ +3 +09\[^\n\]*\n"                    { set x [expr $x+1] }
1011             -re "^ +\[0-9\]+ 0005 CD000132\[^\n\]*\n"   { set x [expr $x+1] }
1012             -re "^ +4 +09\[^\n\]*\n"                    { set x [expr $x+1] }
1013             -re "^ +\[0-9\]+ 000a CD000131\[^\n\]*\n"   { set x [expr $x+1] }
1014             -re "^ +5 +09\[^\n\]*\n"                    { set x [expr $x+1] }
1015             -re "^ +\[0-9\]+ 000f CD0001FF\[^\n\]*\n"   { set x [expr $x+1] }
1016             -re "^ +6 +09\[^\n\]*\n"                    { set x [expr $x+1] }
1017             -re "^ +\[0-9\]+ 0014 DDFFFF01\[^\n\]*\n"   { set x [expr $x+1] }
1018             -re "^ +7 +003409\[^\n\]*\n"                { set x [expr $x+1] }
1019             -re "^ +\[0-9\]+ 001b DDFFFF01\[^\n\]*\n"   { set x [expr $x+1] }
1020             -re "^ +8 +003209\[^\n\]*\n"                { set x [expr $x+1] }
1021             -re "^ +\[0-9\]+ 0022 DDFFFF01\[^\n\]*\n"   { set x [expr $x+1] }
1022             -re "^ +9 +003109\[^\n\]*\n"                { set x [expr $x+1] }
1023             -re "^ +\[0-9\]+ 0029 DDFFFF01\[^\n\]*\n"   { set x [expr $x+1] }
1024             -re "^ +10 +00FF09\[^\n\]*\n"               { set x [expr $x+1] }
1025             -re "^ +\[0-9\]+ 0030 CE34\[^\n\]*\n"       { set x [expr $x+1] }
1026             -re "^ +\[0-9\]+ 0032 CE32\[^\n\]*\n"       { set x [expr $x+1] }
1027             -re "^ +\[0-9\]+ 0034 CE31\[^\n\]*\n"       { set x [expr $x+1] }
1028             -re "^ +\[0-9\]+ 0036 CEFF\[^\n\]*\n"       { set x [expr $x+1] }
1029             -re "^ +\[0-9\]+ 0038 CF34\[^\n\]*\n"       { set x [expr $x+1] }
1030             -re "^ +\[0-9\]+ 003a CF32\[^\n\]*\n"       { set x [expr $x+1] }
1031             -re "^ +\[0-9\]+ 003c CF31\[^\n\]*\n"       { set x [expr $x+1] }
1032             -re "^ +\[0-9\]+ 003e CFFF\[^\n\]*\n"       { set x [expr $x+1] }
1033             -re "^ +\[0-9\]+ 0040 F8CE34\[^\n\]*\n"     { set x [expr $x+1] }
1034             -re "^ +\[0-9\]+ 0043 F8CE32\[^\n\]*\n"     { set x [expr $x+1] }
1035             -re "^ +\[0-9\]+ 0046 F8CE31\[^\n\]*\n"     { set x [expr $x+1] }
1036             -re "^ +\[0-9\]+ 0049 F8CEFF\[^\n\]*\n"     { set x [expr $x+1] }
1037             -re "^ +\[0-9\]+ 004c F8CF34\[^\n\]*\n"     { set x [expr $x+1] }
1038             -re "^ +\[0-9\]+ 004f F8CF32\[^\n\]*\n"     { set x [expr $x+1] }
1039             -re "^ +\[0-9\]+ 0052 F8CF31\[^\n\]*\n"     { set x [expr $x+1] }
1040             -re "^ +\[0-9\]+ 0055 F8CFFF\[^\n\]*\n"     { set x [expr $x+1] }
1041             -re "^ +\[0-9\]+ 0058 F020\[^\n\]*\n"       { set x [expr $x+1] }
1042             -re "^ +\[0-9\]+ 005a F025\[^\n\]*\n"       { set x [expr $x+1] }
1043             -re "^ +\[0-9\]+ 005c F02A\[^\n\]*\n"       { set x [expr $x+1] }
1044             -re "^ +\[0-9\]+ 005e F02F\[^\n\]*\n"       { set x [expr $x+1] }
1045             -re "^ +\[0-9\]+ 0060 F030\[^\n\]*\n"       { set x [expr $x+1] }
1046             -re "^ +\[0-9\]+ 0062 F035\[^\n\]*\n"       { set x [expr $x+1] }
1047             -re "^ +\[0-9\]+ 0064 F03A\[^\n\]*\n"       { set x [expr $x+1] }
1048             -re "^ +\[0-9\]+ 0066 F0E4\[^\n\]*\n"       { set x [expr $x+1] }
1049             -re "^ +\[0-9\]+ 0068 F2EC\[^\n\]*\n"       { set x [expr $x+1] }
1050             -re "^ +\[0-9\]+ 006a F2F5\[^\n\]*\n"       { set x [expr $x+1] }
1051             -re "^ +\[0-9\]+ 006c F501\[^\n\]*\n"       { set x [expr $x+1] }
1052             -re "^ +\[0-9\]+ 006e F563\[^\n\]*\n"       { set x [expr $x+1] }
1053             -re "^ +\[0-9\]+ 0070 F595\[^\n\]*\n"       { set x [expr $x+1] }
1054             -re "^ +\[0-9\]+ 0072 F5DF\[^\n\]*\n"       { set x [expr $x+1] }
1055             -re "^ +\[0-9\]+ 0074 F630\[^\n\]*\n"       { set x [expr $x+1] }
1056             -re "^ +\[0-9\]+ 0076 F665\[^\n\]*\n"       { set x [expr $x+1] }
1057             -re "^ +\[0-9\]+ 0078 F6C0\[^\n\]*\n"       { set x [expr $x+1] }
1058             -re "^ +\[0-9\]+ 007a F6D5\[^\n\]*\n"       { set x [expr $x+1] }
1059             -re "^ +\[0-9\]+ 007c FCFC0000\[^\n\]*\n"   { set x [expr $x+1] }
1060             -re "^ +45 +0200\[^\n\]*\n"         { set x [expr $x+1] }
1061             -re "^ +\[0-9\]+ 0082 FCFDFFFF\[^\n\]*\n"   { set x [expr $x+1] }
1062             -re "^ +46 +0000\[^\n\]*\n"         { set x [expr $x+1] }
1063             -re "\[^\n\]*\n"                            { }
1064             timeout                             { perror "timeout\n"; break }
1065             eof                                 { break }
1066         }
1067     }
1068
1069     # This was intended to do any cleanup necessary.  It kinda looks like it
1070     # isn't needed, but just in case, please keep it in for now.
1071     gas_finish
1072
1073     # Did we find what we were looking for?  If not, flunk it.
1074     if [expr $x==54] then { pass $testname } else { fail $testname }
1075 }
1076
1077 proc do_am33_2 {} {
1078     set testname "am33_2.s: am33 tests part 2"
1079     set x 0
1080
1081     gas_start "am33_2.s" "-al"
1082
1083     # Instead of having a variable for each match string just increment the
1084     # total number of matches seen.  That's simpler when testing large numbers
1085     # of instructions (as these tests to).
1086     while 1 {
1087         expect {
1088             -re "^ +\[0-9\]+ 0000 F90801\[^\n\]*\n"     { set x [expr $x+1] }
1089             -re "^ +\[0-9\]+ 0003 F91822\[^\n\]*\n"     { set x [expr $x+1] }
1090             -re "^ +\[0-9\]+ 0006 F92834\[^\n\]*\n"     { set x [expr $x+1] }
1091             -re "^ +\[0-9\]+ 0009 F93845\[^\n\]*\n"     { set x [expr $x+1] }
1092             -re "^ +\[0-9\]+ 000c F94867\[^\n\]*\n"     { set x [expr $x+1] }
1093             -re "^ +\[0-9\]+ 000f F95878\[^\n\]*\n"     { set x [expr $x+1] }
1094             -re "^ +\[0-9\]+ 0012 F96899\[^\n\]*\n"     { set x [expr $x+1] }
1095             -re "^ +\[0-9\]+ 0015 F978AB\[^\n\]*\n"     { set x [expr $x+1] }
1096             -re "^ +\[0-9\]+ 0018 F988CD\[^\n\]*\n"     { set x [expr $x+1] }
1097             -re "^ +\[0-9\]+ 001b F998EF\[^\n\]*\n"     { set x [expr $x+1] }
1098             -re "^ +\[0-9\]+ 001e F9A8FE\[^\n\]*\n"     { set x [expr $x+1] }
1099             -re "^ +\[0-9\]+ 0021 F9B8DD\[^\n\]*\n"     { set x [expr $x+1] }
1100             -re "^ +\[0-9\]+ 0024 F9C8CC\[^\n\]*\n"     { set x [expr $x+1] }
1101             -re "^ +\[0-9\]+ 0027 F9D8BA\[^\n\]*\n"     { set x [expr $x+1] }
1102             -re "^ +\[0-9\]+ 002a F9E801\[^\n\]*\n"     { set x [expr $x+1] }
1103             -re "^ +\[0-9\]+ 002d F9F812\[^\n\]*\n"     { set x [expr $x+1] }
1104             -re "^ +\[0-9\]+ 0030 F90901\[^\n\]*\n"     { set x [expr $x+1] }
1105             -re "^ +\[0-9\]+ 0033 F91923\[^\n\]*\n"     { set x [expr $x+1] }
1106             -re "^ +\[0-9\]+ 0036 F92945\[^\n\]*\n"     { set x [expr $x+1] }
1107             -re "^ +\[0-9\]+ 0039 F93966\[^\n\]*\n"     { set x [expr $x+1] }
1108             -re "^ +\[0-9\]+ 003c F94978\[^\n\]*\n"     { set x [expr $x+1] }
1109             -re "^ +\[0-9\]+ 003f F9599A\[^\n\]*\n"     { set x [expr $x+1] }
1110             -re "^ +\[0-9\]+ 0042 F969BC\[^\n\]*\n"     { set x [expr $x+1] }
1111             -re "^ +\[0-9\]+ 0045 F979DD\[^\n\]*\n"     { set x [expr $x+1] }
1112             -re "^ +\[0-9\]+ 0048 F989EE\[^\n\]*\n"     { set x [expr $x+1] }
1113             -re "^ +\[0-9\]+ 004b F999FF\[^\n\]*\n"     { set x [expr $x+1] }
1114             -re "^ +\[0-9\]+ 004e F9A912\[^\n\]*\n"     { set x [expr $x+1] }
1115             -re "^ +\[0-9\]+ 0051 F9B934\[^\n\]*\n"     { set x [expr $x+1] }
1116             -re "^ +\[0-9\]+ 0054 F9C956\[^\n\]*\n"     { set x [expr $x+1] }
1117             -re "^ +\[0-9\]+ 0057 F9D978\[^\n\]*\n"     { set x [expr $x+1] }
1118             -re "^ +\[0-9\]+ 005a F90A21\[^\n\]*\n"     { set x [expr $x+1] }
1119             -re "^ +\[0-9\]+ 005d F91A34\[^\n\]*\n"     { set x [expr $x+1] }
1120             -re "^ +\[0-9\]+ 0060 F92A65\[^\n\]*\n"     { set x [expr $x+1] }
1121             -re "^ +\[0-9\]+ 0063 F93A78\[^\n\]*\n"     { set x [expr $x+1] }
1122             -re "^ +\[0-9\]+ 0066 F94AA9\[^\n\]*\n"     { set x [expr $x+1] }
1123             -re "^ +\[0-9\]+ 0069 F95ABC\[^\n\]*\n"     { set x [expr $x+1] }
1124             -re "^ +\[0-9\]+ 006c F96A21\[^\n\]*\n"     { set x [expr $x+1] }
1125             -re "^ +\[0-9\]+ 006f F97A34\[^\n\]*\n"     { set x [expr $x+1] }
1126             -re "^ +\[0-9\]+ 0072 F98A50\[^\n\]*\n"     { set x [expr $x+1] }
1127             -re "^ +\[0-9\]+ 0075 F99A60\[^\n\]*\n"     { set x [expr $x+1] }
1128             -re "^ +\[0-9\]+ 0078 F9AA70\[^\n\]*\n"     { set x [expr $x+1] }
1129             -re "^ +\[0-9\]+ 007b F9BA80\[^\n\]*\n"     { set x [expr $x+1] }
1130             -re "^ +\[0-9\]+ 007e F9CA90\[^\n\]*\n"     { set x [expr $x+1] }
1131             -re "^ +\[0-9\]+ 0081 F9DAA0\[^\n\]*\n"     { set x [expr $x+1] }
1132             -re "^ +\[0-9\]+ 0084 F9EA76\[^\n\]*\n"     { set x [expr $x+1] }
1133             -re "^ +\[0-9\]+ 0087 F9FA89\[^\n\]*\n"     { set x [expr $x+1] }
1134             -re "^ +\[0-9\]+ 008a F90B12\[^\n\]*\n"     { set x [expr $x+1] }
1135             -re "^ +\[0-9\]+ 008d F91B34\[^\n\]*\n"     { set x [expr $x+1] }
1136             -re "^ +\[0-9\]+ 0090 F92B56\[^\n\]*\n"     { set x [expr $x+1] }
1137             -re "^ +\[0-9\]+ 0093 F93B78\[^\n\]*\n"     { set x [expr $x+1] }
1138             -re "^ +\[0-9\]+ 0096 F94B9A\[^\n\]*\n"     { set x [expr $x+1] }
1139             -re "^ +\[0-9\]+ 0099 F95BBC\[^\n\]*\n"     { set x [expr $x+1] }
1140             -re "^ +\[0-9\]+ 009c F96BDE\[^\n\]*\n"     { set x [expr $x+1] }
1141             -re "^ +\[0-9\]+ 009f F97BFE\[^\n\]*\n"     { set x [expr $x+1] }
1142             -re "^ +\[0-9\]+ 00a2 F98BDC\[^\n\]*\n"     { set x [expr $x+1] }
1143             -re "^ +\[0-9\]+ 00a5 F99BBA\[^\n\]*\n"     { set x [expr $x+1] }
1144             -re "^ +\[0-9\]+ 00a8 F9AB98\[^\n\]*\n"     { set x [expr $x+1] }
1145             -re "^ +\[0-9\]+ 00ab F9BB76\[^\n\]*\n"     { set x [expr $x+1] }
1146             -re "^ +\[0-9\]+ 00ae F9CB54\[^\n\]*\n"     { set x [expr $x+1] }
1147             -re "^ +\[0-9\]+ 00b1 F9DB32\[^\n\]*\n"     { set x [expr $x+1] }
1148             -re "^ +\[0-9\]+ 00b4 F9EB10\[^\n\]*\n"     { set x [expr $x+1] }
1149             -re "^ +\[0-9\]+ 00b7 F9FB12\[^\n\]*\n"     { set x [expr $x+1] }
1150             -re "\[^\n\]*\n"                            { }
1151             timeout                             { perror "timeout\n"; break }
1152             eof                                 { break }
1153         }
1154     }
1155
1156     # This was intended to do any cleanup necessary.  It kinda looks like it
1157     # isn't needed, but just in case, please keep it in for now.
1158     gas_finish
1159
1160     # Did we find what we were looking for?  If not, flunk it.
1161     if [expr $x==62] then { pass $testname } else { fail $testname }
1162 }
1163
1164 proc do_am33_3 {} {
1165     set testname "am33_3.s: am33 tests part 3"
1166     set x 0
1167
1168     gas_start "am33_3.s" "-al"
1169
1170     # Instead of having a variable for each match string just increment the
1171     # total number of matches seen.  That's simpler when testing large numbers
1172     # of instructions (as these tests to).
1173     while 1 {
1174         expect {
1175             -re "^ +\[0-9\]+ 0000 FB081110\[^\n\]*\n"   { set x [expr $x+1] }
1176             -re "^ +\[0-9\]+ 0004 FB181110\[^\n\]*\n"   { set x [expr $x+1] }
1177             -re "^ +\[0-9\]+ 0008 FB781110\[^\n\]*\n"   { set x [expr $x+1] }
1178             -re "^ +\[0-9\]+ 000c FB881110\[^\n\]*\n"   { set x [expr $x+1] }
1179             -re "^ +\[0-9\]+ 0010 FB981110\[^\n\]*\n"   { set x [expr $x+1] }
1180             -re "^ +\[0-9\]+ 0014 FBA81110\[^\n\]*\n"   { set x [expr $x+1] }
1181             -re "^ +\[0-9\]+ 0018 FBD81110\[^\n\]*\n"   { set x [expr $x+1] }
1182             -re "^ +\[0-9\]+ 001c FBF81110\[^\n\]*\n"   { set x [expr $x+1] }
1183             -re "^ +\[0-9\]+ 0020 FB091110\[^\n\]*\n"   { set x [expr $x+1] }
1184             -re "^ +\[0-9\]+ 0024 FB191110\[^\n\]*\n"   { set x [expr $x+1] }
1185             -re "^ +\[0-9\]+ 0028 FB291110\[^\n\]*\n"   { set x [expr $x+1] }
1186             -re "^ +\[0-9\]+ 002c FB491110\[^\n\]*\n"   { set x [expr $x+1] }
1187             -re "^ +\[0-9\]+ 0030 FB591110\[^\n\]*\n"   { set x [expr $x+1] }
1188             -re "^ +\[0-9\]+ 0034 FB691110\[^\n\]*\n"   { set x [expr $x+1] }
1189             -re "^ +\[0-9\]+ 0038 FBA91110\[^\n\]*\n"   { set x [expr $x+1] }
1190             -re "^ +\[0-9\]+ 003c FBB91110\[^\n\]*\n"   { set x [expr $x+1] }
1191             -re "^ +\[0-9\]+ 0040 FBE91110\[^\n\]*\n"   { set x [expr $x+1] }
1192             -re "^ +\[0-9\]+ 0044 FB0A2110\[^\n\]*\n"   { set x [expr $x+1] }
1193             -re "^ +\[0-9\]+ 0048 FB1A2110\[^\n\]*\n"   { set x [expr $x+1] }
1194             -re "^ +\[0-9\]+ 004c FB2A2110\[^\n\]*\n"   { set x [expr $x+1] }
1195             -re "^ +\[0-9\]+ 0050 FB3A2110\[^\n\]*\n"   { set x [expr $x+1] }
1196             -re "^ +\[0-9\]+ 0054 FB4A2110\[^\n\]*\n"   { set x [expr $x+1] }
1197             -re "^ +\[0-9\]+ 0058 FB5A2110\[^\n\]*\n"   { set x [expr $x+1] }
1198             -re "^ +\[0-9\]+ 005c FB8A2010\[^\n\]*\n"   { set x [expr $x+1] }
1199             -re "^ +\[0-9\]+ 0060 FB9A2010\[^\n\]*\n"   { set x [expr $x+1] }
1200             -re "^ +\[0-9\]+ 0064 FBAA2010\[^\n\]*\n"   { set x [expr $x+1] }
1201             -re "^ +\[0-9\]+ 0068 FBBA2010\[^\n\]*\n"   { set x [expr $x+1] }
1202             -re "^ +\[0-9\]+ 006c FBCA2010\[^\n\]*\n"   { set x [expr $x+1] }
1203             -re "^ +\[0-9\]+ 0070 FBDA2010\[^\n\]*\n"   { set x [expr $x+1] }
1204             -re "^ +\[0-9\]+ 0074 FB0B1110\[^\n\]*\n"   { set x [expr $x+1] }
1205             -re "^ +\[0-9\]+ 0078 FB1B1110\[^\n\]*\n"   { set x [expr $x+1] }
1206             -re "^ +\[0-9\]+ 007c FB2B1110\[^\n\]*\n"   { set x [expr $x+1] }
1207             -re "^ +\[0-9\]+ 0080 FB3B1110\[^\n\]*\n"   { set x [expr $x+1] }
1208             -re "^ +\[0-9\]+ 0084 FB4B1110\[^\n\]*\n"   { set x [expr $x+1] }
1209             -re "^ +\[0-9\]+ 0088 FB5B1110\[^\n\]*\n"   { set x [expr $x+1] }
1210             -re "^ +\[0-9\]+ 008c FBBB1110\[^\n\]*\n"   { set x [expr $x+1] }
1211             -re "^ +\[0-9\]+ 0090 FB7C1230\[^\n\]*\n"   { set x [expr $x+1] }
1212             -re "^ +\[0-9\]+ 0094 FB6A2110\[^\n\]*\n"   { set x [expr $x+1] }
1213             -re "^ +\[0-9\]+ 0098 FB7A1210\[^\n\]*\n"   { set x [expr $x+1] }
1214             -re "^ +\[0-9\]+ 009c FBEA2110\[^\n\]*\n"   { set x [expr $x+1] }
1215             -re "^ +\[0-9\]+ 00a0 FBFA1210\[^\n\]*\n"   { set x [expr $x+1] }
1216             -re "\[^\n\]*\n"                            { }
1217             timeout                             { perror "timeout\n"; break }
1218             eof                                 { break }
1219         }
1220     }
1221
1222     # This was intended to do any cleanup necessary.  It kinda looks like it
1223     # isn't needed, but just in case, please keep it in for now.
1224     gas_finish
1225
1226     # Did we find what we were looking for?  If not, flunk it.
1227     if [expr $x==41] then { pass $testname } else { fail $testname }
1228 }
1229
1230 proc do_am33_4 {} {
1231     set testname "am33_4.s: am33 tests part 4"
1232     set x 0
1233
1234     gas_start "am33_4.s" "-al"
1235
1236     # Instead of having a variable for each match string just increment the
1237     # total number of matches seen.  That's simpler when testing large numbers
1238     # of instructions (as these tests to).
1239     while 1 {
1240         expect {
1241             -re "^ +\[0-9\]+ 0000 FD0822FF\[^\n\]*\n"   { set x [expr $x+1] }
1242             -re "^ +3 +FE1F\[^\n\]*\n"          { set x [expr $x+1] }
1243             -re "^ +\[0-9\]+ 0006 FD1822FF\[^\n\]*\n"   { set x [expr $x+1] }
1244             -re "^ +4 +FE1F\[^\n\]*\n"          { set x [expr $x+1] }
1245             -re "^ +\[0-9\]+ 000c FD7822FF\[^\n\]*\n"   { set x [expr $x+1] }
1246             -re "^ +5 +FE1F\[^\n\]*\n"          { set x [expr $x+1] }
1247             -re "^ +\[0-9\]+ 0012 FD8822FF\[^\n\]*\n"   { set x [expr $x+1] }
1248             -re "^ +6 +FE1F\[^\n\]*\n"          { set x [expr $x+1] }
1249             -re "^ +\[0-9\]+ 0018 FD9822FF\[^\n\]*\n"   { set x [expr $x+1] }
1250             -re "^ +7 +FE1F\[^\n\]*\n"          { set x [expr $x+1] }
1251             -re "^ +\[0-9\]+ 001e FDA822FF\[^\n\]*\n"   { set x [expr $x+1] }
1252             -re "^ +8 +FE1F\[^\n\]*\n"          { set x [expr $x+1] }
1253             -re "^ +\[0-9\]+ 0024 FDD822FF\[^\n\]*\n"   { set x [expr $x+1] }
1254             -re "^ +9 +FE1F\[^\n\]*\n"          { set x [expr $x+1] }
1255             -re "^ +\[0-9\]+ 002a FDF822FF\[^\n\]*\n"   { set x [expr $x+1] }
1256             -re "^ +10 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1257             -re "^ +\[0-9\]+ 0030 FD0922FF\[^\n\]*\n"   { set x [expr $x+1] }
1258             -re "^ +11 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1259             -re "^ +\[0-9\]+ 0036 FD1922FF\[^\n\]*\n"   { set x [expr $x+1] }
1260             -re "^ +12 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1261             -re "^ +\[0-9\]+ 003c FD2922FF\[^\n\]*\n"   { set x [expr $x+1] }
1262             -re "^ +13 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1263             -re "^ +\[0-9\]+ 0042 FD4922FF\[^\n\]*\n"   { set x [expr $x+1] }
1264             -re "^ +14 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1265             -re "^ +\[0-9\]+ 0048 FD5922FF\[^\n\]*\n"   { set x [expr $x+1] }
1266             -re "^ +15 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1267             -re "^ +\[0-9\]+ 004e FD6922FF\[^\n\]*\n"   { set x [expr $x+1] }
1268             -re "^ +16 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1269             -re "^ +\[0-9\]+ 0054 FDA922FF\[^\n\]*\n"   { set x [expr $x+1] }
1270             -re "^ +17 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1271             -re "^ +\[0-9\]+ 005a FDB922FF\[^\n\]*\n"   { set x [expr $x+1] }
1272             -re "^ +18 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1273             -re "^ +\[0-9\]+ 0060 FDE922FF\[^\n\]*\n"   { set x [expr $x+1] }
1274             -re "^ +19 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1275             -re "^ +\[0-9\]+ 0066 FD0A21FF\[^\n\]*\n"   { set x [expr $x+1] }
1276             -re "^ +20 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1277             -re "^ +\[0-9\]+ 006c FD1A21FF\[^\n\]*\n"   { set x [expr $x+1] }
1278             -re "^ +21 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1279             -re "^ +\[0-9\]+ 0072 FD2A21FF\[^\n\]*\n"   { set x [expr $x+1] }
1280             -re "^ +22 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1281             -re "^ +\[0-9\]+ 0078 FD3A21FF\[^\n\]*\n"   { set x [expr $x+1] }
1282             -re "^ +23 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1283             -re "^ +\[0-9\]+ 007e FD4A21FF\[^\n\]*\n"   { set x [expr $x+1] }
1284             -re "^ +24 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1285             -re "^ +\[0-9\]+ 0084 FD5A21FF\[^\n\]*\n"   { set x [expr $x+1] }
1286             -re "^ +25 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1287             -re "^ +\[0-9\]+ 008a FD8A20FF\[^\n\]*\n"   { set x [expr $x+1] }
1288             -re "^ +26 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1289             -re "^ +\[0-9\]+ 0090 FD9A20FF\[^\n\]*\n"   { set x [expr $x+1] }
1290             -re "^ +27 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1291             -re "^ +\[0-9\]+ 0096 FDAA20FF\[^\n\]*\n"   { set x [expr $x+1] }
1292             -re "^ +28 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1293             -re "^ +\[0-9\]+ 009c FDBA20FF\[^\n\]*\n"   { set x [expr $x+1] }
1294             -re "^ +29 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1295             -re "^ +\[0-9\]+ 00a2 FDCA20FF\[^\n\]*\n"   { set x [expr $x+1] }
1296             -re "^ +30 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1297             -re "^ +\[0-9\]+ 00a8 FDDA20FF\[^\n\]*\n"   { set x [expr $x+1] }
1298             -re "^ +31 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1299             -re "^ +\[0-9\]+ 00ae FD0B22FF\[^\n\]*\n"   { set x [expr $x+1] }
1300             -re "^ +32 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1301             -re "^ +\[0-9\]+ 00b4 FD1B22FF\[^\n\]*\n"   { set x [expr $x+1] }
1302             -re "^ +33 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1303             -re "^ +\[0-9\]+ 00ba FD2B22FF\[^\n\]*\n"   { set x [expr $x+1] }
1304             -re "^ +34 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1305             -re "^ +\[0-9\]+ 00c0 FD3B22FF\[^\n\]*\n"   { set x [expr $x+1] }
1306             -re "^ +35 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1307             -re "^ +\[0-9\]+ 00c6 FD4B22FF\[^\n\]*\n"   { set x [expr $x+1] }
1308             -re "^ +36 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1309             -re "^ +\[0-9\]+ 00cc FD5B22FF\[^\n\]*\n"   { set x [expr $x+1] }
1310             -re "^ +37 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1311             -re "^ +\[0-9\]+ 00d2 FD0E20FF\[^\n\]*\n"   { set x [expr $x+1] }
1312             -re "^ +38 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1313             -re "^ +\[0-9\]+ 00d8 FD1E20FF\[^\n\]*\n"   { set x [expr $x+1] }
1314             -re "^ +39 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1315             -re "^ +\[0-9\]+ 00de FD2E20FF\[^\n\]*\n"   { set x [expr $x+1] }
1316             -re "^ +40 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1317             -re "^ +\[0-9\]+ 00e4 FD3E20FF\[^\n\]*\n"   { set x [expr $x+1] }
1318             -re "^ +41 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1319             -re "^ +\[0-9\]+ 00ea FD4E20FF\[^\n\]*\n"   { set x [expr $x+1] }
1320             -re "^ +42 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1321             -re "^ +\[0-9\]+ 00f0 FD5E20FF\[^\n\]*\n"   { set x [expr $x+1] }
1322             -re "^ +43 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1323             -re "^ +\[0-9\]+ 00f6 FD6A21FF\[^\n\]*\n"   { set x [expr $x+1] }
1324             -re "^ +44 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1325             -re "^ +\[0-9\]+ 00fc FD7A12FF\[^\n\]*\n"   { set x [expr $x+1] }
1326             -re "^ +45 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1327             -re "^ +\[0-9\]+ 0102 FDEA21FF\[^\n\]*\n"   { set x [expr $x+1] }
1328             -re "^ +46 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1329             -re "^ +\[0-9\]+ 0108 FDFA12FF\[^\n\]*\n"   { set x [expr $x+1] }
1330             -re "^ +47 +FE1F\[^\n\]*\n"         { set x [expr $x+1] }
1331             -re "\[^\n\]*\n"                            { }
1332             timeout                             { perror "timeout\n"; break }
1333             eof                                 { break }
1334         }
1335     }
1336
1337     # This was intended to do any cleanup necessary.  It kinda looks like it
1338     # isn't needed, but just in case, please keep it in for now.
1339     gas_finish
1340
1341     # Did we find what we were looking for?  If not, flunk it.
1342     if [expr $x==90] then { pass $testname } else { fail $testname }
1343 }
1344
1345 proc do_am33_5 {} {
1346     set testname "am33_5.s: am33 tests part 5"
1347     set x 0
1348
1349     gas_start "am33_5.s" "-al"
1350
1351     # Instead of having a variable for each match string just increment the
1352     # total number of matches seen.  That's simpler when testing large numbers
1353     # of instructions (as these tests to).
1354     while 1 {
1355         expect {
1356             -re "^ +\[0-9\]+ 0000 FE0822FC\[^\n\]*\n"   { set x [expr $x+1] }
1357             -re "^ +3 +FDFE7F\[^\n\]*\n"                { set x [expr $x+1] }
1358             -re "^ +\[0-9\]+ 0007 FE1822FC\[^\n\]*\n"   { set x [expr $x+1] }
1359             -re "^ +4 +FDFE7F\[^\n\]*\n"                { set x [expr $x+1] }
1360             -re "^ +\[0-9\]+ 000e FE7822FC\[^\n\]*\n"   { set x [expr $x+1] }
1361             -re "^ +5 +FDFE7F\[^\n\]*\n"                { set x [expr $x+1] }
1362             -re "^ +\[0-9\]+ 0015 FE8822FC\[^\n\]*\n"   { set x [expr $x+1] }
1363             -re "^ +6 +FDFE7F\[^\n\]*\n"                { set x [expr $x+1] }
1364             -re "^ +\[0-9\]+ 001c FE9822FC\[^\n\]*\n"   { set x [expr $x+1] }
1365             -re "^ +7 +FDFE7F\[^\n\]*\n"                { set x [expr $x+1] }
1366             -re "^ +\[0-9\]+ 0023 FEA822FC\[^\n\]*\n"   { set x [expr $x+1] }
1367             -re "^ +8 +FDFE7F\[^\n\]*\n"                { set x [expr $x+1] }
1368             -re "^ +\[0-9\]+ 002a FED822FC\[^\n\]*\n"   { set x [expr $x+1] }
1369             -re "^ +9 +FDFE7F\[^\n\]*\n"                { set x [expr $x+1] }
1370             -re "^ +\[0-9\]+ 0031 FEF822FC\[^\n\]*\n"   { set x [expr $x+1] }
1371             -re "^ +10 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1372             -re "^ +\[0-9\]+ 0038 FE0922FC\[^\n\]*\n"   { set x [expr $x+1] }
1373             -re "^ +11 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1374             -re "^ +\[0-9\]+ 003f FE1922FC\[^\n\]*\n"   { set x [expr $x+1] }
1375             -re "^ +12 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1376             -re "^ +\[0-9\]+ 0046 FE2922FC\[^\n\]*\n"   { set x [expr $x+1] }
1377             -re "^ +13 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1378             -re "^ +\[0-9\]+ 004d FE4922FC\[^\n\]*\n"   { set x [expr $x+1] }
1379             -re "^ +14 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1380             -re "^ +\[0-9\]+ 0054 FE5922FC\[^\n\]*\n"   { set x [expr $x+1] }
1381             -re "^ +15 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1382             -re "^ +\[0-9\]+ 005b FE6922FC\[^\n\]*\n"   { set x [expr $x+1] }
1383             -re "^ +16 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1384             -re "^ +\[0-9\]+ 0062 FEA922FC\[^\n\]*\n"   { set x [expr $x+1] }
1385             -re "^ +17 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1386             -re "^ +\[0-9\]+ 0069 FEB922FC\[^\n\]*\n"   { set x [expr $x+1] }
1387             -re "^ +18 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1388             -re "^ +\[0-9\]+ 0070 FEE922FC\[^\n\]*\n"   { set x [expr $x+1] }
1389             -re "^ +19 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1390             -re "^ +\[0-9\]+ 0077 FE0A21FC\[^\n\]*\n"   { set x [expr $x+1] }
1391             -re "^ +20 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1392             -re "^ +\[0-9\]+ 007e FE1A21FC\[^\n\]*\n"   { set x [expr $x+1] }
1393             -re "^ +21 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1394             -re "^ +\[0-9\]+ 0085 FE2A21FC\[^\n\]*\n"   { set x [expr $x+1] }
1395             -re "^ +22 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1396             -re "^ +\[0-9\]+ 008c FE3A21FC\[^\n\]*\n"   { set x [expr $x+1] }
1397             -re "^ +23 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1398             -re "^ +\[0-9\]+ 0093 FE4A21FC\[^\n\]*\n"   { set x [expr $x+1] }
1399             -re "^ +24 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1400             -re "^ +\[0-9\]+ 009a FE5A21FC\[^\n\]*\n"   { set x [expr $x+1] }
1401             -re "^ +25 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1402             -re "^ +\[0-9\]+ 00a1 FE8A20FC\[^\n\]*\n"   { set x [expr $x+1] }
1403             -re "^ +26 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1404             -re "^ +\[0-9\]+ 00a8 FE9A20FC\[^\n\]*\n"   { set x [expr $x+1] }
1405             -re "^ +27 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1406             -re "^ +\[0-9\]+ 00af FEAA20FC\[^\n\]*\n"   { set x [expr $x+1] }
1407             -re "^ +28 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1408             -re "^ +\[0-9\]+ 00b6 FEBA20FC\[^\n\]*\n"   { set x [expr $x+1] }
1409             -re "^ +29 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1410             -re "^ +\[0-9\]+ 00bd FECA20FC\[^\n\]*\n"   { set x [expr $x+1] }
1411             -re "^ +30 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1412             -re "^ +\[0-9\]+ 00c4 FEDA20FC\[^\n\]*\n"   { set x [expr $x+1] }
1413             -re "^ +31 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1414             -re "^ +\[0-9\]+ 00cb FE0B22FC\[^\n\]*\n"   { set x [expr $x+1] }
1415             -re "^ +32 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1416             -re "^ +\[0-9\]+ 00d2 FE1B22FC\[^\n\]*\n"   { set x [expr $x+1] }
1417             -re "^ +33 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1418             -re "^ +\[0-9\]+ 00d9 FE2B22FC\[^\n\]*\n"   { set x [expr $x+1] }
1419             -re "^ +34 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1420             -re "^ +\[0-9\]+ 00e0 FE3B22FC\[^\n\]*\n"   { set x [expr $x+1] }
1421             -re "^ +35 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1422             -re "^ +\[0-9\]+ 00e7 FE4B22FC\[^\n\]*\n"   { set x [expr $x+1] }
1423             -re "^ +36 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1424             -re "^ +\[0-9\]+ 00ee FE5B22FC\[^\n\]*\n"   { set x [expr $x+1] }
1425             -re "^ +37 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1426             -re "^ +\[0-9\]+ 00f5 FE6B22FC\[^\n\]*\n"   { set x [expr $x+1] }
1427             -re "^ +38 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1428             -re "^ +\[0-9\]+ 00fc FE7B22FC\[^\n\]*\n"   { set x [expr $x+1] }
1429             -re "^ +39 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1430             -re "^ +\[0-9\]+ 0103 FE8B22FC\[^\n\]*\n"   { set x [expr $x+1] }
1431             -re "^ +40 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1432             -re "^ +\[0-9\]+ 010a FE9B22FC\[^\n\]*\n"   { set x [expr $x+1] }
1433             -re "^ +41 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1434             -re "^ +\[0-9\]+ 0111 FE0E20FC\[^\n\]*\n"   { set x [expr $x+1] }
1435             -re "^ +42 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1436             -re "^ +\[0-9\]+ 0118 FE1E20FC\[^\n\]*\n"   { set x [expr $x+1] }
1437             -re "^ +43 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1438             -re "^ +\[0-9\]+ 011f FE2E20FC\[^\n\]*\n"   { set x [expr $x+1] }
1439             -re "^ +44 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1440             -re "^ +\[0-9\]+ 0126 FE3E20FC\[^\n\]*\n"   { set x [expr $x+1] }
1441             -re "^ +45 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1442             -re "^ +\[0-9\]+ 012d FE4E20FC\[^\n\]*\n"   { set x [expr $x+1] }
1443             -re "^ +46 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1444             -re "^ +\[0-9\]+ 0134 FE5E20FC\[^\n\]*\n"   { set x [expr $x+1] }
1445             -re "^ +47 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1446             -re "^ +\[0-9\]+ 013b FBADCD89\[^\n\]*\n"   { set x [expr $x+1] }
1447             -re "^ +\[0-9\]+ 013f FBBDCD89\[^\n\]*\n"   { set x [expr $x+1] }
1448             -re "^ +\[0-9\]+ 0143 FE6A21FC\[^\n\]*\n"   { set x [expr $x+1] }
1449             -re "^ +50 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1450             -re "^ +\[0-9\]+ 014a FE7A12FC\[^\n\]*\n"   { set x [expr $x+1] }
1451             -re "^ +51 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1452             -re "^ +\[0-9\]+ 0151 FEEA21FC\[^\n\]*\n"   { set x [expr $x+1] }
1453             -re "^ +52 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1454             -re "^ +\[0-9\]+ 0158 FEFA12FC\[^\n\]*\n"   { set x [expr $x+1] }
1455             -re "^ +53 +FDFE7F\[^\n\]*\n"               { set x [expr $x+1] }
1456             -re "^ +\[0-9\]+ 015f FE8A20F0\[^\n\]*\n"   { set x [expr $x+1] }
1457             -re "^ +54 +FFFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1458             -re "^ +\[0-9\]+ 0166 FE9A20F0\[^\n\]*\n"   { set x [expr $x+1] }
1459             -re "^ +55 +FFFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1460             -re "^ +\[0-9\]+ 016d FEAA20F0\[^\n\]*\n"   { set x [expr $x+1] }
1461             -re "^ +56 +FFFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1462             -re "^ +\[0-9\]+ 0174 FEBA20F0\[^\n\]*\n"   { set x [expr $x+1] }
1463             -re "^ +57 +FFFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1464             -re "^ +\[0-9\]+ 017b FECA20F0\[^\n\]*\n"   { set x [expr $x+1] }
1465             -re "^ +58 +FFFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1466             -re "^ +\[0-9\]+ 0182 FEDA20F0\[^\n\]*\n"   { set x [expr $x+1] }
1467             -re "^ +59 +FFFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1468             -re "^ +\[0-9\]+ 0189 FE8A2000\[^\n\]*\n"   { set x [expr $x+1] }
1469             -re "^ +60 +FCFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1470             -re "^ +\[0-9\]+ 0190 FE9A2000\[^\n\]*\n"   { set x [expr $x+1] }
1471             -re "^ +61 +FCFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1472             -re "^ +\[0-9\]+ 0197 FEAA2000\[^\n\]*\n"   { set x [expr $x+1] }
1473             -re "^ +62 +FCFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1474             -re "^ +\[0-9\]+ 019e FEBA2000\[^\n\]*\n"   { set x [expr $x+1] }
1475             -re "^ +63 +FCFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1476             -re "^ +\[0-9\]+ 01a5 FECA2000\[^\n\]*\n"   { set x [expr $x+1] }
1477             -re "^ +64 +FCFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1478             -re "^ +\[0-9\]+ 01ac FEDA2000\[^\n\]*\n"   { set x [expr $x+1] }
1479             -re "^ +65 +FCFFFF\[^\n\]*\n"               { set x [expr $x+1] }
1480             -re "\[^\n\]*\n"                            { }
1481             timeout                             { perror "timeout\n"; break }
1482             eof                                 { break }
1483         }
1484     }
1485
1486     # This was intended to do any cleanup necessary.  It kinda looks like it
1487     # isn't needed, but just in case, please keep it in for now.
1488     gas_finish
1489
1490     # Did we find what we were looking for?  If not, flunk it.
1491     if [expr $x==124] then { pass $testname } else { fail $testname }
1492 }
1493
1494 proc do_am33_6 {} {
1495     set testname "am33_6.s: am33 tests part 6"
1496     set x 0
1497
1498     gas_start "am33_6.s" "-al"
1499
1500     # Instead of having a variable for each match string just increment the
1501     # total number of matches seen.  That's simpler when testing large numbers
1502     # of instructions (as these tests to).
1503     while 1 {
1504         expect {
1505             -re "^ +\[0-9\]+ 0000 F7004123\[^\n\]*\n"   { set x [expr $x+1] }
1506             -re "^ +\[0-9\]+ 0004 F7104123\[^\n\]*\n"   { set x [expr $x+1] }
1507             -re "^ +\[0-9\]+ 0008 F7204123\[^\n\]*\n"   { set x [expr $x+1] }
1508             -re "^ +\[0-9\]+ 000c F7304123\[^\n\]*\n"   { set x [expr $x+1] }
1509             -re "^ +\[0-9\]+ 0010 F7404123\[^\n\]*\n"   { set x [expr $x+1] }
1510             -re "^ +\[0-9\]+ 0014 F7504123\[^\n\]*\n"   { set x [expr $x+1] }
1511             -re "^ +\[0-9\]+ 0018 F7604123\[^\n\]*\n"   { set x [expr $x+1] }
1512             -re "^ +\[0-9\]+ 001c F7704123\[^\n\]*\n"   { set x [expr $x+1] }
1513             -re "^ +\[0-9\]+ 0020 F7804123\[^\n\]*\n"   { set x [expr $x+1] }
1514             -re "^ +\[0-9\]+ 0024 F7904123\[^\n\]*\n"   { set x [expr $x+1] }
1515             -re "^ +\[0-9\]+ 0028 F7A04123\[^\n\]*\n"   { set x [expr $x+1] }
1516             -re "^ +\[0-9\]+ 002c F7B04123\[^\n\]*\n"   { set x [expr $x+1] }
1517             -re "^ +\[0-9\]+ 0030 F7C04123\[^\n\]*\n"   { set x [expr $x+1] }
1518             -re "^ +\[0-9\]+ 0034 F7D04123\[^\n\]*\n"   { set x [expr $x+1] }
1519             -re "^ +\[0-9\]+ 0038 F7014123\[^\n\]*\n"   { set x [expr $x+1] }
1520             -re "^ +\[0-9\]+ 003c F7114123\[^\n\]*\n"   { set x [expr $x+1] }
1521             -re "^ +\[0-9\]+ 0040 F7214123\[^\n\]*\n"   { set x [expr $x+1] }
1522             -re "^ +\[0-9\]+ 0044 F7314123\[^\n\]*\n"   { set x [expr $x+1] }
1523             -re "^ +\[0-9\]+ 0048 F7614123\[^\n\]*\n"   { set x [expr $x+1] }
1524             -re "^ +\[0-9\]+ 004c F7714123\[^\n\]*\n"   { set x [expr $x+1] }
1525             -re "^ +\[0-9\]+ 0050 F7814123\[^\n\]*\n"   { set x [expr $x+1] }
1526             -re "^ +\[0-9\]+ 0054 F7914123\[^\n\]*\n"   { set x [expr $x+1] }
1527             -re "^ +\[0-9\]+ 0058 F7A14123\[^\n\]*\n"   { set x [expr $x+1] }
1528             -re "^ +\[0-9\]+ 005c F7B14123\[^\n\]*\n"   { set x [expr $x+1] }
1529             -re "^ +\[0-9\]+ 0060 F7C14123\[^\n\]*\n"   { set x [expr $x+1] }
1530             -re "^ +\[0-9\]+ 0064 F7D14123\[^\n\]*\n"   { set x [expr $x+1] }
1531             -re "^ +\[0-9\]+ 0068 F7024123\[^\n\]*\n"   { set x [expr $x+1] }
1532             -re "^ +\[0-9\]+ 006c F7124123\[^\n\]*\n"   { set x [expr $x+1] }
1533             -re "^ +\[0-9\]+ 0070 F7224123\[^\n\]*\n"   { set x [expr $x+1] }
1534             -re "^ +\[0-9\]+ 0074 F7324123\[^\n\]*\n"   { set x [expr $x+1] }
1535             -re "^ +\[0-9\]+ 0078 F7424123\[^\n\]*\n"   { set x [expr $x+1] }
1536             -re "^ +\[0-9\]+ 007c F7524123\[^\n\]*\n"   { set x [expr $x+1] }
1537             -re "^ +\[0-9\]+ 0080 F7624123\[^\n\]*\n"   { set x [expr $x+1] }
1538             -re "^ +\[0-9\]+ 0084 F7724123\[^\n\]*\n"   { set x [expr $x+1] }
1539             -re "^ +\[0-9\]+ 0088 F7824123\[^\n\]*\n"   { set x [expr $x+1] }
1540             -re "^ +\[0-9\]+ 008c F7924123\[^\n\]*\n"   { set x [expr $x+1] }
1541             -re "^ +\[0-9\]+ 0090 F7A24123\[^\n\]*\n"   { set x [expr $x+1] }
1542             -re "^ +\[0-9\]+ 0094 F7B24123\[^\n\]*\n"   { set x [expr $x+1] }
1543             -re "^ +\[0-9\]+ 0098 F7C24123\[^\n\]*\n"   { set x [expr $x+1] }
1544             -re "^ +\[0-9\]+ 009c F7D24123\[^\n\]*\n"   { set x [expr $x+1] }
1545             -re "^ +\[0-9\]+ 00a0 F7034123\[^\n\]*\n"   { set x [expr $x+1] }
1546             -re "^ +\[0-9\]+ 00a4 F7134123\[^\n\]*\n"   { set x [expr $x+1] }
1547             -re "^ +\[0-9\]+ 00a8 F7234123\[^\n\]*\n"   { set x [expr $x+1] }
1548             -re "^ +\[0-9\]+ 00ac F7334123\[^\n\]*\n"   { set x [expr $x+1] }
1549             -re "^ +\[0-9\]+ 00b0 F7434123\[^\n\]*\n"   { set x [expr $x+1] }
1550             -re "^ +\[0-9\]+ 00b4 F7534123\[^\n\]*\n"   { set x [expr $x+1] }
1551             -re "^ +\[0-9\]+ 00b8 F7634123\[^\n\]*\n"   { set x [expr $x+1] }
1552             -re "^ +\[0-9\]+ 00bc F7734123\[^\n\]*\n"   { set x [expr $x+1] }
1553             -re "^ +\[0-9\]+ 00c0 F7834123\[^\n\]*\n"   { set x [expr $x+1] }
1554             -re "^ +\[0-9\]+ 00c4 F7934123\[^\n\]*\n"   { set x [expr $x+1] }
1555             -re "^ +\[0-9\]+ 00c8 F7A34123\[^\n\]*\n"   { set x [expr $x+1] }
1556             -re "^ +\[0-9\]+ 00cc F7B34123\[^\n\]*\n"   { set x [expr $x+1] }
1557             -re "^ +\[0-9\]+ 00d0 F7C34123\[^\n\]*\n"   { set x [expr $x+1] }
1558             -re "^ +\[0-9\]+ 00d4 F7D34123\[^\n\]*\n"   { set x [expr $x+1] }
1559             -re "^ +\[0-9\]+ 00d8 F7044123\[^\n\]*\n"   { set x [expr $x+1] }
1560             -re "^ +\[0-9\]+ 00dc F7144123\[^\n\]*\n"   { set x [expr $x+1] }
1561             -re "^ +\[0-9\]+ 00e0 F7244123\[^\n\]*\n"   { set x [expr $x+1] }
1562             -re "^ +\[0-9\]+ 00e4 F7344123\[^\n\]*\n"   { set x [expr $x+1] }
1563             -re "^ +\[0-9\]+ 00e8 F7444123\[^\n\]*\n"   { set x [expr $x+1] }
1564             -re "^ +\[0-9\]+ 00ec F7544123\[^\n\]*\n"   { set x [expr $x+1] }
1565             -re "^ +\[0-9\]+ 00f0 F7644123\[^\n\]*\n"   { set x [expr $x+1] }
1566             -re "^ +\[0-9\]+ 00f4 F7744123\[^\n\]*\n"   { set x [expr $x+1] }
1567             -re "^ +\[0-9\]+ 00f8 F7844123\[^\n\]*\n"   { set x [expr $x+1] }
1568             -re "^ +\[0-9\]+ 00fc F7944123\[^\n\]*\n"   { set x [expr $x+1] }
1569             -re "^ +\[0-9\]+ 0100 F7A44123\[^\n\]*\n"   { set x [expr $x+1] }
1570             -re "^ +\[0-9\]+ 0104 F7B44123\[^\n\]*\n"   { set x [expr $x+1] }
1571             -re "^ +\[0-9\]+ 0108 F7C44123\[^\n\]*\n"   { set x [expr $x+1] }
1572             -re "^ +\[0-9\]+ 010c F7D44123\[^\n\]*\n"   { set x [expr $x+1] }
1573             -re "\[^\n\]*\n"                            { }
1574             timeout                             { perror "timeout\n"; break }
1575             eof                                 { break }
1576         }
1577     }
1578
1579     # This was intended to do any cleanup necessary.  It kinda looks like it
1580     # isn't needed, but just in case, please keep it in for now.
1581     gas_finish
1582
1583     # Did we find what we were looking for?  If not, flunk it.
1584     if [expr $x==68] then { pass $testname } else { fail $testname }
1585 }
1586
1587 proc do_am33_7 {} {
1588     set testname "am33_7.s: am33 tests part 7"
1589     set x 0
1590
1591     gas_start "am33_7.s" "-al"
1592
1593     # Instead of having a variable for each match string just increment the
1594     # total number of matches seen.  That's simpler when testing large numbers
1595     # of instructions (as these tests to).
1596     while 1 {
1597         expect {
1598             -re "^ +\[0-9\]+ 0000 F7054123\[^\n\]*\n"   { set x [expr $x+1] }
1599             -re "^ +\[0-9\]+ 0004 F7154123\[^\n\]*\n"   { set x [expr $x+1] }
1600             -re "^ +\[0-9\]+ 0008 F7254123\[^\n\]*\n"   { set x [expr $x+1] }
1601             -re "^ +\[0-9\]+ 000c F7354123\[^\n\]*\n"   { set x [expr $x+1] }
1602             -re "^ +\[0-9\]+ 0010 F7654123\[^\n\]*\n"   { set x [expr $x+1] }
1603             -re "^ +\[0-9\]+ 0014 F7754123\[^\n\]*\n"   { set x [expr $x+1] }
1604             -re "^ +\[0-9\]+ 0018 F7854123\[^\n\]*\n"   { set x [expr $x+1] }
1605             -re "^ +\[0-9\]+ 001c F7954123\[^\n\]*\n"   { set x [expr $x+1] }
1606             -re "^ +\[0-9\]+ 0020 F7A54123\[^\n\]*\n"   { set x [expr $x+1] }
1607             -re "^ +\[0-9\]+ 0024 F7B54123\[^\n\]*\n"   { set x [expr $x+1] }
1608             -re "^ +\[0-9\]+ 0028 F7C54123\[^\n\]*\n"   { set x [expr $x+1] }
1609             -re "^ +\[0-9\]+ 002c F7D54123\[^\n\]*\n"   { set x [expr $x+1] }
1610             -re "^ +\[0-9\]+ 0030 F7064123\[^\n\]*\n"   { set x [expr $x+1] }
1611             -re "^ +\[0-9\]+ 0034 F7164123\[^\n\]*\n"   { set x [expr $x+1] }
1612             -re "^ +\[0-9\]+ 0038 F7264123\[^\n\]*\n"   { set x [expr $x+1] }
1613             -re "^ +\[0-9\]+ 003c F7364123\[^\n\]*\n"   { set x [expr $x+1] }
1614             -re "^ +\[0-9\]+ 0040 F7464123\[^\n\]*\n"   { set x [expr $x+1] }
1615             -re "^ +\[0-9\]+ 0044 F7564123\[^\n\]*\n"   { set x [expr $x+1] }
1616             -re "^ +\[0-9\]+ 0048 F7664123\[^\n\]*\n"   { set x [expr $x+1] }
1617             -re "^ +\[0-9\]+ 004c F7764123\[^\n\]*\n"   { set x [expr $x+1] }
1618             -re "^ +\[0-9\]+ 0050 F7864123\[^\n\]*\n"   { set x [expr $x+1] }
1619             -re "^ +\[0-9\]+ 0054 F7964123\[^\n\]*\n"   { set x [expr $x+1] }
1620             -re "^ +\[0-9\]+ 0058 F7A64123\[^\n\]*\n"   { set x [expr $x+1] }
1621             -re "^ +\[0-9\]+ 005c F7B64123\[^\n\]*\n"   { set x [expr $x+1] }
1622             -re "^ +\[0-9\]+ 0060 F7C64123\[^\n\]*\n"   { set x [expr $x+1] }
1623             -re "^ +\[0-9\]+ 0064 F7D64123\[^\n\]*\n"   { set x [expr $x+1] }
1624             -re "^ +\[0-9\]+ 0068 F7074123\[^\n\]*\n"   { set x [expr $x+1] }
1625             -re "^ +\[0-9\]+ 006c F7174123\[^\n\]*\n"   { set x [expr $x+1] }
1626             -re "^ +\[0-9\]+ 0070 F7274123\[^\n\]*\n"   { set x [expr $x+1] }
1627             -re "^ +\[0-9\]+ 0074 F7374123\[^\n\]*\n"   { set x [expr $x+1] }
1628             -re "^ +\[0-9\]+ 0078 F7474123\[^\n\]*\n"   { set x [expr $x+1] }
1629             -re "^ +\[0-9\]+ 007c F7574123\[^\n\]*\n"   { set x [expr $x+1] }
1630             -re "^ +\[0-9\]+ 0080 F7674123\[^\n\]*\n"   { set x [expr $x+1] }
1631             -re "^ +\[0-9\]+ 0084 F7774123\[^\n\]*\n"   { set x [expr $x+1] }
1632             -re "^ +\[0-9\]+ 0088 F7874123\[^\n\]*\n"   { set x [expr $x+1] }
1633             -re "^ +\[0-9\]+ 008c F7974123\[^\n\]*\n"   { set x [expr $x+1] }
1634             -re "^ +\[0-9\]+ 0090 F7A74123\[^\n\]*\n"   { set x [expr $x+1] }
1635             -re "^ +\[0-9\]+ 0094 F7B74123\[^\n\]*\n"   { set x [expr $x+1] }
1636             -re "^ +\[0-9\]+ 0098 F7C74123\[^\n\]*\n"   { set x [expr $x+1] }
1637             -re "^ +\[0-9\]+ 009c F7D74123\[^\n\]*\n"   { set x [expr $x+1] }
1638             -re "^ +\[0-9\]+ 00a0 F7084123\[^\n\]*\n"   { set x [expr $x+1] }
1639             -re "^ +\[0-9\]+ 00a4 F7184123\[^\n\]*\n"   { set x [expr $x+1] }
1640             -re "^ +\[0-9\]+ 00a8 F7284123\[^\n\]*\n"   { set x [expr $x+1] }
1641             -re "^ +\[0-9\]+ 00ac F7384123\[^\n\]*\n"   { set x [expr $x+1] }
1642             -re "^ +\[0-9\]+ 00b0 F7484123\[^\n\]*\n"   { set x [expr $x+1] }
1643             -re "^ +\[0-9\]+ 00b4 F7584123\[^\n\]*\n"   { set x [expr $x+1] }
1644             -re "^ +\[0-9\]+ 00b8 F7684123\[^\n\]*\n"   { set x [expr $x+1] }
1645             -re "^ +\[0-9\]+ 00bc F7784123\[^\n\]*\n"   { set x [expr $x+1] }
1646             -re "^ +\[0-9\]+ 00c0 F7884123\[^\n\]*\n"   { set x [expr $x+1] }
1647             -re "^ +\[0-9\]+ 00c4 F7984123\[^\n\]*\n"   { set x [expr $x+1] }
1648             -re "^ +\[0-9\]+ 00c8 F7A84123\[^\n\]*\n"   { set x [expr $x+1] }
1649             -re "^ +\[0-9\]+ 00cc F7B84123\[^\n\]*\n"   { set x [expr $x+1] }
1650             -re "^ +\[0-9\]+ 00d0 F7C84123\[^\n\]*\n"   { set x [expr $x+1] }
1651             -re "^ +\[0-9\]+ 00d4 F7D84123\[^\n\]*\n"   { set x [expr $x+1] }
1652             -re "^ +\[0-9\]+ 00d8 F7094123\[^\n\]*\n"   { set x [expr $x+1] }
1653             -re "^ +\[0-9\]+ 00dc F7194123\[^\n\]*\n"   { set x [expr $x+1] }
1654             -re "^ +\[0-9\]+ 00e0 F7294123\[^\n\]*\n"   { set x [expr $x+1] }
1655             -re "^ +\[0-9\]+ 00e4 F7394123\[^\n\]*\n"   { set x [expr $x+1] }
1656             -re "^ +\[0-9\]+ 00e8 F7494123\[^\n\]*\n"   { set x [expr $x+1] }
1657             -re "^ +\[0-9\]+ 00ec F7594123\[^\n\]*\n"   { set x [expr $x+1] }
1658             -re "^ +\[0-9\]+ 00f0 F7694123\[^\n\]*\n"   { set x [expr $x+1] }
1659             -re "^ +\[0-9\]+ 00f4 F7794123\[^\n\]*\n"   { set x [expr $x+1] }
1660             -re "^ +\[0-9\]+ 00f8 F7894123\[^\n\]*\n"   { set x [expr $x+1] }
1661             -re "^ +\[0-9\]+ 00fc F7994123\[^\n\]*\n"   { set x [expr $x+1] }
1662             -re "^ +\[0-9\]+ 0100 F7A94123\[^\n\]*\n"   { set x [expr $x+1] }
1663             -re "^ +\[0-9\]+ 0104 F7B94123\[^\n\]*\n"   { set x [expr $x+1] }
1664             -re "^ +\[0-9\]+ 0108 F7C94123\[^\n\]*\n"   { set x [expr $x+1] }
1665             -re "^ +\[0-9\]+ 010c F7D94123\[^\n\]*\n"   { set x [expr $x+1] }
1666             -re "\[^\n\]*\n"                            { }
1667             timeout                             { perror "timeout\n"; break }
1668             eof                                 { break }
1669         }
1670     }
1671
1672     # This was intended to do any cleanup necessary.  It kinda looks like it
1673     # isn't needed, but just in case, please keep it in for now.
1674     gas_finish
1675
1676     # Did we find what we were looking for?  If not, flunk it.
1677     if [expr $x==68] then { pass $testname } else { fail $testname }
1678 }
1679
1680 proc do_am33_8 {} {
1681     set testname "am33_8.s: am33 tests part 8"
1682     set x 0
1683
1684     gas_start "am33_8.s" "-al"
1685
1686     # Instead of having a variable for each match string just increment the
1687     # total number of matches seen.  That's simpler when testing large numbers
1688     # of instructions (as these tests to).
1689     while 1 {
1690         expect {
1691             -re "^ +\[0-9\]+ 0000 F70A4123\[^\n\]*\n"   { set x [expr $x+1] }
1692             -re "^ +\[0-9\]+ 0004 F71A4123\[^\n\]*\n"   { set x [expr $x+1] }
1693             -re "^ +\[0-9\]+ 0008 F72A4123\[^\n\]*\n"   { set x [expr $x+1] }
1694             -re "^ +\[0-9\]+ 000c F73A4123\[^\n\]*\n"   { set x [expr $x+1] }
1695             -re "^ +\[0-9\]+ 0010 F74A4123\[^\n\]*\n"   { set x [expr $x+1] }
1696             -re "^ +\[0-9\]+ 0014 F75A4123\[^\n\]*\n"   { set x [expr $x+1] }
1697             -re "^ +\[0-9\]+ 0018 F76A4123\[^\n\]*\n"   { set x [expr $x+1] }
1698             -re "^ +\[0-9\]+ 001c F77A4123\[^\n\]*\n"   { set x [expr $x+1] }
1699             -re "^ +\[0-9\]+ 0020 F78A4123\[^\n\]*\n"   { set x [expr $x+1] }
1700             -re "^ +\[0-9\]+ 0024 F79A4123\[^\n\]*\n"   { set x [expr $x+1] }
1701             -re "^ +\[0-9\]+ 0028 F7AA4123\[^\n\]*\n"   { set x [expr $x+1] }
1702             -re "^ +\[0-9\]+ 002c F7BA4123\[^\n\]*\n"   { set x [expr $x+1] }
1703             -re "^ +\[0-9\]+ 0030 F7CA4123\[^\n\]*\n"   { set x [expr $x+1] }
1704             -re "^ +\[0-9\]+ 0034 F7DA4123\[^\n\]*\n"   { set x [expr $x+1] }
1705             -re "^ +\[0-9\]+ 0038 F70B4123\[^\n\]*\n"   { set x [expr $x+1] }
1706             -re "^ +\[0-9\]+ 003c F71B4123\[^\n\]*\n"   { set x [expr $x+1] }
1707             -re "^ +\[0-9\]+ 0040 F72B4123\[^\n\]*\n"   { set x [expr $x+1] }
1708             -re "^ +\[0-9\]+ 0044 F73B4123\[^\n\]*\n"   { set x [expr $x+1] }
1709             -re "^ +\[0-9\]+ 0048 F74B4123\[^\n\]*\n"   { set x [expr $x+1] }
1710             -re "^ +\[0-9\]+ 004c F75B4123\[^\n\]*\n"   { set x [expr $x+1] }
1711             -re "^ +\[0-9\]+ 0050 F76B4123\[^\n\]*\n"   { set x [expr $x+1] }
1712             -re "^ +\[0-9\]+ 0054 F77B4123\[^\n\]*\n"   { set x [expr $x+1] }
1713             -re "^ +\[0-9\]+ 0058 F78B4123\[^\n\]*\n"   { set x [expr $x+1] }
1714             -re "^ +\[0-9\]+ 005c F79B4123\[^\n\]*\n"   { set x [expr $x+1] }
1715             -re "^ +\[0-9\]+ 0060 F7AB4123\[^\n\]*\n"   { set x [expr $x+1] }
1716             -re "^ +\[0-9\]+ 0064 F7BB4123\[^\n\]*\n"   { set x [expr $x+1] }
1717             -re "^ +\[0-9\]+ 0068 F7CB4123\[^\n\]*\n"   { set x [expr $x+1] }
1718             -re "^ +\[0-9\]+ 006c F7DB4123\[^\n\]*\n"   { set x [expr $x+1] }
1719             -re "^ +\[0-9\]+ 0070 F70C4123\[^\n\]*\n"   { set x [expr $x+1] }
1720             -re "^ +\[0-9\]+ 0074 F71C4123\[^\n\]*\n"   { set x [expr $x+1] }
1721             -re "^ +\[0-9\]+ 0078 F72C4123\[^\n\]*\n"   { set x [expr $x+1] }
1722             -re "^ +\[0-9\]+ 007c F73C4123\[^\n\]*\n"   { set x [expr $x+1] }
1723             -re "^ +\[0-9\]+ 0080 F74C4123\[^\n\]*\n"   { set x [expr $x+1] }
1724             -re "^ +\[0-9\]+ 0084 F75C4123\[^\n\]*\n"   { set x [expr $x+1] }
1725             -re "^ +\[0-9\]+ 0088 F76C4123\[^\n\]*\n"   { set x [expr $x+1] }
1726             -re "^ +\[0-9\]+ 008c F77C4123\[^\n\]*\n"   { set x [expr $x+1] }
1727             -re "^ +\[0-9\]+ 0090 F78C4123\[^\n\]*\n"   { set x [expr $x+1] }
1728             -re "^ +\[0-9\]+ 0094 F79C4123\[^\n\]*\n"   { set x [expr $x+1] }
1729             -re "^ +\[0-9\]+ 0098 F7AC4123\[^\n\]*\n"   { set x [expr $x+1] }
1730             -re "^ +\[0-9\]+ 009c F7BC4123\[^\n\]*\n"   { set x [expr $x+1] }
1731             -re "^ +\[0-9\]+ 00a0 F7CC4123\[^\n\]*\n"   { set x [expr $x+1] }
1732             -re "^ +\[0-9\]+ 00a4 F7DC4123\[^\n\]*\n"   { set x [expr $x+1] }
1733             -re "^ +\[0-9\]+ 00a8 F70D4123\[^\n\]*\n"   { set x [expr $x+1] }
1734             -re "^ +\[0-9\]+ 00ac F71D4123\[^\n\]*\n"   { set x [expr $x+1] }
1735             -re "^ +\[0-9\]+ 00b0 F72D4123\[^\n\]*\n"   { set x [expr $x+1] }
1736             -re "^ +\[0-9\]+ 00b4 F73D4123\[^\n\]*\n"   { set x [expr $x+1] }
1737             -re "^ +\[0-9\]+ 00b8 F74D4123\[^\n\]*\n"   { set x [expr $x+1] }
1738             -re "^ +\[0-9\]+ 00bc F75D4123\[^\n\]*\n"   { set x [expr $x+1] }
1739             -re "^ +\[0-9\]+ 00c0 F76D4123\[^\n\]*\n"   { set x [expr $x+1] }
1740             -re "^ +\[0-9\]+ 00c4 F77D4123\[^\n\]*\n"   { set x [expr $x+1] }
1741             -re "^ +\[0-9\]+ 00c8 F78D4123\[^\n\]*\n"   { set x [expr $x+1] }
1742             -re "^ +\[0-9\]+ 00cc F79D4123\[^\n\]*\n"   { set x [expr $x+1] }
1743             -re "^ +\[0-9\]+ 00d0 F7AD4123\[^\n\]*\n"   { set x [expr $x+1] }
1744             -re "^ +\[0-9\]+ 00d4 F7BD4123\[^\n\]*\n"   { set x [expr $x+1] }
1745             -re "^ +\[0-9\]+ 00d8 F7CD4123\[^\n\]*\n"   { set x [expr $x+1] }
1746             -re "^ +\[0-9\]+ 00dc F7DD4123\[^\n\]*\n"   { set x [expr $x+1] }
1747             -re "^ +\[0-9\]+ 00e0 F7E02140\[^\n\]*\n"   { set x [expr $x+1] }
1748             -re "^ +\[0-9\]+ 00e4 F7E02141\[^\n\]*\n"   { set x [expr $x+1] }
1749             -re "^ +\[0-9\]+ 00e8 F7E02142\[^\n\]*\n"   { set x [expr $x+1] }
1750             -re "^ +\[0-9\]+ 00ec F7E02143\[^\n\]*\n"   { set x [expr $x+1] }
1751             -re "^ +\[0-9\]+ 00f0 F7E02144\[^\n\]*\n"   { set x [expr $x+1] }
1752             -re "^ +\[0-9\]+ 00f4 F7E02145\[^\n\]*\n"   { set x [expr $x+1] }
1753             -re "^ +\[0-9\]+ 00f8 F7E02146\[^\n\]*\n"   { set x [expr $x+1] }
1754             -re "^ +\[0-9\]+ 00fc F7E02147\[^\n\]*\n"   { set x [expr $x+1] }
1755             -re "^ +\[0-9\]+ 0100 F7E02148\[^\n\]*\n"   { set x [expr $x+1] }
1756             -re "^ +\[0-9\]+ 0104 F7E02149\[^\n\]*\n"   { set x [expr $x+1] }
1757             -re "^ +\[0-9\]+ 0108 F7E0214A\[^\n\]*\n"   { set x [expr $x+1] }
1758             -re "\[^\n\]*\n"                            { }
1759             timeout                             { perror "timeout\n"; break }
1760             eof                                 { break }
1761         }
1762     }
1763
1764     # This was intended to do any cleanup necessary.  It kinda looks like it
1765     # isn't needed, but just in case, please keep it in for now.
1766     gas_finish
1767
1768     # Did we find what we were looking for?  If not, flunk it.
1769     if [expr $x==67] then { pass $testname } else { fail $testname }
1770 }
1771
1772 if [istarget mn10300*-*-*] then {
1773     # Test the basic instruction parser.
1774     do_add
1775     do_bcc
1776     do_bit
1777     do_cmp
1778     do_ext
1779     do_extend
1780     do_logical
1781     do_loop
1782     do_mov1
1783     do_mov2
1784     do_mov3
1785     do_mov4
1786     do_mov5
1787     do_movbu
1788     do_movhu
1789     do_movm
1790     do_muldiv
1791     do_other
1792     do_shift
1793     do_sub
1794     do_udf
1795     do_am33_1
1796     do_am33_2
1797     do_am33_3
1798     do_am33_4
1799     do_am33_5
1800     do_am33_6
1801     do_am33_7
1802     do_am33_8
1803
1804     run_list_test "movpc" ""
1805     run_list_test "pr997" "-a"
1806
1807     run_dump_test "am33-2"
1808     run_dump_test "relax"
1809     run_dump_test "pr11973"
1810 }