1 # Copyright (C) 1996 Free Software Foundation, Inc.
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.
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.
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. */
17 # Please email any bugs, comments, and/or additions to this file to:
20 # Written by Cygnus Support.
23 set testname "add.s: Add operations"
26 gas_start "add.s" "-al"
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).
33 -re "^ +\[0-9\]+ 0000 96\[^\n\]*\n" { set x [expr $x+1] }
34 -re "^ +\[0-9\]+ 0001 F20B\[^\n\]*\n" { set x [expr $x+1] }
35 -re "^ +\[0-9\]+ 0003 F2C9\[^\n\]*\n" { set x [expr $x+1] }
36 -re "^ +\[0-9\]+ 0005 F24E\[^\n\]*\n" { set x [expr $x+1] }
37 -re "^ +\[0-9\]+ 0007 D510\[^\n\]*\n" { set x [expr $x+1] }
38 -re "^ +\[0-9\]+ 0009 F71A0001\[^\n\]*\n" { set x [expr $x+1] }
39 -re "^ +\[0-9\]+ 000d F463FFFF\[^\n\]*\n" { set x [expr $x+1] }
40 -re "^ +8 +01\[^\n\]*\n" { set x [expr $x+1] }
41 -re "^ +\[0-9\]+ 0012 D110\[^\n\]*\n" { set x [expr $x+1] }
42 -re "^ +\[0-9\]+ 0014 F70A0001\[^\n\]*\n" { set x [expr $x+1] }
43 -re "^ +\[0-9\]+ 0018 F467FFFF\[^\n\]*\n" { set x [expr $x+1] }
44 -re "^ +11 +01\[^\n\]*\n" { set x [expr $x+1] }
45 -re "^ +\[0-9\]+ 001d F286\[^\n\]*\n" { set x [expr $x+1] }
46 -re "^ +\[0-9\]+ 001f F50E10\[^\n\]*\n" { set x [expr $x+1] }
48 timeout { perror "timeout\n"; break }
53 # This was intended to do any cleanup necessary. It kinda looks like it
54 # isn't needed, but just in case, please keep it in for now.
57 # Did we find what we were looking for? If not, flunk it.
58 if [expr $x==14] then { pass $testname } else { fail $testname }
62 set testname "bcc.s: Bcc tests"
65 gas_start "bcc.s" "-al"
67 # Instead of having a variable for each match string just increment the
68 # total number of matches seen. That's simpler when testing large numbers
69 # of instructions (as these tests to).
72 -re "^ +\[0-9\]+ 0000 E800\[^\n\]*\n" { set x [expr $x+1] }
73 -re "^ +\[0-9\]+ 0002 E900\[^\n\]*\n" { set x [expr $x+1] }
74 -re "^ +\[0-9\]+ 0004 E100\[^\n\]*\n" { set x [expr $x+1] }
75 -re "^ +\[0-9\]+ 0006 E200\[^\n\]*\n" { set x [expr $x+1] }
76 -re "^ +\[0-9\]+ 0008 E300\[^\n\]*\n" { set x [expr $x+1] }
77 -re "^ +\[0-9\]+ 000a E000\[^\n\]*\n" { set x [expr $x+1] }
78 -re "^ +\[0-9\]+ 000c E500\[^\n\]*\n" { set x [expr $x+1] }
79 -re "^ +\[0-9\]+ 000e E600\[^\n\]*\n" { set x [expr $x+1] }
80 -re "^ +\[0-9\]+ 0010 E700\[^\n\]*\n" { set x [expr $x+1] }
81 -re "^ +\[0-9\]+ 0012 E400\[^\n\]*\n" { set x [expr $x+1] }
82 -re "^ +\[0-9\]+ 0014 F5FC00\[^\n\]*\n" { set x [expr $x+1] }
83 -re "^ +\[0-9\]+ 0017 F5FD00\[^\n\]*\n" { set x [expr $x+1] }
84 -re "^ +\[0-9\]+ 001a F5FE00\[^\n\]*\n" { set x [expr $x+1] }
85 -re "^ +\[0-9\]+ 001d F5FF00\[^\n\]*\n" { set x [expr $x+1] }
86 -re "^ +\[0-9\]+ 0020 EA00\[^\n\]*\n" { set x [expr $x+1] }
88 timeout { perror "timeout\n"; break }
93 # This was intended to do any cleanup necessary. It kinda looks like it
94 # isn't needed, but just in case, please keep it in for now.
97 # Did we find what we were looking for? If not, flunk it.
98 if [expr $x==15] then { pass $testname } else { fail $testname }
102 set testname "bccx.s: Bccx tests"
105 gas_start "bccx.s" "-al"
107 # Instead of having a variable for each match string just increment the
108 # total number of matches seen. That's simpler when testing large numbers
109 # of instructions (as these tests to).
112 -re "^ +\[0-9\]+ 0000 F5E800\[^\n\]*\n" { set x [expr $x+1] }
113 -re "^ +\[0-9\]+ 0003 F5E900\[^\n\]*\n" { set x [expr $x+1] }
114 -re "^ +\[0-9\]+ 0006 F5E100\[^\n\]*\n" { set x [expr $x+1] }
115 -re "^ +\[0-9\]+ 0009 F5E200\[^\n\]*\n" { set x [expr $x+1] }
116 -re "^ +\[0-9\]+ 000c F5E300\[^\n\]*\n" { set x [expr $x+1] }
117 -re "^ +\[0-9\]+ 000f F5E000\[^\n\]*\n" { set x [expr $x+1] }
118 -re "^ +\[0-9\]+ 0012 F5E500\[^\n\]*\n" { set x [expr $x+1] }
119 -re "^ +\[0-9\]+ 0015 F5E600\[^\n\]*\n" { set x [expr $x+1] }
120 -re "^ +\[0-9\]+ 0018 F5E700\[^\n\]*\n" { set x [expr $x+1] }
121 -re "^ +\[0-9\]+ 001b F5E400\[^\n\]*\n" { set x [expr $x+1] }
122 -re "^ +\[0-9\]+ 001e F5EC00\[^\n\]*\n" { set x [expr $x+1] }
123 -re "^ +\[0-9\]+ 0021 F5ED00\[^\n\]*\n" { set x [expr $x+1] }
124 -re "^ +\[0-9\]+ 0024 F5EE00\[^\n\]*\n" { set x [expr $x+1] }
125 -re "^ +\[0-9\]+ 0027 F5EF00\[^\n\]*\n" { set x [expr $x+1] }
127 timeout { perror "timeout\n"; break }
132 # This was intended to do any cleanup necessary. It kinda looks like it
133 # isn't needed, but just in case, please keep it in for now.
136 # Did we find what we were looking for? If not, flunk it.
137 if [expr $x==14] then { pass $testname } else { fail $testname }
141 set testname "bit.s: bit tests"
144 gas_start "bit.s" "-al"
146 # Instead of having a variable for each match string just increment the
147 # total number of matches seen. That's simpler when testing large numbers
148 # of instructions (as these tests to).
151 -re "^ +\[0-9\]+ 0000 F50540\[^\n\]*\n" { set x [expr $x+1] }
152 -re "^ +\[0-9\]+ 0003 F7060020\[^\n\]*\n" { set x [expr $x+1] }
153 -re "^ +\[0-9\]+ 0007 F029\[^\n\]*\n" { set x [expr $x+1] }
154 -re "^ +\[0-9\]+ 0009 F039\[^\n\]*\n" { set x [expr $x+1] }
155 -re "^ +12 +FFFF40\[^\n\]*\n" { set x [expr $x+1] }
157 timeout { perror "timeout\n"; break }
162 # This was intended to do any cleanup necessary. It kinda looks like it
163 # isn't needed, but just in case, please keep it in for now.
166 # Did we find what we were looking for? If not, flunk it.
167 if [expr $x==4] then { pass $testname } else { fail $testname }
172 set testname "cmp.s: cmp tests"
175 gas_start "cmp.s" "-al"
177 # Instead of having a variable for each match string just increment the
178 # total number of matches seen. That's simpler when testing large numbers
179 # of instructions (as these tests to).
182 -re "^ +\[0-9\]+ 0000 F396\[^\n\]*\n" { set x [expr $x+1] }
183 -re "^ +\[0-9\]+ 0002 F22B\[^\n\]*\n" { set x [expr $x+1] }
184 -re "^ +\[0-9\]+ 0004 F2EF\[^\n\]*\n" { set x [expr $x+1] }
185 -re "^ +\[0-9\]+ 0006 F26E\[^\n\]*\n" { set x [expr $x+1] }
186 -re "^ +\[0-9\]+ 0008 DB10\[^\n\]*\n" { set x [expr $x+1] }
187 -re "^ +\[0-9\]+ 000a F74A0001\[^\n\]*\n" { set x [expr $x+1] }
188 -re "^ +\[0-9\]+ 000e F479FFFF\[^\n\]*\n" { set x [expr $x+1] }
189 -re "^ +8 +01\[^\n\]*\n" { set x [expr $x+1] }
190 -re "^ +\[0-9\]+ 0013 EE0001\[^\n\]*\n" { set x [expr $x+1] }
191 -re "^ +\[0-9\]+ 0016 F47DFFFF\[^\n\]*\n" { set x [expr $x+1] }
192 -re "^ +10 +01\[^\n\]*\n" { set x [expr $x+1] }
194 timeout { perror "timeout\n"; break }
199 # This was intended to do any cleanup necessary. It kinda looks like it
200 # isn't needed, but just in case, please keep it in for now.
203 # Did we find what we were looking for? If not, flunk it.
204 if [expr $x==11] then { pass $testname } else { fail $testname }
208 set testname "ext.s: ext tests"
211 gas_start "ext.s" "-al"
213 # Instead of having a variable for each match string just increment the
214 # total number of matches seen. That's simpler when testing large numbers
215 # of instructions (as these tests to).
218 -re "^ +\[0-9\]+ 0000 F3C5\[^\n\]*\n" { set x [expr $x+1] }
219 -re "^ +\[0-9\]+ 0002 B2\[^\n\]*\n" { set x [expr $x+1] }
220 -re "^ +\[0-9\]+ 0003 B7\[^\n\]*\n" { set x [expr $x+1] }
221 -re "^ +\[0-9\]+ 0004 BA\[^\n\]*\n" { set x [expr $x+1] }
222 -re "^ +\[0-9\]+ 0005 BD\[^\n\]*\n" { set x [expr $x+1] }
224 timeout { perror "timeout\n"; break }
229 # This was intended to do any cleanup necessary. It kinda looks like it
230 # isn't needed, but just in case, please keep it in for now.
233 # Did we find what we were looking for? If not, flunk it.
234 if [expr $x==5] then { pass $testname } else { fail $testname }
238 set testname "extend.s: extended instruction tests"
241 gas_start "extend.s" "-al"
243 # Instead of having a variable for each match string just increment the
244 # total number of matches seen. That's simpler when testing large numbers
245 # of instructions (as these tests to).
248 -re "^ +\[0-9\]+ 0000 F505\[^\n\]*\n" { set x [expr $x+1] }
249 -re "^ +\[0-9\]+ 0002 F6FA\[^\n\]*\n" { set x [expr $x+1] }
250 -re "^ +\[0-9\]+ 0004 F606\[^\n\]*\n" { set x [expr $x+1] }
251 -re "^ +\[0-9\]+ 0006 F90210\[^\n\]*\n" { set x [expr $x+1] }
252 -re "^ +\[0-9\]+ 0009 FB030100\[^\n\]*\n" { set x [expr $x+1] }
253 -re "^ +\[0-9\]+ 000d FD030001\[^\n\]*\n" { set x [expr $x+1] }
254 -re "^ +7 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
255 -re "^ +\[0-9\]+ 0013 F616\[^\n\]*\n" { set x [expr $x+1] }
256 -re "^ +\[0-9\]+ 0015 F91610\[^\n\]*\n" { set x [expr $x+1] }
257 -re "^ +\[0-9\]+ 0018 FB170100\[^\n\]*\n" { set x [expr $x+1] }
258 -re "^ +\[0-9\]+ 001c FD170001\[^\n\]*\n" { set x [expr $x+1] }
259 -re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
260 -re "^ +\[0-9\]+ 0022 F64B\[^\n\]*\n" { set x [expr $x+1] }
261 -re "^ +\[0-9\]+ 0024 F65E\[^\n\]*\n" { set x [expr $x+1] }
262 -re "^ +\[0-9\]+ 0026 F676\[^\n\]*\n" { set x [expr $x+1] }
264 timeout { perror "timeout\n"; break }
269 # This was intended to do any cleanup necessary. It kinda looks like it
270 # isn't needed, but just in case, please keep it in for now.
273 # Did we find what we were looking for? If not, flunk it.
274 if [expr $x==15] then { pass $testname } else { fail $testname }
278 set testname "logical.s: logical tests"
281 gas_start "logical.s" "-al"
283 # Instead of having a variable for each match string just increment the
284 # total number of matches seen. That's simpler when testing large numbers
285 # of instructions (as these tests to).
288 -re "^ +\[0-9\]+ 0000 F306\[^\n\]*\n" { set x [expr $x+1] }
289 -re "^ +\[0-9\]+ 0002 F5027F\[^\n\]*\n" { set x [expr $x+1] }
290 -re "^ +\[0-9\]+ 0005 F703FF7F\[^\n\]*\n" { set x [expr $x+1] }
291 -re "^ +\[0-9\]+ 0009 F710FF7F\[^\n\]*\n" { set x [expr $x+1] }
292 -re "^ +\[0-9\]+ 000d F316\[^\n\]*\n" { set x [expr $x+1] }
293 -re "^ +\[0-9\]+ 000f F50A7F\[^\n\]*\n" { set x [expr $x+1] }
294 -re "^ +\[0-9\]+ 0012 F743FF7F\[^\n\]*\n" { set x [expr $x+1] }
295 -re "^ +\[0-9\]+ 0016 F714FF7F\[^\n\]*\n" { set x [expr $x+1] }
296 -re "^ +\[0-9\]+ 001a F326\[^\n\]*\n" { set x [expr $x+1] }
297 -re "^ +\[0-9\]+ 001c F74FFF7F\[^\n\]*\n" { set x [expr $x+1] }
298 -re "^ +\[0-9\]+ 0020 F3E7\[^\n\]*\n" { set x [expr $x+1] }
299 -re "^\[^\n\]*\n" { }
300 timeout { perror "timeout\n"; break }
305 # This was intended to do any cleanup necessary. It kinda looks like it
306 # isn't needed, but just in case, please keep it in for now.
309 # Did we find what we were looking for? If not, flunk it.
310 if [expr $x==11] then { pass $testname } else { fail $testname }
314 set testname "loop.s: loop tests"
317 gas_start "loop.s" "-al"
319 # Instead of having a variable for each match string just increment the
320 # total number of matches seen. That's simpler when testing large numbers
321 # of instructions (as these tests to).
324 -re "^ +\[0-9\]+ 0000 D8\[^\n\]*\n" { set x [expr $x+1] }
325 -re "^ +\[0-9\]+ 0001 D9\[^\n\]*\n" { set x [expr $x+1] }
326 -re "^ +\[0-9\]+ 0002 D1\[^\n\]*\n" { set x [expr $x+1] }
327 -re "^ +\[0-9\]+ 0003 D2\[^\n\]*\n" { set x [expr $x+1] }
328 -re "^ +\[0-9\]+ 0004 D3\[^\n\]*\n" { set x [expr $x+1] }
329 -re "^ +\[0-9\]+ 0005 D0\[^\n\]*\n" { set x [expr $x+1] }
330 -re "^ +\[0-9\]+ 0006 D5\[^\n\]*\n" { set x [expr $x+1] }
331 -re "^ +\[0-9\]+ 0007 D6\[^\n\]*\n" { set x [expr $x+1] }
332 -re "^ +\[0-9\]+ 0008 D7\[^\n\]*\n" { set x [expr $x+1] }
333 -re "^ +\[0-9\]+ 0009 D4\[^\n\]*\n" { set x [expr $x+1] }
334 -re "^ +\[0-9\]+ 000a DA\[^\n\]*\n" { set x [expr $x+1] }
335 -re "^ +\[0-9\]+ 000b DB\[^\n\]*\n" { set x [expr $x+1] }
337 timeout { perror "timeout\n"; break }
342 # This was intended to do any cleanup necessary. It kinda looks like it
343 # isn't needed, but just in case, please keep it in for now.
346 # Did we find what we were looking for? If not, flunk it.
347 if [expr $x==12] then { pass $testname } else { fail $testname }
351 set testname "mov1.s: mov1 tests"
354 gas_start "mov1.s" "-al"
356 # Instead of having a variable for each match string just increment the
357 # total number of matches seen. That's simpler when testing large numbers
358 # of instructions (as these tests to).
361 -re "^ +\[0-9\]+ 0000 F236\[^\n\]*\n" { set x [expr $x+1] }
362 -re "^ +\[0-9\]+ 0002 F2F9\[^\n\]*\n" { set x [expr $x+1] }
363 -re "^ +\[0-9\]+ 0004 86\[^\n\]*\n" { set x [expr $x+1] }
364 -re "^ +\[0-9\]+ 0005 F279\[^\n\]*\n" { set x [expr $x+1] }
365 -re "^ +\[0-9\]+ 0007 F3F3\[^\n\]*\n" { set x [expr $x+1] }
366 -re "^ +\[0-9\]+ 0009 F3D8\[^\n\]*\n" { set x [expr $x+1] }
367 -re "^ +\[0-9\]+ 000b F3E1\[^\n\]*\n" { set x [expr $x+1] }
368 -re "^ +\[0-9\]+ 000d F3C8\[^\n\]*\n" { set x [expr $x+1] }
369 -re "^ +\[0-9\]+ 000f 29\[^\n\]*\n" { set x [expr $x+1] }
370 -re "^ +\[0-9\]+ 0010 6908\[^\n\]*\n" { set x [expr $x+1] }
371 -re "^ +\[0-9\]+ 0012 F7C90001\[^\n\]*\n" { set x [expr $x+1] }
372 -re "^ +\[0-9\]+ 0016 F489FFFF\[^\n\]*\n" { set x [expr $x+1] }
373 -re "^ +13 +01\[^\n\]*\n" { set x [expr $x+1] }
375 timeout { perror "timeout\n"; break }
380 # This was intended to do any cleanup necessary. It kinda looks like it
381 # isn't needed, but just in case, please keep it in for now.
384 # Did we find what we were looking for? If not, flunk it.
385 if [expr $x==13] then { pass $testname } else { fail $testname }
389 set testname "mov2.s: mov2 tests"
392 gas_start "mov2.s" "-al"
394 # Instead of having a variable for each match string just increment the
395 # total number of matches seen. That's simpler when testing large numbers
396 # of instructions (as these tests to).
399 -re "^ +\[0-9\]+ 0000 F156\[^\n\]*\n" { set x [expr $x+1] }
400 -re "^ +\[0-9\]+ 0002 C90080\[^\n\]*\n" { set x [expr $x+1] }
401 -re "^ +\[0-9\]+ 0005 F4C1FFFF\[^\n\]*\n" { set x [expr $x+1] }
402 -re "^ +4 +01\[^\n\]*\n" { set x [expr $x+1] }
403 -re "^ +\[0-9\]+ 000a 7908\[^\n\]*\n" { set x [expr $x+1] }
404 -re "^ +\[0-9\]+ 000c F7B90001\[^\n\]*\n" { set x [expr $x+1] }
405 -re "^ +\[0-9\]+ 0010 F4F9FFFF \[^\n\]*\n" { set x [expr $x+1] }
406 -re "^ +7 +01\[^\n\]*\n" { set x [expr $x+1] }
407 -re "^ +\[0-9\]+ 0015 F116\[^\n\]*\n" { set x [expr $x+1] }
408 -re "^ +\[0-9\]+ 0017 F7310080\[^\n\]*\n" { set x [expr $x+1] }
409 -re "^ +\[0-9\]+ 001b F4D1FFFF\[^\n\]*\n" { set x [expr $x+1] }
410 -re "^ +10 +01\[^\n\]*\n" { set x [expr $x+1] }
412 timeout { perror "timeout\n"; break }
417 # This was intended to do any cleanup necessary. It kinda looks like it
418 # isn't needed, but just in case, please keep it in for now.
421 # Did we find what we were looking for? If not, flunk it.
422 if [expr $x==12] then { pass $testname } else { fail $testname }
426 set testname "mov3.s: mov3 tests"
429 gas_start "mov3.s" "-al"
431 # Instead of having a variable for each match string just increment the
432 # total number of matches seen. That's simpler when testing large numbers
433 # of instructions (as these tests to).
436 -re "^ +\[0-9\]+ 0000 09\[^\n\]*\n" { set x [expr $x+1] }
437 -re "^ +\[0-9\]+ 0001 4920\[^\n\]*\n" { set x [expr $x+1] }
438 -re "^ +\[0-9\]+ 0003 F7890001\[^\n\]*\n" { set x [expr $x+1] }
439 -re "^ +\[0-9\]+ 0007 F409FFFF\[^\n\]*\n" { set x [expr $x+1] }
440 -re "^ +5 +01\[^\n\]*\n" { set x [expr $x+1] }
441 -re "^ +\[0-9\]+ 000c F1E9\[^\n\]*\n" { set x [expr $x+1] }
442 -re "^ +\[0-9\]+ 000e C18000\[^\n\]*\n" { set x [expr $x+1] }
443 -re "^ +\[0-9\]+ 0011 F441FFFF\[^\n\]*\n" { set x [expr $x+1] }
444 -re "^ +8 +01\[^\n\]*\n" { set x [expr $x+1] }
445 -re "^ +\[0-9\]+ 0016 5920\[^\n\]*\n" { set x [expr $x+1] }
446 -re "^ +\[0-9\]+ 0018 F7A90001\[^\n\]*\n" { set x [expr $x+1] }
447 -re "^ +\[0-9\]+ 001c F419FFFF\[^\n\]*\n" { set x [expr $x+1] }
448 -re "^ +11 +01\[^\n\]*\n" { set x [expr $x+1] }
450 timeout { perror "timeout\n"; break }
455 # This was intended to do any cleanup necessary. It kinda looks like it
456 # isn't needed, but just in case, please keep it in for now.
459 # Did we find what we were looking for? If not, flunk it.
460 if [expr $x==13] then { pass $testname } else { fail $testname }
464 set testname "mov4.s: mov4 tests"
467 gas_start "mov4.s" "-al"
469 # Instead of having a variable for each match string just increment the
470 # total number of matches seen. That's simpler when testing large numbers
471 # of instructions (as these tests to).
474 -re "^ +\[0-9\]+ 0000 F1A9\[^\n\]*\n" { set x [expr $x+1] }
475 -re "^ +\[0-9\]+ 0002 F7218000\[^\n\]*\n" { set x [expr $x+1] }
476 -re "^ +\[0-9\]+ 0006 F451FFFF\[^\n\]*\n" { set x [expr $x+1] }
477 -re "^ +4 +01\[^\n\]*\n" { set x [expr $x+1] }
478 -re "^ +\[0-9\]+ 000b 8508\[^\n\]*\n" { set x [expr $x+1] }
479 -re "^ +\[0-9\]+ 000d F90001\[^\n\]*\n" { set x [expr $x+1] }
480 -re "^ +\[0-9\]+ 0010 F471FFFF\[^\n\]*\n" { set x [expr $x+1] }
481 -re "^ +7 +01\[^\n\]*\n" { set x [expr $x+1] }
482 -re "^ +\[0-9\]+ 0015 DD0001\[^\n\]*\n" { set x [expr $x+1] }
483 -re "^ +\[0-9\]+ 0018 F475FFFF\[^\n\]*\n" { set x [expr $x+1] }
484 -re "^ +9 +01\[^\n\]*\n" { set x [expr $x+1] }
486 timeout { perror "timeout\n"; break }
491 # This was intended to do any cleanup necessary. It kinda looks like it
492 # isn't needed, but just in case, please keep it in for now.
495 # Did we find what we were looking for? If not, flunk it.
496 if [expr $x==11] then { pass $testname } else { fail $testname }
500 set testname "movx.s: movx tests"
503 gas_start "movx.s" "-al"
505 # Instead of having a variable for each match string just increment the
506 # total number of matches seen. That's simpler when testing large numbers
507 # of instructions (as these tests to).
510 -re "^ +\[0-9\]+ 0000 F57908\[^\n\]*\n" { set x [expr $x+1] }
511 -re "^ +\[0-9\]+ 0003 F7790001\[^\n\]*\n" { set x [expr $x+1] }
512 -re "^ +\[0-9\]+ 0007 F4B9FFFF\[^\n\]*\n" { set x [expr $x+1] }
513 -re "^ +4 +01\[^\n\]*\n" { set x [expr $x+1] }
514 -re "^ +\[0-9\]+ 000c F55908\[^\n\]*\n" { set x [expr $x+1] }
515 -re "^ +\[0-9\]+ 000f F7690001\[^\n\]*\n" { set x [expr $x+1] }
516 -re "^ +\[0-9\]+ 0013 F439FFFF\[^\n\]*\n" { set x [expr $x+1] }
517 -re "^ +7 +01\[^\n\]*\n" { set x [expr $x+1] }
519 timeout { perror "timeout\n"; break }
524 # This was intended to do any cleanup necessary. It kinda looks like it
525 # isn't needed, but just in case, please keep it in for now.
528 # Did we find what we were looking for? If not, flunk it.
529 if [expr $x==8] then { pass $testname } else { fail $testname }
533 set testname "movb.s: movb tests"
536 gas_start "movb.s" "-al"
538 # Instead of having a variable for each match string just increment the
539 # total number of matches seen. That's simpler when testing large numbers
540 # of instructions (as these tests to).
543 -re "^ +\[0-9\]+ 0000 F52908\[^\n\]*\n" { set x [expr $x+1] }
544 -re "^ +\[0-9\]+ 0003 F7D90001\[^\n\]*\n" { set x [expr $x+1] }
545 -re "^ +\[0-9\]+ 0007 F4A9FFFF\[^\n\]*\n" { set x [expr $x+1] }
546 -re "^ +4 +01\[^\n\]*\n" { set x [expr $x+1] }
547 -re "^ +\[0-9\]+ 000c F06B\[^\n\]*\n" { set x [expr $x+1] }
548 -re "^ +\[0-9\]+ 000e F4C6FFFF\[^\n\]*\n" { set x [expr $x+1] }
549 -re "^ +6 +01\[^\n\]*\n" { set x [expr $x+1] }
550 -re "^ +\[0-9\]+ 0013 19\[^\n\]*\n" { set x [expr $x+1] }
551 -re "^ +\[0-9\]+ 0014 F51908\[^\n\]*\n" { set x [expr $x+1] }
552 -re "^ +\[0-9\]+ 0017 F7990001\[^\n\]*\n" { set x [expr $x+1] }
553 -re "^ +\[0-9\]+ 001b F429FFFF\[^\n\]*\n" { set x [expr $x+1] }
554 -re "^ +10 +01\[^\n\]*\n" { set x [expr $x+1] }
555 -re "^ +\[0-9\]+ 0020 F0E9\[^\n\]*\n" { set x [expr $x+1] }
556 -re "^ +\[0-9\]+ 0022 C50001\[^\n\]*\n" { set x [expr $x+1] }
557 -re "^ +\[0-9\]+ 0025 F445FFFF\[^\n\]*\n" { set x [expr $x+1] }
558 -re "^ +13 +01\[^\n\]*\n" { set x [expr $x+1] }
560 timeout { perror "timeout\n"; break }
565 # This was intended to do any cleanup necessary. It kinda looks like it
566 # isn't needed, but just in case, please keep it in for now.
569 # Did we find what we were looking for? If not, flunk it.
570 if [expr $x==16] then { pass $testname } else { fail $testname }
574 set testname "movbu.s: movbu tests"
577 gas_start "movbu.s" "-al"
579 # Instead of having a variable for each match string just increment the
580 # total number of matches seen. That's simpler when testing large numbers
581 # of instructions (as these tests to).
584 -re "^ +\[0-9\]+ 0000 39\[^\n\]*\n" { set x [expr $x+1] }
585 -re "^ +\[0-9\]+ 0001 F53908\[^\n\]*\n" { set x [expr $x+1] }
586 -re "^ +\[0-9\]+ 0004 F7590001\[^\n\]*\n" { set x [expr $x+1] }
587 -re "^ +\[0-9\]+ 0008 F499FFFF\[^\n\]*\n" { set x [expr $x+1] }
588 -re "^ +5 +01\[^\n\]*\n" { set x [expr $x+1] }
589 -re "^ +\[0-9\]+ 000d F096\[^\n\]*\n" { set x [expr $x+1] }
590 -re "^ +\[0-9\]+ 000f CD0080\[^\n\]*\n" { set x [expr $x+1] }
591 -re "^ +\[0-9\]+ 0012 F4C9FFFF\[^\n\]*\n" { set x [expr $x+1] }
592 -re "^ +8 +01\[^\n\]*\n" { set x [expr $x+1] }
594 timeout { perror "timeout\n"; break }
599 # This was intended to do any cleanup necessary. It kinda looks like it
600 # isn't needed, but just in case, please keep it in for now.
603 # Did we find what we were looking for? If not, flunk it.
604 if [expr $x==9] then { pass $testname } else { fail $testname }
608 set testname "movhu.s: movhu tests"
611 gas_start "movhu.s" "-al"
613 # Instead of having a variable for each match string just increment the
614 # total number of matches seen. That's simpler when testing large numbers
615 # of instructions (as these tests to).
618 -re "^ +\[0-9\]+ 0000 F066\[^\n\]*\n" { set x [expr $x+1] }
619 -re "^ +\[0-9\]+ 0002 F86608\[^\n\]*\n" { set x [expr $x+1] }
620 -re "^ +\[0-9\]+ 0005 FA660100\[^\n\]*\n" { set x [expr $x+1] }
621 -re "^ +\[0-9\]+ 0009 FC660001\[^\n\]*\n" { set x [expr $x+1] }
622 -re "^ +5 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
623 -re "^ +\[0-9\]+ 000f F8BD08\[^\n\]*\n" { set x [expr $x+1] }
624 -re "^ +\[0-9\]+ 0012 FABD0100\[^\n\]*\n" { set x [expr $x+1] }
625 -re "^ +\[0-9\]+ 0016 FCBD0001\[^\n\]*\n" { set x [expr $x+1] }
626 -re "^ +8 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
627 -re "^ +\[0-9\]+ 001c F4A5\[^\n\]*\n" { set x [expr $x+1] }
628 -re "^ +\[0-9\]+ 001e 398000\[^\n\]*\n" { set x [expr $x+1] }
629 -re "^ +\[0-9\]+ 0021 FCAD0001\[^\n\]*\n" { set x [expr $x+1] }
630 -re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
631 -re "^ +\[0-9\]+ 0027 F076\[^\n\]*\n" { set x [expr $x+1] }
632 -re "^ +\[0-9\]+ 0029 F87620\[^\n\]*\n" { set x [expr $x+1] }
633 -re "^ +\[0-9\]+ 002c FA760100\[^\n\]*\n" { set x [expr $x+1] }
634 -re "^ +\[0-9\]+ 0030 FC760001\[^\n\]*\n" { set x [expr $x+1] }
635 -re "^ +15 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
636 -re "^ +\[0-9\]+ 0036 F89720\[^\n\]*\n" { set x [expr $x+1] }
637 -re "^ +\[0-9\]+ 0039 FA978000\[^\n\]*\n" { set x [expr $x+1] }
638 -re "^ +\[0-9\]+ 003d FC970001\[^\n\]*\n" { set x [expr $x+1] }
639 -re "^ +18 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
640 -re "^ +\[0-9\]+ 0043 F4DA\[^\n\]*\n" { set x [expr $x+1] }
641 -re "^ +\[0-9\]+ 0045 070080\[^\n\]*\n" { set x [expr $x+1] }
642 -re "^ +\[0-9\]+ 0048 FC870001\[^\n\]*\n" { set x [expr $x+1] }
643 -re "^ +21 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
645 timeout { perror "timeout\n"; break }
650 # This was intended to do any cleanup necessary. It kinda looks like it
651 # isn't needed, but just in case, please keep it in for now.
654 # Did we find what we were looking for? If not, flunk it.
655 if [expr $x==26] then { pass $testname } else { fail $testname }
659 set testname "movm.s: movm tests"
662 gas_start "movm.s" "-al"
664 # Instead of having a variable for each match string just increment the
665 # total number of matches seen. That's simpler when testing large numbers
666 # of instructions (as these tests to).
669 -re "^ +\[0-9\]+ 0000 CE30\[^\n\]*\n" { set x [expr $x+1] }
670 -re "^ +\[0-9\]+ 0002 CEF8\[^\n\]*\n" { set x [expr $x+1] }
671 -re "^ +\[0-9\]+ 0004 CF30\[^\n\]*\n" { set x [expr $x+1] }
672 -re "^ +\[0-9\]+ 0006 CFF8\[^\n\]*\n" { set x [expr $x+1] }
674 timeout { perror "timeout\n"; break }
679 # This was intended to do any cleanup necessary. It kinda looks like it
680 # isn't needed, but just in case, please keep it in for now.
683 # Did we find what we were looking for? If not, flunk it.
684 if [expr $x==4] then { pass $testname } else { fail $testname }
688 set testname "muldiv.s: muldiv tests"
691 gas_start "muldiv.s" "-al"
693 # Instead of having a variable for each match string just increment the
694 # total number of matches seen. That's simpler when testing large numbers
695 # of instructions (as these tests to).
698 -re "^ +\[0-9\]+ 0000 F346\[^\n\]*\n" { set x [expr $x+1] }
699 -re "^ +\[0-9\]+ 0002 F35B\[^\n\]*\n" { set x [expr $x+1] }
700 -re "^ +\[0-9\]+ 0004 F36E\[^\n\]*\n" { set x [expr $x+1] }
702 timeout { perror "timeout\n"; break }
707 # This was intended to do any cleanup necessary. It kinda looks like it
708 # isn't needed, but just in case, please keep it in for now.
711 # Did we find what we were looking for? If not, flunk it.
712 if [expr $x==3] then { pass $testname } else { fail $testname }
716 set testname "other.s: other tests"
719 gas_start "other.s" "-al"
721 # Instead of having a variable for each match string just increment the
722 # total number of matches seen. That's simpler when testing large numbers
723 # of instructions (as these tests to).
726 -re "^ +\[0-9\]+ 0000 FC0001\[^\n\]*\n" { set x [expr $x+1] }
727 -re "^ +\[0-9\]+ 0003 F4E0FFFF\[^\n\]*\n" { set x [expr $x+1] }
728 -re "^ +3 +01\[^\n\]*\n" { set x [expr $x+1] }
729 -re "^ +\[0-9\]+ 0008 F008\[^\n\]*\n" { set x [expr $x+1] }
730 -re "^ +\[0-9\]+ 000a FD0001\[^\n\]*\n" { set x [expr $x+1] }
731 -re "^ +\[0-9\]+ 000d F4E1FFFF\[^\n\]*\n" { set x [expr $x+1] }
732 -re "^ +6 +01\[^\n\]*\n" { set x [expr $x+1] }
733 -re "^ +\[0-9\]+ 0012 F009\[^\n\]*\n" { set x [expr $x+1] }
734 -re "^ +\[0-9\]+ 0014 FE\[^\n\]*\n" { set x [expr $x+1] }
735 -re "^ +\[0-9\]+ 0015 EB\[^\n\]*\n" { set x [expr $x+1] }
736 -re "^ +\[0-9\]+ 0016 F6\[^\n\]*\n" { set x [expr $x+1] }
738 timeout { perror "timeout\n"; break }
743 # This was intended to do any cleanup necessary. It kinda looks like it
744 # isn't needed, but just in case, please keep it in for now.
747 # Did we find what we were looking for? If not, flunk it.
748 if [expr $x==11] then { pass $testname } else { fail $testname }
752 set testname "shift.s: shift tests"
755 gas_start "shift.s" "-al"
757 # Instead of having a variable for each match string just increment the
758 # total number of matches seen. That's simpler when testing large numbers
759 # of instructions (as these tests to).
762 -re "^ +\[0-9\]+ 0000 F33A\[^\n\]*\n" { set x [expr $x+1] }
763 -re "^ +\[0-9\]+ 0002 F33F\[^\n\]*\n" { set x [expr $x+1] }
764 -re "^ +\[0-9\]+ 0004 F335\[^\n\]*\n" { set x [expr $x+1] }
765 -re "^ +\[0-9\]+ 0006 F332\[^\n\]*\n" { set x [expr $x+1] }
767 timeout { perror "timeout\n"; break }
772 # This was intended to do any cleanup necessary. It kinda looks like it
773 # isn't needed, but just in case, please keep it in for now.
776 # Did we find what we were looking for? If not, flunk it.
777 if [expr $x==4] then { pass $testname } else { fail $testname }
781 set testname "sub.s: sub tests"
784 gas_start "sub.s" "-al"
786 # Instead of having a variable for each match string just increment the
787 # total number of matches seen. That's simpler when testing large numbers
788 # of instructions (as these tests to).
791 -re "^ +\[0-9\]+ 0000 A6\[^\n\]*\n" { set x [expr $x+1] }
792 -re "^ +\[0-9\]+ 0001 F21B\[^\n\]*\n" { set x [expr $x+1] }
793 -re "^ +\[0-9\]+ 0003 F2DF\[^\n\]*\n" { set x [expr $x+1] }
794 -re "^ +\[0-9\]+ 0005 F25E\[^\n\]*\n" { set x [expr $x+1] }
795 -re "^ +\[0-9\]+ 0007 F71EFF7F \[^\n\]*\n" { set x [expr $x+1] }
796 -re "^ +\[0-9\]+ 000b F46AFFFF\[^\n\]*\n" { set x [expr $x+1] }
797 -re "^ +7 +01\[^\n\]*\n" { set x [expr $x+1] }
798 -re "^ +\[0-9\]+ 0010 F70EFF7F \[^\n\]*\n" { set x [expr $x+1] }
799 -re "^ +\[0-9\]+ 0014 F46EFFFF\[^\n\]*\n" { set x [expr $x+1] }
800 -re "^ +9 +01\[^\n\]*\n" { set x [expr $x+1] }
801 -re "^ +\[0-9\]+ 0019 F296 \[^\n\]*\n" { set x [expr $x+1] }
803 timeout { perror "timeout\n"; break }
808 # This was intended to do any cleanup necessary. It kinda looks like it
809 # isn't needed, but just in case, please keep it in for now.
812 # Did we find what we were looking for? If not, flunk it.
813 if [expr $x==11] then { pass $testname } else { fail $testname }
816 if [istarget mn10200*-*-*] then {
817 # Test the basic instruction parser.