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