Commit | Line | Data |
---|---|---|
aa820537 | 1 | # Copyright (C) 1996, 2002, 2005, 2007 Free Software Foundation, Inc. |
252b5132 RH |
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 | |
ec2655a6 | 5 | # the Free Software Foundation; either version 3 of the License, or |
252b5132 RH |
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 | |
4b4da160 | 15 | # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ |
252b5132 RH |
16 | |
17 | # Please email any bugs, comments, and/or additions to this file to: | |
fc697c14 | 18 | # dejagnu@gnu.org |
252b5132 RH |
19 | |
20 | # Written by Cygnus Support. | |
21 | ||
22 | proc do_add {} { | |
23 | set testname "add.s: Add operations" | |
24 | set x 0 | |
25 | ||
26 | gas_start "add.s" "-al" | |
27 | ||
28 | # Instead of having a variable for each match string just increment the | |
29 | # total number of matches seen. That's simpler when testing large numbers | |
30 | # of instructions (as these tests to). | |
31 | while 1 { | |
32 | expect { | |
33 | -re "^ +\[0-9\]+ 0000 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] } | |
47 | -re "\[^\n\]*\n" { } | |
48 | timeout { perror "timeout\n"; break } | |
49 | eof { break } | |
50 | } | |
51 | } | |
52 | ||
53 | # This was intended to do any cleanup necessary. It kinda looks like it | |
54 | # isn't needed, but just in case, please keep it in for now. | |
55 | gas_finish | |
56 | ||
57 | # Did we find what we were looking for? If not, flunk it. | |
58 | if [expr $x==14] then { pass $testname } else { fail $testname } | |
59 | } | |
60 | ||
61 | proc do_bcc {} { | |
62 | set testname "bcc.s: Bcc tests" | |
63 | set x 0 | |
64 | ||
65 | gas_start "bcc.s" "-al" | |
66 | ||
67 | # Instead of having a variable for each match string just increment the | |
68 | # total number of matches seen. That's simpler when testing large numbers | |
69 | # of instructions (as these tests to). | |
70 | while 1 { | |
71 | expect { | |
72 | -re "^ +\[0-9\]+ 0000 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] } | |
87 | -re "\[^\n\]*\n" { } | |
88 | timeout { perror "timeout\n"; break } | |
89 | eof { break } | |
90 | } | |
91 | } | |
92 | ||
93 | # This was intended to do any cleanup necessary. It kinda looks like it | |
94 | # isn't needed, but just in case, please keep it in for now. | |
95 | gas_finish | |
96 | ||
97 | # Did we find what we were looking for? If not, flunk it. | |
98 | if [expr $x==15] then { pass $testname } else { fail $testname } | |
99 | } | |
100 | ||
101 | proc do_bccx {} { | |
102 | set testname "bccx.s: Bccx tests" | |
103 | set x 0 | |
104 | ||
105 | gas_start "bccx.s" "-al" | |
106 | ||
107 | # Instead of having a variable for each match string just increment the | |
108 | # total number of matches seen. That's simpler when testing large numbers | |
109 | # of instructions (as these tests to). | |
110 | while 1 { | |
111 | expect { | |
112 | -re "^ +\[0-9\]+ 0000 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] } | |
126 | -re "\[^\n\]*\n" { } | |
127 | timeout { perror "timeout\n"; break } | |
128 | eof { break } | |
129 | } | |
130 | } | |
131 | ||
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. | |
134 | gas_finish | |
135 | ||
136 | # Did we find what we were looking for? If not, flunk it. | |
137 | if [expr $x==14] then { pass $testname } else { fail $testname } | |
138 | } | |
139 | ||
140 | proc do_bit {} { | |
141 | set testname "bit.s: bit tests" | |
142 | set x 0 | |
143 | ||
144 | gas_start "bit.s" "-al" | |
145 | ||
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). | |
149 | while 1 { | |
150 | expect { | |
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] } | |
156 | -re "\[^\n\]*\n" { } | |
157 | timeout { perror "timeout\n"; break } | |
158 | eof { break } | |
159 | } | |
160 | } | |
161 | ||
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. | |
164 | gas_finish | |
165 | ||
166 | # Did we find what we were looking for? If not, flunk it. | |
167 | if [expr $x==4] then { pass $testname } else { fail $testname } | |
168 | } | |
169 | ||
170 | ||
171 | proc do_cmp {} { | |
172 | set testname "cmp.s: cmp tests" | |
173 | set x 0 | |
174 | ||
175 | gas_start "cmp.s" "-al" | |
176 | ||
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). | |
180 | while 1 { | |
181 | expect { | |
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] } | |
193 | -re "\[^\n\]*\n" { } | |
194 | timeout { perror "timeout\n"; break } | |
195 | eof { break } | |
196 | } | |
197 | } | |
198 | ||
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. | |
201 | gas_finish | |
202 | ||
203 | # Did we find what we were looking for? If not, flunk it. | |
204 | if [expr $x==11] then { pass $testname } else { fail $testname } | |
205 | } | |
206 | ||
207 | proc do_ext {} { | |
208 | set testname "ext.s: ext tests" | |
209 | set x 0 | |
210 | ||
211 | gas_start "ext.s" "-al" | |
212 | ||
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). | |
216 | while 1 { | |
217 | expect { | |
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] } | |
223 | -re "\[^\n\]*\n" { } | |
224 | timeout { perror "timeout\n"; break } | |
225 | eof { break } | |
226 | } | |
227 | } | |
228 | ||
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. | |
231 | gas_finish | |
232 | ||
233 | # Did we find what we were looking for? If not, flunk it. | |
234 | if [expr $x==5] then { pass $testname } else { fail $testname } | |
235 | } | |
236 | ||
237 | proc do_extend {} { | |
238 | set testname "extend.s: extended instruction tests" | |
239 | set x 0 | |
240 | ||
241 | gas_start "extend.s" "-al" | |
242 | ||
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). | |
246 | while 1 { | |
247 | expect { | |
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] } | |
263 | -re "\[^\n\]*\n" { } | |
264 | timeout { perror "timeout\n"; break } | |
265 | eof { break } | |
266 | } | |
267 | } | |
268 | ||
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. | |
271 | gas_finish | |
272 | ||
273 | # Did we find what we were looking for? If not, flunk it. | |
274 | if [expr $x==15] then { pass $testname } else { fail $testname } | |
275 | } | |
276 | ||
277 | proc do_logical {} { | |
278 | set testname "logical.s: logical tests" | |
279 | set x 0 | |
280 | ||
281 | gas_start "logical.s" "-al" | |
282 | ||
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). | |
286 | while 1 { | |
287 | expect { | |
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 } | |
301 | eof { break } | |
302 | } | |
303 | } | |
304 | ||
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. | |
307 | gas_finish | |
308 | ||
309 | # Did we find what we were looking for? If not, flunk it. | |
310 | if [expr $x==11] then { pass $testname } else { fail $testname } | |
311 | } | |
312 | ||
313 | proc do_loop {} { | |
314 | set testname "loop.s: loop tests" | |
315 | set x 0 | |
316 | ||
317 | gas_start "loop.s" "-al" | |
318 | ||
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). | |
322 | while 1 { | |
323 | expect { | |
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] } | |
336 | -re "\[^\n\]*\n" { } | |
337 | timeout { perror "timeout\n"; break } | |
338 | eof { break } | |
339 | } | |
340 | } | |
341 | ||
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. | |
344 | gas_finish | |
345 | ||
346 | # Did we find what we were looking for? If not, flunk it. | |
347 | if [expr $x==12] then { pass $testname } else { fail $testname } | |
348 | } | |
349 | ||
350 | proc do_mov1 {} { | |
351 | set testname "mov1.s: mov1 tests" | |
352 | set x 0 | |
353 | ||
354 | gas_start "mov1.s" "-al" | |
355 | ||
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). | |
359 | while 1 { | |
360 | expect { | |
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] } | |
374 | -re "\[^\n\]*\n" { } | |
375 | timeout { perror "timeout\n"; break } | |
376 | eof { break } | |
377 | } | |
378 | } | |
379 | ||
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. | |
382 | gas_finish | |
383 | ||
384 | # Did we find what we were looking for? If not, flunk it. | |
385 | if [expr $x==13] then { pass $testname } else { fail $testname } | |
386 | } | |
387 | ||
388 | proc do_mov2 {} { | |
389 | set testname "mov2.s: mov2 tests" | |
390 | set x 0 | |
391 | ||
392 | gas_start "mov2.s" "-al" | |
393 | ||
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). | |
397 | while 1 { | |
398 | expect { | |
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] } | |
411 | -re "\[^\n\]*\n" { } | |
412 | timeout { perror "timeout\n"; break } | |
413 | eof { break } | |
414 | } | |
415 | } | |
416 | ||
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. | |
419 | gas_finish | |
420 | ||
421 | # Did we find what we were looking for? If not, flunk it. | |
422 | if [expr $x==12] then { pass $testname } else { fail $testname } | |
423 | } | |
424 | ||
425 | proc do_mov3 {} { | |
426 | set testname "mov3.s: mov3 tests" | |
427 | set x 0 | |
428 | ||
429 | gas_start "mov3.s" "-al" | |
430 | ||
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). | |
434 | while 1 { | |
435 | expect { | |
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] } | |
449 | -re "\[^\n\]*\n" { } | |
450 | timeout { perror "timeout\n"; break } | |
451 | eof { break } | |
452 | } | |
453 | } | |
454 | ||
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. | |
457 | gas_finish | |
458 | ||
459 | # Did we find what we were looking for? If not, flunk it. | |
460 | if [expr $x==13] then { pass $testname } else { fail $testname } | |
461 | } | |
462 | ||
463 | proc do_mov4 {} { | |
464 | set testname "mov4.s: mov4 tests" | |
465 | set x 0 | |
466 | ||
467 | gas_start "mov4.s" "-al" | |
468 | ||
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). | |
472 | while 1 { | |
473 | expect { | |
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] } | |
485 | -re "\[^\n\]*\n" { } | |
486 | timeout { perror "timeout\n"; break } | |
487 | eof { break } | |
488 | } | |
489 | } | |
490 | ||
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. | |
493 | gas_finish | |
494 | ||
495 | # Did we find what we were looking for? If not, flunk it. | |
496 | if [expr $x==11] then { pass $testname } else { fail $testname } | |
497 | } | |
498 | ||
499 | proc do_movx {} { | |
500 | set testname "movx.s: movx tests" | |
501 | set x 0 | |
502 | ||
503 | gas_start "movx.s" "-al" | |
504 | ||
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). | |
508 | while 1 { | |
509 | expect { | |
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] } | |
518 | -re "\[^\n\]*\n" { } | |
519 | timeout { perror "timeout\n"; break } | |
520 | eof { break } | |
521 | } | |
522 | } | |
523 | ||
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. | |
526 | gas_finish | |
527 | ||
528 | # Did we find what we were looking for? If not, flunk it. | |
529 | if [expr $x==8] then { pass $testname } else { fail $testname } | |
530 | } | |
531 | ||
532 | proc do_movb {} { | |
533 | set testname "movb.s: movb tests" | |
534 | set x 0 | |
535 | ||
536 | gas_start "movb.s" "-al" | |
537 | ||
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). | |
541 | while 1 { | |
542 | expect { | |
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] } | |
559 | -re "\[^\n\]*\n" { } | |
560 | timeout { perror "timeout\n"; break } | |
561 | eof { break } | |
562 | } | |
563 | } | |
564 | ||
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. | |
567 | gas_finish | |
568 | ||
569 | # Did we find what we were looking for? If not, flunk it. | |
570 | if [expr $x==16] then { pass $testname } else { fail $testname } | |
571 | } | |
572 | ||
573 | proc do_movbu {} { | |
574 | set testname "movbu.s: movbu tests" | |
575 | set x 0 | |
576 | ||
577 | gas_start "movbu.s" "-al" | |
578 | ||
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). | |
582 | while 1 { | |
583 | expect { | |
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] } | |
593 | -re "\[^\n\]*\n" { } | |
594 | timeout { perror "timeout\n"; break } | |
595 | eof { break } | |
596 | } | |
597 | } | |
598 | ||
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. | |
601 | gas_finish | |
602 | ||
603 | # Did we find what we were looking for? If not, flunk it. | |
604 | if [expr $x==9] then { pass $testname } else { fail $testname } | |
605 | } | |
606 | ||
607 | proc do_movhu {} { | |
608 | set testname "movhu.s: movhu tests" | |
609 | set x 0 | |
610 | ||
611 | gas_start "movhu.s" "-al" | |
612 | ||
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). | |
616 | while 1 { | |
617 | expect { | |
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] } | |
644 | -re "\[^\n\]*\n" { } | |
645 | timeout { perror "timeout\n"; break } | |
646 | eof { break } | |
647 | } | |
648 | } | |
649 | ||
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. | |
652 | gas_finish | |
653 | ||
654 | # Did we find what we were looking for? If not, flunk it. | |
655 | if [expr $x==26] then { pass $testname } else { fail $testname } | |
656 | } | |
657 | ||
658 | proc do_movm {} { | |
659 | set testname "movm.s: movm tests" | |
660 | set x 0 | |
661 | ||
662 | gas_start "movm.s" "-al" | |
663 | ||
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). | |
667 | while 1 { | |
668 | expect { | |
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] } | |
673 | -re "\[^\n\]*\n" { } | |
674 | timeout { perror "timeout\n"; break } | |
675 | eof { break } | |
676 | } | |
677 | } | |
678 | ||
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. | |
681 | gas_finish | |
682 | ||
683 | # Did we find what we were looking for? If not, flunk it. | |
684 | if [expr $x==4] then { pass $testname } else { fail $testname } | |
685 | } | |
686 | ||
687 | proc do_muldiv {} { | |
688 | set testname "muldiv.s: muldiv tests" | |
689 | set x 0 | |
690 | ||
691 | gas_start "muldiv.s" "-al" | |
692 | ||
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). | |
696 | while 1 { | |
697 | expect { | |
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] } | |
701 | -re "\[^\n\]*\n" { } | |
702 | timeout { perror "timeout\n"; break } | |
703 | eof { break } | |
704 | } | |
705 | } | |
706 | ||
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. | |
709 | gas_finish | |
710 | ||
711 | # Did we find what we were looking for? If not, flunk it. | |
712 | if [expr $x==3] then { pass $testname } else { fail $testname } | |
713 | } | |
714 | ||
715 | proc do_other {} { | |
716 | set testname "other.s: other tests" | |
717 | set x 0 | |
718 | ||
719 | gas_start "other.s" "-al" | |
720 | ||
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). | |
724 | while 1 { | |
725 | expect { | |
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] } | |
737 | -re "\[^\n\]*\n" { } | |
738 | timeout { perror "timeout\n"; break } | |
739 | eof { break } | |
740 | } | |
741 | } | |
742 | ||
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. | |
745 | gas_finish | |
746 | ||
747 | # Did we find what we were looking for? If not, flunk it. | |
748 | if [expr $x==11] then { pass $testname } else { fail $testname } | |
749 | } | |
750 | ||
751 | proc do_shift {} { | |
752 | set testname "shift.s: shift tests" | |
753 | set x 0 | |
754 | ||
755 | gas_start "shift.s" "-al" | |
756 | ||
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). | |
760 | while 1 { | |
761 | expect { | |
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] } | |
766 | -re "\[^\n\]*\n" { } | |
767 | timeout { perror "timeout\n"; break } | |
768 | eof { break } | |
769 | } | |
770 | } | |
771 | ||
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. | |
774 | gas_finish | |
775 | ||
776 | # Did we find what we were looking for? If not, flunk it. | |
777 | if [expr $x==4] then { pass $testname } else { fail $testname } | |
778 | } | |
779 | ||
780 | proc do_sub {} { | |
781 | set testname "sub.s: sub tests" | |
782 | set x 0 | |
783 | ||
784 | gas_start "sub.s" "-al" | |
785 | ||
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). | |
789 | while 1 { | |
790 | expect { | |
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] } | |
802 | -re "\[^\n\]*\n" { } | |
803 | timeout { perror "timeout\n"; break } | |
804 | eof { break } | |
805 | } | |
806 | } | |
807 | ||
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. | |
810 | gas_finish | |
811 | ||
812 | # Did we find what we were looking for? If not, flunk it. | |
813 | if [expr $x==11] then { pass $testname } else { fail $testname } | |
814 | } | |
815 | ||
816 | if [istarget mn10200*-*-*] then { | |
817 | # Test the basic instruction parser. | |
818 | do_add | |
819 | do_bcc | |
820 | do_bccx | |
821 | do_bit | |
822 | do_cmp | |
823 | do_ext | |
824 | do_logical | |
825 | do_mov1 | |
826 | do_mov2 | |
827 | do_mov3 | |
828 | do_mov4 | |
829 | do_movb | |
830 | do_movx | |
831 | do_movbu | |
832 | do_muldiv | |
833 | do_other | |
834 | do_shift | |
835 | do_sub | |
836 | } |