projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* gas/mn10200/*.s: New tests for the mn10200 assembler.
[deliverable/binutils-gdb.git] / gas / testsuite / gas / mn10200 / basic.exp
CommitLineData
9d49699b
JL		 1# Copyright (C) 1996 Free Software Foundation, Inc.
2
3# This program is free software; you can redistribute it and/or modify
4# it under the terms of the GNU General Public License as published by
5# the Free Software Foundation; either version 2 of the License, or
6# (at your option) any later version.
7#
8# This program is distributed in the hope that it will be useful,
9# but WITHOUT ANY WARRANTY; without even the implied warranty of
10# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11# GNU General Public License for more details.
12#
13# You should have received a copy of the GNU General Public License
14# along with this program; if not, write to the Free Software
15# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
16
17# Please email any bugs, comments, and/or additions to this file to:
18# DejaGnu@cygnus.com
19
20# Written by Cygnus Support.
21
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 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
61proc 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
101proc 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
140proc 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
171proc 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
207proc 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
237proc 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
277proc 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
313proc 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
350proc 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 86\[^\n\]*\n" { set x [expr $x+1] }
362 -re "^ +\[0-9\]+ 0001 F1E6\[^\n\]*\n" { set x [expr $x+1] }
363 -re "^ +\[0-9\]+ 0003 F1D9\[^\n\]*\n" { set x [expr $x+1] }
364 -re "^ +\[0-9\]+ 0005 99\[^\n\]*\n" { set x [expr $x+1] }
365 -re "^ +\[0-9\]+ 0006 3E\[^\n\]*\n" { set x [expr $x+1] }
366 -re "^ +\[0-9\]+ 0007 F2F4\[^\n\]*\n" { set x [expr $x+1] }
367 -re "^ +\[0-9\]+ 0009 F2FB\[^\n\]*\n" { set x [expr $x+1] }
368 -re "^ +\[0-9\]+ 000b F2E1\[^\n\]*\n" { set x [expr $x+1] }
369 -re "^ +\[0-9\]+ 000d F2FA\[^\n\]*\n" { set x [expr $x+1] }
370 -re "^ +\[0-9\]+ 000f 76\[^\n\]*\n" { set x [expr $x+1] }
371 -re "^ +\[0-9\]+ 0010 F80608\[^\n\]*\n" { set x [expr $x+1] }
372 -re "^ +\[0-9\]+ 0013 FA060100\[^\n\]*\n" { set x [expr $x+1] }
373 -re "^ +\[0-9\]+ 0017 FC060001\[^\n\]*\n" { set x [expr $x+1] }
374 -re "^ +14 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
375 -re "^ +\[0-9\]+ 001d 5908\[^\n\]*\n" { set x [expr $x+1] }
376 -re "^ +\[0-9\]+ 001f FAB50100\[^\n\]*\n" { set x [expr $x+1] }
377 -re "^ +\[0-9\]+ 0023 F2E7\[^\n\]*\n" { set x [expr $x+1] }
378 -re "\[^\n\]*\n" { }
379 timeout { perror "timeout\n"; break }
380 eof { break }
381 }
382 }
383
384 # This was intended to do any cleanup necessary. It kinda looks like it
385 # isn't needed, but just in case, please keep it in for now.
386 gas_finish
387
388 # Did we find what we were looking for? If not, flunk it.
389 if [expr $x==17] then { pass $testname } else { fail $testname }
390}
391
392proc do_mov2 {} {
393 set testname "mov2.s: mov2 tests"
394 set x 0
395
396 gas_start "mov2.s" "-al"
397
398 # Instead of having a variable for each match string just increment the
399 # total number of matches seen. That's simpler when testing large numbers
400 # of instructions (as these tests to).
401 while 1 {
402 expect {
403 -re "^ +\[0-9\]+ 0000 FCB50001\[^\n\]*\n" { set x [expr $x+1] }
404 -re "^ +2 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
405 -re "^ +\[0-9\]+ 0006 F325\[^\n\]*\n" { set x [expr $x+1] }
406 -re "^ +\[0-9\]+ 0008 318000\[^\n\]*\n" { set x [expr $x+1] }
407 -re "^ +\[0-9\]+ 000b FCA50001\[^\n\]*\n" { set x [expr $x+1] }
408 -re "^ +5 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
409 -re "^ +\[0-9\]+ 0011 F006\[^\n\]*\n" { set x [expr $x+1] }
410 -re "^ +\[0-9\]+ 0013 F82608\[^\n\]*\n" { set x [expr $x+1] }
411 -re "^ +\[0-9\]+ 0016 FA260100 \[^\n\]*\n" { set x [expr $x+1] }
412 -re "^ +\[0-9\]+ 001a FC260001\[^\n\]*\n" { set x [expr $x+1] }
413 -re "^ +9 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
414 -re "^ +\[0-9\]+ 0020 5D08\[^\n\]*\n" { set x [expr $x+1] }
415 -re "^ +\[0-9\]+ 0022 FAB10100\[^\n\]*\n" { set x [expr $x+1] }
416 -re "^ +\[0-9\]+ 0026 FCB10001\[^\n\]*\n" { set x [expr $x+1] }
417 -re "^ +12 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
418 -re "^ +\[0-9\]+ 002c F3A5\[^\n\]*\n" { set x [expr $x+1] }
419 -re "^ +\[0-9\]+ 002e FAA18000\[^\n\]*\n" { set x [expr $x+1] }
420 -re "^ +\[0-9\]+ 0032 FCA10001\[^\n\]*\n" { set x [expr $x+1] }
421 -re "^ +15 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
422 -re "^ +\[0-9\]+ 0038 F8F120\[^\n\]*\n" { set x [expr $x+1] }
423 -re "\[^\n\]*\n" { }
424 timeout { perror "timeout\n"; break }
425 eof { break }
426 }
427 }
428
429 # This was intended to do any cleanup necessary. It kinda looks like it
430 # isn't needed, but just in case, please keep it in for now.
431 gas_finish
432
433 # Did we find what we were looking for? If not, flunk it.
434 if [expr $x==20] then { pass $testname } else { fail $testname }
435}
436
437proc do_mov3 {} {
438 set testname "mov3.s: mov3 tests"
439 set x 0
440
441 gas_start "mov3.s" "-al"
442
443 # Instead of having a variable for each match string just increment the
444 # total number of matches seen. That's simpler when testing large numbers
445 # of instructions (as these tests to).
446 while 1 {
447 expect {
448 -re "^ +\[0-9\]+ 0000 66\[^\n\]*\n" { set x [expr $x+1] }
449 -re "^ +\[0-9\]+ 0001 F81620\[^\n\]*\n" { set x [expr $x+1] }
450 -re "^ +\[0-9\]+ 0004 FA160100\[^\n\]*\n" { set x [expr $x+1] }
451 -re "^ +\[0-9\]+ 0008 FC160001\[^\n\]*\n" { set x [expr $x+1] }
452 -re "^ +5 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
453 -re "^ +\[0-9\]+ 000e 4620\[^\n\]*\n" { set x [expr $x+1] }
454 -re "^ +\[0-9\]+ 0010 FA958000\[^\n\]*\n" { set x [expr $x+1] }
455 -re "^ +\[0-9\]+ 0014 FC950001\[^\n\]*\n" { set x [expr $x+1] }
456 -re "^ +8 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
457 -re "^ +\[0-9\]+ 001a F35A\[^\n\]*\n" { set x [expr $x+1] }
458 -re "^ +\[0-9\]+ 001c 050080\[^\n\]*\n" { set x [expr $x+1] }
459 -re "^ +\[0-9\]+ 001f FC850001\[^\n\]*\n" { set x [expr $x+1] }
460 -re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
461 -re "^ +\[0-9\]+ 0025 F016\[^\n\]*\n" { set x [expr $x+1] }
462 -re "^ +\[0-9\]+ 0027 F83620\[^\n\]*\n" { set x [expr $x+1] }
463 -re "^ +\[0-9\]+ 002a FA360100\[^\n\]*\n" { set x [expr $x+1] }
464 -re "^ +\[0-9\]+ 002e FC360001\[^\n\]*\n" { set x [expr $x+1] }
465 -re "^ +15 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
466 -re "^ +\[0-9\]+ 0034 4720\[^\n\]*\n" { set x [expr $x+1] }
467 -re "\[^\n\]*\n" { }
468 timeout { perror "timeout\n"; break }
469 eof { break }
470 }
471 }
472
473 # This was intended to do any cleanup necessary. It kinda looks like it
474 # isn't needed, but just in case, please keep it in for now.
475 gas_finish
476
477 # Did we find what we were looking for? If not, flunk it.
478 if [expr $x==19] then { pass $testname } else { fail $testname }
479}
480
481proc do_mov4 {} {
482 set testname "mov4.s: mov4 tests"
483 set x 0
484
485 gas_start "mov4.s" "-al"
486
487 # Instead of having a variable for each match string just increment the
488 # total number of matches seen. That's simpler when testing large numbers
489 # of instructions (as these tests to).
490 while 1 {
491 expect {
492 -re "^ +\[0-9\]+ 0000 FA948000\[^\n\]*\n" { set x [expr $x+1] }
493 -re "^ +\[0-9\]+ 0004 FC940001\[^\n\]*\n" { set x [expr $x+1] }
494 -re "^ +3 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
495 -re "^ +\[0-9\]+ 000a F3DA\[^\n\]*\n" { set x [expr $x+1] }
496 -re "^ +\[0-9\]+ 000c FA840080\[^\n\]*\n" { set x [expr $x+1] }
497 -re "^ +\[0-9\]+ 0010 FC840001\[^\n\]*\n" { set x [expr $x+1] }
498 -re "^ +6 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
499 -re "^ +\[0-9\]+ 0016 F8F520\[^\n\]*\n" { set x [expr $x+1] }
500 -re "^ +\[0-9\]+ 0019 8508\[^\n\]*\n" { set x [expr $x+1] }
501 -re "^ +\[0-9\]+ 001b 2D0100\[^\n\]*\n" { set x [expr $x+1] }
502 -re "^ +\[0-9\]+ 001e FCCD0001\[^\n\]*\n" { set x [expr $x+1] }
503 -re "^ +10 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
504 -re "^ +\[0-9\]+ 0024 9508\[^\n\]*\n" { set x [expr $x+1] }
505 -re "^ +\[0-9\]+ 0026 250100\[^\n\]*\n" { set x [expr $x+1] }
506 -re "^ +\[0-9\]+ 0029 FCDD0001\[^\n\]*\n" { set x [expr $x+1] }
507 -re "^ +13 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
508 -re "\[^\n\]*\n" { }
509 timeout { perror "timeout\n"; break }
510 eof { break }
511 }
512 }
513
514 # This was intended to do any cleanup necessary. It kinda looks like it
515 # isn't needed, but just in case, please keep it in for now.
516 gas_finish
517
518 # Did we find what we were looking for? If not, flunk it.
519 if [expr $x==16] then { pass $testname } else { fail $testname }
520}
521
522proc do_movbu {} {
523 set testname "movbu.s: movbu tests"
524 set x 0
525
526 gas_start "movbu.s" "-al"
527
528 # Instead of having a variable for each match string just increment the
529 # total number of matches seen. That's simpler when testing large numbers
530 # of instructions (as these tests to).
531 while 1 {
532 expect {
533 -re "^ +\[0-9\]+ 0000 F046\[^\n\]*\n" { set x [expr $x+1] }
534 -re "^ +\[0-9\]+ 0002 F84608\[^\n\]*\n" { set x [expr $x+1] }
535 -re "^ +\[0-9\]+ 0005 FA460100\[^\n\]*\n" { set x [expr $x+1] }
536 -re "^ +\[0-9\]+ 0009 FC460001\[^\n\]*\n" { set x [expr $x+1] }
537 -re "^ +5 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
538 -re "^ +\[0-9\]+ 000f F8B908\[^\n\]*\n" { set x [expr $x+1] }
539 -re "^ +\[0-9\]+ 0012 FAB90100\[^\n\]*\n" { set x [expr $x+1] }
540 -re "^ +\[0-9\]+ 0016 FCB90001\[^\n\]*\n" { set x [expr $x+1] }
541 -re "^ +8 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
542 -re "^ +\[0-9\]+ 001c F425\[^\n\]*\n" { set x [expr $x+1] }
543 -re "^ +\[0-9\]+ 001e 358000\[^\n\]*\n" { set x [expr $x+1] }
544 -re "^ +\[0-9\]+ 0021 FCA90001\[^\n\]*\n" { set x [expr $x+1] }
545 -re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
546 -re "^ +\[0-9\]+ 0027 F056\[^\n\]*\n" { set x [expr $x+1] }
547 -re "^ +\[0-9\]+ 0029 F85620\[^\n\]*\n" { set x [expr $x+1] }
548 -re "^ +\[0-9\]+ 002c FA560100\[^\n\]*\n" { set x [expr $x+1] }
549 -re "^ +\[0-9\]+ 0030 FC560001\[^\n\]*\n" { set x [expr $x+1] }
550 -re "^ +15 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
551 -re "^ +\[0-9\]+ 0036 F89620\[^\n\]*\n" { set x [expr $x+1] }
552 -re "^ +\[0-9\]+ 0039 FA968000\[^\n\]*\n" { set x [expr $x+1] }
553 -re "^ +\[0-9\]+ 003d FC960001\[^\n\]*\n" { set x [expr $x+1] }
554 -re "^ +18 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
555 -re "^ +\[0-9\]+ 0043 F45A\[^\n\]*\n" { set x [expr $x+1] }
556 -re "^ +\[0-9\]+ 0045 060080\[^\n\]*\n" { set x [expr $x+1] }
557 -re "^ +\[0-9\]+ 0048 FC860001\[^\n\]*\n" { set x [expr $x+1] }
558 -re "^ +21 +FFFF\[^\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==26] then { pass $testname } else { fail $testname }
571}
572
573proc do_movhu {} {
574 set testname "movhu.s: movhu tests"
575 set x 0
576
577 gas_start "movhu.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 F066\[^\n\]*\n" { set x [expr $x+1] }
585 -re "^ +\[0-9\]+ 0002 F86608\[^\n\]*\n" { set x [expr $x+1] }
586 -re "^ +\[0-9\]+ 0005 FA660100\[^\n\]*\n" { set x [expr $x+1] }
587 -re "^ +\[0-9\]+ 0009 FC660001\[^\n\]*\n" { set x [expr $x+1] }
588 -re "^ +5 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
589 -re "^ +\[0-9\]+ 000f F8BD08\[^\n\]*\n" { set x [expr $x+1] }
590 -re "^ +\[0-9\]+ 0012 FABD0100\[^\n\]*\n" { set x [expr $x+1] }
591 -re "^ +\[0-9\]+ 0016 FCBD0001\[^\n\]*\n" { set x [expr $x+1] }
592 -re "^ +8 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
593 -re "^ +\[0-9\]+ 001c F4A5\[^\n\]*\n" { set x [expr $x+1] }
594 -re "^ +\[0-9\]+ 001e 398000\[^\n\]*\n" { set x [expr $x+1] }
595 -re "^ +\[0-9\]+ 0021 FCAD0001\[^\n\]*\n" { set x [expr $x+1] }
596 -re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
597 -re "^ +\[0-9\]+ 0027 F076\[^\n\]*\n" { set x [expr $x+1] }
598 -re "^ +\[0-9\]+ 0029 F87620\[^\n\]*\n" { set x [expr $x+1] }
599 -re "^ +\[0-9\]+ 002c FA760100\[^\n\]*\n" { set x [expr $x+1] }
600 -re "^ +\[0-9\]+ 0030 FC760001\[^\n\]*\n" { set x [expr $x+1] }
601 -re "^ +15 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
602 -re "^ +\[0-9\]+ 0036 F89720\[^\n\]*\n" { set x [expr $x+1] }
603 -re "^ +\[0-9\]+ 0039 FA978000\[^\n\]*\n" { set x [expr $x+1] }
604 -re "^ +\[0-9\]+ 003d FC970001\[^\n\]*\n" { set x [expr $x+1] }
605 -re "^ +18 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
606 -re "^ +\[0-9\]+ 0043 F4DA\[^\n\]*\n" { set x [expr $x+1] }
607 -re "^ +\[0-9\]+ 0045 070080\[^\n\]*\n" { set x [expr $x+1] }
608 -re "^ +\[0-9\]+ 0048 FC870001\[^\n\]*\n" { set x [expr $x+1] }
609 -re "^ +21 +FFFF\[^\n\]*\n" { set x [expr $x+1] }
610 -re "\[^\n\]*\n" { }
611 timeout { perror "timeout\n"; break }
612 eof { break }
613 }
614 }
615
616 # This was intended to do any cleanup necessary. It kinda looks like it
617 # isn't needed, but just in case, please keep it in for now.
618 gas_finish
619
620 # Did we find what we were looking for? If not, flunk it.
621 if [expr $x==26] then { pass $testname } else { fail $testname }
622}
623
624proc do_movm {} {
625 set testname "movm.s: movm tests"
626 set x 0
627
628 gas_start "movm.s" "-al"
629
630 # Instead of having a variable for each match string just increment the
631 # total number of matches seen. That's simpler when testing large numbers
632 # of instructions (as these tests to).
633 while 1 {
634 expect {
635 -re "^ +\[0-9\]+ 0000 CE30\[^\n\]*\n" { set x [expr $x+1] }
636 -re "^ +\[0-9\]+ 0002 CEF8\[^\n\]*\n" { set x [expr $x+1] }
637 -re "^ +\[0-9\]+ 0004 CF30\[^\n\]*\n" { set x [expr $x+1] }
638 -re "^ +\[0-9\]+ 0006 CFF8\[^\n\]*\n" { set x [expr $x+1] }
639 -re "\[^\n\]*\n" { }
640 timeout { perror "timeout\n"; break }
641 eof { break }
642 }
643 }
644
645 # This was intended to do any cleanup necessary. It kinda looks like it
646 # isn't needed, but just in case, please keep it in for now.
647 gas_finish
648
649 # Did we find what we were looking for? If not, flunk it.
650 if [expr $x==4] then { pass $testname } else { fail $testname }
651}
652
653proc do_muldiv {} {
654 set testname "muldiv.s: muldiv tests"
655 set x 0
656
657 gas_start "muldiv.s" "-al"
658
659 # Instead of having a variable for each match string just increment the
660 # total number of matches seen. That's simpler when testing large numbers
661 # of instructions (as these tests to).
662 while 1 {
663 expect {
664 -re "^ +\[0-9\]+ 0000 F346\[^\n\]*\n" { set x [expr $x+1] }
665 -re "^ +\[0-9\]+ 0002 F35B\[^\n\]*\n" { set x [expr $x+1] }
666 -re "^ +\[0-9\]+ 0004 F36E\[^\n\]*\n" { set x [expr $x+1] }
667 -re "\[^\n\]*\n" { }
668 timeout { perror "timeout\n"; break }
669 eof { break }
670 }
671 }
672
673 # This was intended to do any cleanup necessary. It kinda looks like it
674 # isn't needed, but just in case, please keep it in for now.
675 gas_finish
676
677 # Did we find what we were looking for? If not, flunk it.
678 if [expr $x==3] then { pass $testname } else { fail $testname }
679}
680
681proc do_other {} {
682 set testname "other.s: other tests"
683 set x 0
684
685 gas_start "other.s" "-al"
686
687 # Instead of having a variable for each match string just increment the
688 # total number of matches seen. That's simpler when testing large numbers
689 # of instructions (as these tests to).
690 while 1 {
691 expect {
692 -re "^ +\[0-9\]+ 0000 FC0001\[^\n\]*\n" { set x [expr $x+1] }
693 -re "^ +\[0-9\]+ 0003 F4E0FFFF\[^\n\]*\n" { set x [expr $x+1] }
694 -re "^ +3 +01\[^\n\]*\n" { set x [expr $x+1] }
695 -re "^ +\[0-9\]+ 0008 F008\[^\n\]*\n" { set x [expr $x+1] }
696 -re "^ +\[0-9\]+ 000a FD0001\[^\n\]*\n" { set x [expr $x+1] }
697 -re "^ +\[0-9\]+ 000d F4E1FFFF\[^\n\]*\n" { set x [expr $x+1] }
698 -re "^ +6 +01\[^\n\]*\n" { set x [expr $x+1] }
699 -re "^ +\[0-9\]+ 0012 F009\[^\n\]*\n" { set x [expr $x+1] }
700 -re "^ +\[0-9\]+ 0014 FE\[^\n\]*\n" { set x [expr $x+1] }
701 -re "^ +\[0-9\]+ 0015 EB\[^\n\]*\n" { set x [expr $x+1] }
702 -re "^ +\[0-9\]+ 0016 F6\[^\n\]*\n" { set x [expr $x+1] }
703 -re "\[^\n\]*\n" { }
704 timeout { perror "timeout\n"; break }
705 eof { break }
706 }
707 }
708
709 # This was intended to do any cleanup necessary. It kinda looks like it
710 # isn't needed, but just in case, please keep it in for now.
711 gas_finish
712
713 # Did we find what we were looking for? If not, flunk it.
714 if [expr $x==11] then { pass $testname } else { fail $testname }
715}
716
717proc do_shift {} {
718 set testname "shift.s: shift tests"
719 set x 0
720
721 gas_start "shift.s" "-al"
722
723 # Instead of having a variable for each match string just increment the
724 # total number of matches seen. That's simpler when testing large numbers
725 # of instructions (as these tests to).
726 while 1 {
727 expect {
728 -re "^ +\[0-9\]+ 0000 F33A\[^\n\]*\n" { set x [expr $x+1] }
729 -re "^ +\[0-9\]+ 0002 F33F\[^\n\]*\n" { set x [expr $x+1] }
730 -re "^ +\[0-9\]+ 0004 F335\[^\n\]*\n" { set x [expr $x+1] }
731 -re "^ +\[0-9\]+ 0006 F332\[^\n\]*\n" { set x [expr $x+1] }
732 -re "\[^\n\]*\n" { }
733 timeout { perror "timeout\n"; break }
734 eof { break }
735 }
736 }
737
738 # This was intended to do any cleanup necessary. It kinda looks like it
739 # isn't needed, but just in case, please keep it in for now.
740 gas_finish
741
742 # Did we find what we were looking for? If not, flunk it.
743 if [expr $x==4] then { pass $testname } else { fail $testname }
744}
745
746proc do_sub {} {
747 set testname "sub.s: sub tests"
748 set x 0
749
750 gas_start "sub.s" "-al"
751
752 # Instead of having a variable for each match string just increment the
753 # total number of matches seen. That's simpler when testing large numbers
754 # of instructions (as these tests to).
755 while 1 {
756 expect {
757 -re "^ +\[0-9\]+ 0000 A6\[^\n\]*\n" { set x [expr $x+1] }
758 -re "^ +\[0-9\]+ 0001 F21B\[^\n\]*\n" { set x [expr $x+1] }
759 -re "^ +\[0-9\]+ 0003 F2DF\[^\n\]*\n" { set x [expr $x+1] }
760 -re "^ +\[0-9\]+ 0005 F25E\[^\n\]*\n" { set x [expr $x+1] }
761 -re "^ +\[0-9\]+ 0007 F71EFF7F \[^\n\]*\n" { set x [expr $x+1] }
762 -re "^ +\[0-9\]+ 000b F46AFFFF\[^\n\]*\n" { set x [expr $x+1] }
763 -re "^ +7 +01\[^\n\]*\n" { set x [expr $x+1] }
764 -re "^ +\[0-9\]+ 0010 F70EFF7F \[^\n\]*\n" { set x [expr $x+1] }
765 -re "^ +\[0-9\]+ 0014 F46EFFFF\[^\n\]*\n" { set x [expr $x+1] }
766 -re "^ +9 +01\[^\n\]*\n" { set x [expr $x+1] }
767 -re "^ +\[0-9\]+ 0019 F296 \[^\n\]*\n" { set x [expr $x+1] }
768 -re "\[^\n\]*\n" { }
769 timeout { perror "timeout\n"; break }
770 eof { break }
771 }
772 }
773
774 # This was intended to do any cleanup necessary. It kinda looks like it
775 # isn't needed, but just in case, please keep it in for now.
776 gas_finish
777
778 # Did we find what we were looking for? If not, flunk it.
779 if [expr $x==11] then { pass $testname } else { fail $testname }
780}
781
782if [istarget mn10200*-*-*] then {
783 # Test the basic instruction parser.
784 do_add
785 do_bcc
786 do_bccx
787 do_bit
788 do_cmp
789 do_ext
790 do_logical
791# do_mov1
792# do_mov2
793# do_mov3
794# do_mov4
795# do_movbu
796 do_muldiv
797 do_other
798 do_shift
799 do_sub
800}
GDB Binutils - Deliverables
This page took 0.05135 seconds and 4 git commands to generate.