Commit | Line | Data |
---|---|---|
82704155 | 1 | # Copyright (C) 2012-2019 Free Software Foundation, Inc. |
5bf135a7 NC |
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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. | |
16 | ||
d70c5fc7 NC |
17 | # |
18 | # Some xc16x tests | |
19 | # | |
20 | proc do_xc16x_add {} { | |
21 | set testname "add.s: xc16x add word tests" | |
22 | set x 0 | |
23 | ||
24 | gas_start "add.s" "-al" | |
25 | ||
26 | # Check each instruction bit pattern to verify it got | |
27 | # assembled correctly. | |
28 | while 1 { | |
29 | expect { | |
30 | -re " +\[0-9\]+ 0000 0001\[^\n\]*\n" { set x [expr $x+1] } | |
31 | -re " +\[0-9\]+ 0002 0809\[^\n\]*\n" { set x [expr $x+1] } | |
32 | -re " +\[0-9\]+ 0004 080D\[^\n\]*\n" { set x [expr $x+1] } | |
33 | -re " +\[0-9\]+ 0006 0803\[^\n\]*\n" { set x [expr $x+1] } | |
34 | -re " +\[0-9\]+ 0008 06F0D204\[^\n\]*\n" { set x [expr $x+1] } | |
35 | -re " +\[0-9\]+ 000c 02F0EDFF\[^\n\]*\n" { set x [expr $x+1] } | |
36 | -re " +\[0-9\]+ 0010 04F0EDFF\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 37 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
38 | eof { break } |
39 | } | |
40 | } | |
41 | ||
42 | # This was intended to do any cleanup necessary. It kinda looks like it | |
43 | # isn't needed, but just in case, please keep it in for now. | |
44 | gas_finish | |
45 | ||
46 | # Did we find what we were looking for? If not, flunk it. | |
47 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
48 | } | |
49 | ||
50 | proc do_xc16x_addb {} { | |
51 | set testname "addb.s: xc16x add byte tests" | |
52 | set x 0 | |
53 | ||
54 | gas_start "addb.s" "-al" | |
55 | ||
56 | # Check each instruction bit pattern to verify it got | |
57 | # assembled correctly. | |
58 | while 1 { | |
59 | expect { | |
60 | -re " +\[0-9\]+ 0000 0102\[^\n\]*\n" { set x [expr $x+1] } | |
61 | -re " +\[0-9\]+ 0002 0909\[^\n\]*\n" { set x [expr $x+1] } | |
62 | -re " +\[0-9\]+ 0004 090D\[^\n\]*\n" { set x [expr $x+1] } | |
63 | -re " +\[0-9\]+ 0006 0902\[^\n\]*\n" { set x [expr $x+1] } | |
64 | -re " +\[0-9\]+ 0008 07F03300\[^\n\]*\n" { set x [expr $x+1] } | |
65 | -re " +\[0-9\]+ 000c 03F08723\[^\n\]*\n" { set x [expr $x+1] } | |
66 | -re " +\[0-9\]+ 0010 05F08723\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 67 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
68 | eof { break } |
69 | } | |
70 | } | |
71 | ||
72 | # This was intended to do any cleanup necessary. It kinda looks like it | |
73 | # isn't needed, but just in case, please keep it in for now. | |
74 | gas_finish | |
75 | ||
76 | # Did we find what we were looking for? If not, flunk it. | |
77 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
78 | } | |
79 | ||
80 | proc do_xc16x_addc {} { | |
81 | set testname "addc.s: xc16x add with carry tests" | |
82 | set x 0 | |
83 | ||
84 | gas_start "addc.s" "-al" | |
85 | ||
86 | # Check each instruction bit pattern to verify it got | |
87 | # assembled correctly. | |
88 | while 1 { | |
89 | expect { | |
90 | -re " +\[0-9\]+ 0000 1001\[^\n\]*\n" { set x [expr $x+1] } | |
91 | -re " +\[0-9\]+ 0002 1809\[^\n\]*\n" { set x [expr $x+1] } | |
92 | -re " +\[0-9\]+ 0004 180D\[^\n\]*\n" { set x [expr $x+1] } | |
93 | -re " +\[0-9\]+ 0006 16F03400\[^\n\]*\n" { set x [expr $x+1] } | |
94 | -re " +\[0-9\]+ 000a 16F05634\[^\n\]*\n" { set x [expr $x+1] } | |
95 | -re " +\[0-9\]+ 000e 12F08723\[^\n\]*\n" { set x [expr $x+1] } | |
96 | -re " +\[0-9\]+ 0012 14F08723\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 97 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
98 | eof { break } |
99 | } | |
100 | } | |
101 | ||
102 | # This was intended to do any cleanup necessary. It kinda looks like it | |
103 | # isn't needed, but just in case, please keep it in for now. | |
104 | gas_finish | |
105 | ||
106 | # Did we find what we were looking for? If not, flunk it. | |
107 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
108 | } | |
109 | ||
110 | proc do_xc16x_addcb {} { | |
111 | set testname "addcb.s: xc16x add byte with carry tests" | |
112 | set x 0 | |
113 | ||
114 | gas_start "addcb.s" "-al" | |
115 | ||
116 | # Check each instruction bit pattern to verify it got | |
117 | # assembled correctly. | |
118 | while 1 { | |
119 | expect { | |
120 | -re " +\[0-9\]+ 0000 1102\[^\n\]*\n" { set x [expr $x+1] } | |
121 | -re " +\[0-9\]+ 0002 1909\[^\n\]*\n" { set x [expr $x+1] } | |
122 | -re " +\[0-9\]+ 0004 190D\[^\n\]*\n" { set x [expr $x+1] } | |
123 | -re " +\[0-9\]+ 0006 17F00200\[^\n\]*\n" { set x [expr $x+1] } | |
124 | -re " +\[0-9\]+ 000a 17F02300\[^\n\]*\n" { set x [expr $x+1] } | |
125 | -re " +\[0-9\]+ 000e 15F08723\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 126 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
127 | eof { break } |
128 | } | |
129 | } | |
130 | ||
131 | # This was intended to do any cleanup necessary. It kinda looks like it | |
132 | # isn't needed, but just in case, please keep it in for now. | |
133 | gas_finish | |
134 | ||
135 | # Did we find what we were looking for? If not, flunk it. | |
136 | if [expr $x == 6] then { pass $testname } else { fail $testname } | |
137 | } | |
138 | ||
139 | proc do_xc16x_sub {} { | |
140 | set testname "sub.s: xc16x sub tests" | |
141 | set x 0 | |
142 | ||
143 | gas_start "sub.s" "-al" | |
144 | ||
145 | # Check each instruction bit pattern to verify it got | |
146 | # assembled correctly. | |
147 | while 1 { | |
148 | expect { | |
149 | -re " +\[0-9\]+ 0000 2001\[^\n\]*\n" { set x [expr $x+1] } | |
150 | -re " +\[0-9\]+ 0002 2809\[^\n\]*\n" { set x [expr $x+1] } | |
151 | -re " +\[0-9\]+ 0004 280D\[^\n\]*\n" { set x [expr $x+1] } | |
152 | -re " +\[0-9\]+ 0006 2801\[^\n\]*\n" { set x [expr $x+1] } | |
153 | -re " +\[0-9\]+ 0008 26F04376\[^\n\]*\n" { set x [expr $x+1] } | |
154 | -re " +\[0-9\]+ 000c 22F04376\[^\n\]*\n" { set x [expr $x+1] } | |
155 | -re " +\[0-9\]+ 0010 24F04376\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 156 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
157 | eof { break } |
158 | } | |
159 | } | |
160 | ||
161 | # This was intended to do any cleanup necessary. It kinda looks like it | |
162 | # isn't needed, but just in case, please keep it in for now. | |
163 | gas_finish | |
164 | ||
165 | # Did we find what we were looking for? If not, flunk it. | |
166 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
167 | } | |
168 | ||
169 | proc do_xc16x_subb {} { | |
170 | set testname "subb.s: xc16x sub byte tests" | |
171 | set x 0 | |
172 | ||
173 | gas_start "subb.s" "-al" | |
174 | ||
175 | # Check each instruction bit pattern to verify it got | |
176 | # assembled correctly. | |
177 | while 1 { | |
178 | expect { | |
179 | -re " +\[0-9\]+ 0000 2102\[^\n\]*\n" { set x [expr $x+1] } | |
180 | -re " +\[0-9\]+ 0002 2909\[^\n\]*\n" { set x [expr $x+1] } | |
181 | -re " +\[0-9\]+ 0004 290D\[^\n\]*\n" { set x [expr $x+1] } | |
182 | -re " +\[0-9\]+ 0006 2901\[^\n\]*\n" { set x [expr $x+1] } | |
183 | -re " +\[0-9\]+ 0008 27F04300\[^\n\]*\n" { set x [expr $x+1] } | |
184 | -re " +\[0-9\]+ 000c 23F04376\[^\n\]*\n" { set x [expr $x+1] } | |
185 | -re " +\[0-9\]+ 0010 25F04376\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 186 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
187 | eof { break } |
188 | } | |
189 | } | |
190 | ||
191 | # This was intended to do any cleanup necessary. It kinda looks like it | |
192 | # isn't needed, but just in case, please keep it in for now. | |
193 | gas_finish | |
194 | ||
195 | # Did we find what we were looking for? If not, flunk it. | |
196 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
197 | } | |
198 | ||
199 | proc do_xc16x_subc {} { | |
200 | set testname "subc.s: xc16x sub with carry tests" | |
201 | set x 0 | |
202 | ||
203 | gas_start "subc.s" "-al" | |
204 | ||
205 | # Check each instruction bit pattern to verify it got | |
206 | # assembled correctly. | |
207 | while 1 { | |
208 | expect { | |
209 | -re " +\[0-9\]+ 0000 3001\[^\n\]*\n" { set x [expr $x+1] } | |
210 | -re " +\[0-9\]+ 0002 3809\[^\n\]*\n" { set x [expr $x+1] } | |
211 | -re " +\[0-9\]+ 0004 380D\[^\n\]*\n" { set x [expr $x+1] } | |
212 | -re " +\[0-9\]+ 0006 3802\[^\n\]*\n" { set x [expr $x+1] } | |
213 | -re " +\[0-9\]+ 0008 36F04300\[^\n\]*\n" { set x [expr $x+1] } | |
214 | -re " +\[0-9\]+ 000c 32F04376\[^\n\]*\n" { set x [expr $x+1] } | |
215 | -re " +\[0-9\]+ 0010 34F04376\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 216 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
217 | eof { break } |
218 | } | |
219 | } | |
220 | ||
221 | # This was intended to do any cleanup necessary. It kinda looks like it | |
222 | # isn't needed, but just in case, please keep it in for now. | |
223 | gas_finish | |
224 | ||
225 | # Did we find what we were looking for? If not, flunk it. | |
226 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
227 | } | |
228 | ||
229 | proc do_xc16x_subcb {} { | |
230 | set testname "subcb.s: xc16x sub byte with carry tests" | |
231 | set x 0 | |
232 | ||
233 | gas_start "subcb.s" "-al" | |
234 | ||
235 | # Check each instruction bit pattern to verify it got | |
236 | # assembled correctly. | |
237 | while 1 { | |
238 | expect { | |
239 | -re " +\[0-9\]+ 0000 3102\[^\n\]*\n" { set x [expr $x+1] } | |
240 | -re " +\[0-9\]+ 0002 3909\[^\n\]*\n" { set x [expr $x+1] } | |
241 | -re " +\[0-9\]+ 0004 390D\[^\n\]*\n" { set x [expr $x+1] } | |
242 | -re " +\[0-9\]+ 0006 3902\[^\n\]*\n" { set x [expr $x+1] } | |
243 | -re " +\[0-9\]+ 0008 37F04300\[^\n\]*\n" { set x [expr $x+1] } | |
244 | -re " +\[0-9\]+ 000c 33F04376\[^\n\]*\n" { set x [expr $x+1] } | |
245 | -re " +\[0-9\]+ 0010 35F04376\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 246 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
247 | eof { break } |
248 | } | |
249 | } | |
250 | ||
251 | # This was intended to do any cleanup necessary. It kinda looks like it | |
252 | # isn't needed, but just in case, please keep it in for now. | |
253 | gas_finish | |
254 | ||
255 | # Did we find what we were looking for? If not, flunk it. | |
256 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
257 | } | |
258 | ||
259 | proc do_xc16x_and {} { | |
260 | set testname "and.s: xc16x and tests" | |
261 | set x 0 | |
262 | ||
263 | gas_start "and.s" "-al" | |
264 | ||
265 | # Check each instruction bit pattern to verify it got | |
266 | # assembled correctly. | |
267 | while 1 { | |
268 | expect { | |
269 | -re " +\[0-9\]+ 0000 6001\[^\n\]*\n" { set x [expr $x+1] } | |
270 | -re " +\[0-9\]+ 0002 6809\[^\n\]*\n" { set x [expr $x+1] } | |
271 | -re " +\[0-9\]+ 0004 680D\[^\n\]*\n" { set x [expr $x+1] } | |
272 | -re " +\[0-9\]+ 0006 6803\[^\n\]*\n" { set x [expr $x+1] } | |
273 | -re " +\[0-9\]+ 0008 66F0BEFC\[^\n\]*\n" { set x [expr $x+1] } | |
274 | -re " +\[0-9\]+ 000c 62F03002\[^\n\]*\n" { set x [expr $x+1] } | |
275 | -re " +\[0-9\]+ 0010 64F02003\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 276 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
277 | eof { break } |
278 | } | |
279 | } | |
280 | ||
281 | # This was intended to do any cleanup necessary. It kinda looks like it | |
282 | # isn't needed, but just in case, please keep it in for now. | |
283 | gas_finish | |
284 | ||
285 | # Did we find what we were looking for? If not, flunk it. | |
286 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
287 | } | |
288 | ||
289 | proc do_xc16x_andb {} { | |
290 | set testname "andb.s: xc16x and byte tests" | |
291 | set x 0 | |
292 | ||
293 | gas_start "andb.s" "-al" | |
294 | ||
295 | # Check each instruction bit pattern to verify it got | |
296 | # assembled correctly. | |
297 | while 1 { | |
298 | expect { | |
299 | -re " +\[0-9\]+ 0000 6102\[^\n\]*\n" { set x [expr $x+1] } | |
300 | -re " +\[0-9\]+ 0002 6909\[^\n\]*\n" { set x [expr $x+1] } | |
301 | -re " +\[0-9\]+ 0004 690D\[^\n\]*\n" { set x [expr $x+1] } | |
302 | -re " +\[0-9\]+ 0006 6903\[^\n\]*\n" { set x [expr $x+1] } | |
303 | -re " +\[0-9\]+ 0008 67F0BE00\[^\n\]*\n" { set x [expr $x+1] } | |
304 | -re " +\[0-9\]+ 000c 63F03002\[^\n\]*\n" { set x [expr $x+1] } | |
305 | -re " +\[0-9\]+ 0010 65F02003\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 306 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
307 | eof { break } |
308 | } | |
309 | } | |
310 | ||
311 | # This was intended to do any cleanup necessary. It kinda looks like it | |
312 | # isn't needed, but just in case, please keep it in for now. | |
313 | gas_finish | |
314 | ||
315 | # Did we find what we were looking for? If not, flunk it. | |
316 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
317 | } | |
318 | ||
319 | proc do_xc16x_or {} { | |
320 | set testname "or.s: xc16x or tests" | |
321 | set x 0 | |
322 | ||
323 | gas_start "or.s" "-al" | |
324 | ||
325 | # Check each instruction bit pattern to verify it got | |
326 | # assembled correctly. | |
327 | while 1 { | |
328 | expect { | |
329 | -re " +\[0-9\]+ 0000 7001\[^\n\]*\n" { set x [expr $x+1] } | |
330 | -re " +\[0-9\]+ 0002 7809\[^\n\]*\n" { set x [expr $x+1] } | |
331 | -re " +\[0-9\]+ 0004 780D\[^\n\]*\n" { set x [expr $x+1] } | |
332 | -re " +\[0-9\]+ 0006 7803\[^\n\]*\n" { set x [expr $x+1] } | |
333 | -re " +\[0-9\]+ 0008 76F03402\[^\n\]*\n" { set x [expr $x+1] } | |
334 | -re " +\[0-9\]+ 000c 72F03645\[^\n\]*\n" { set x [expr $x+1] } | |
335 | -re " +\[0-9\]+ 0010 74F03645\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 336 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
337 | eof { break } |
338 | } | |
339 | } | |
340 | ||
341 | # This was intended to do any cleanup necessary. It kinda looks like it | |
342 | # isn't needed, but just in case, please keep it in for now. | |
343 | gas_finish | |
344 | ||
345 | # Did we find what we were looking for? If not, flunk it. | |
346 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
347 | } | |
348 | ||
349 | proc do_xc16x_xor {} { | |
350 | set testname "xor.s: xc16x xor tests" | |
351 | set x 0 | |
352 | ||
353 | gas_start "xor.s" "-al" | |
354 | ||
355 | # Check each instruction bit pattern to verify it got | |
356 | # assembled correctly. | |
357 | while 1 { | |
358 | expect { | |
359 | -re " +\[0-9\]+ 0000 5001\[^\n\]*\n" { set x [expr $x+1] } | |
360 | -re " +\[0-9\]+ 0002 5809\[^\n\]*\n" { set x [expr $x+1] } | |
361 | -re " +\[0-9\]+ 0004 580D\[^\n\]*\n" { set x [expr $x+1] } | |
362 | -re " +\[0-9\]+ 0006 5803\[^\n\]*\n" { set x [expr $x+1] } | |
363 | -re " +\[0-9\]+ 0008 56F03402\[^\n\]*\n" { set x [expr $x+1] } | |
364 | -re " +\[0-9\]+ 000c 52F03402\[^\n\]*\n" { set x [expr $x+1] } | |
365 | -re " +\[0-9\]+ 0010 54F03402\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 366 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
367 | eof { break } |
368 | } | |
369 | } | |
370 | ||
371 | # This was intended to do any cleanup necessary. It kinda looks like it | |
372 | # isn't needed, but just in case, please keep it in for now. | |
373 | gas_finish | |
374 | ||
375 | # Did we find what we were looking for? If not, flunk it. | |
376 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
377 | } | |
378 | ||
379 | proc do_xc16x_xorb {} { | |
380 | set testname "xorb.s: xc16x xorb tests" | |
381 | set x 0 | |
382 | ||
383 | gas_start "xorb.s" "-al" | |
384 | ||
385 | # Check each instruction bit pattern to verify it got | |
386 | # assembled correctly. | |
387 | while 1 { | |
388 | expect { | |
389 | -re " +\[0-9\]+ 0000 5102\[^\n\]*\n" { set x [expr $x+1] } | |
390 | -re " +\[0-9\]+ 0002 5909\[^\n\]*\n" { set x [expr $x+1] } | |
391 | -re " +\[0-9\]+ 0004 590D\[^\n\]*\n" { set x [expr $x+1] } | |
392 | -re " +\[0-9\]+ 0006 5903\[^\n\]*\n" { set x [expr $x+1] } | |
393 | -re " +\[0-9\]+ 0008 57F03400\[^\n\]*\n" { set x [expr $x+1] } | |
394 | -re " +\[0-9\]+ 000c 53F00324\[^\n\]*\n" { set x [expr $x+1] } | |
395 | -re " +\[0-9\]+ 0010 55F00324\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 396 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
397 | eof { break } |
398 | } | |
399 | } | |
400 | ||
401 | # This was intended to do any cleanup necessary. It kinda looks like it | |
402 | # isn't needed, but just in case, please keep it in for now. | |
403 | gas_finish | |
404 | ||
405 | # Did we find what we were looking for? If not, flunk it. | |
406 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
407 | ||
408 | } | |
409 | ||
410 | proc do_xc16x_mov {} { | |
411 | set testname "mov.s: xc16x mov tests" | |
412 | set x 0 | |
413 | ||
414 | gas_start "mov.s" "-al" | |
415 | ||
416 | # Check each instruction bit pattern to verify it got | |
417 | # assembled correctly. | |
418 | while 1 { | |
419 | expect { | |
420 | -re " +\[0-9\]+ 0000 F001\[^\n\]*\n" { set x [expr $x+1] } | |
421 | -re " +\[0-9\]+ 0002 E6F00200\[^\n\]*\n" { set x [expr $x+1] } | |
422 | -re " +\[0-9\]+ 0006 E6F0BEFC\[^\n\]*\n" { set x [expr $x+1] } | |
423 | -re " +\[0-9\]+ 000a A801\[^\n\]*\n" { set x [expr $x+1] } | |
424 | -re " +\[0-9\]+ 000c 9801\[^\n\]*\n" { set x [expr $x+1] } | |
425 | -re " +\[0-9\]+ 000e B810\[^\n\]*\n" { set x [expr $x+1] } | |
426 | -re " +\[0-9\]+ 0010 8810\[^\n\]*\n" { set x [expr $x+1] } | |
427 | -re " +\[0-9\]+ 0012 C801\[^\n\]*\n" { set x [expr $x+1] } | |
428 | -re " +\[0-9\]+ 0014 D801\[^\n\]*\n" { set x [expr $x+1] } | |
429 | -re " +\[0-9\]+ 0016 E801\[^\n\]*\n" { set x [expr $x+1] } | |
430 | -re " +\[0-9\]+ 0018 D400CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
431 | -re " +\[0-9\]+ 001c C400CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
432 | -re " +\[0-9\]+ 0020 8400CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
433 | -re " +\[0-9\]+ 0024 9400CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
434 | -re " +\[0-9\]+ 0028 F2F0CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
435 | -re " +\[0-9\]+ 002c F6F0CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 436 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
437 | eof { break } |
438 | } | |
439 | } | |
440 | ||
441 | # This was intended to do any cleanup necessary. It kinda looks like it | |
442 | # isn't needed, but just in case, please keep it in for now. | |
443 | gas_finish | |
444 | ||
445 | # Did we find what we were looking for? If not, flunk it. | |
446 | if [expr $x == 16] then { pass $testname } else { fail $testname } | |
447 | } | |
448 | ||
449 | proc do_xc16x_movb {} { | |
450 | set testname "movb.s: xc16x movb tests" | |
451 | set x 0 | |
452 | ||
453 | gas_start "movb.s" "-al" | |
454 | ||
455 | # Check each instruction bit pattern to verify it got | |
456 | # assembled correctly. | |
457 | while 1 { | |
458 | expect { | |
459 | -re " +\[0-9\]+ 0000 F3F00000\[^\n\]*\n" { set x [expr $x+1] } | |
460 | -re " +\[0-9\]+ 0004 E7F01200\[^\n\]*\n" { set x [expr $x+1] } | |
461 | -re " +\[0-9\]+ 0008 B4020000\[^\n\]*\n" { set x [expr $x+1] } | |
462 | -re " +\[0-9\]+ 000c 9902\[^\n\]*\n" { set x [expr $x+1] } | |
463 | -re " +\[0-9\]+ 000e 8902\[^\n\]*\n" { set x [expr $x+1] } | |
464 | -re " +\[0-9\]+ 0010 E932\[^\n\]*\n" { set x [expr $x+1] } | |
465 | -re " +\[0-9\]+ 0012 C932\[^\n\]*\n" { set x [expr $x+1] } | |
466 | -re " +\[0-9\]+ 0014 D923\[^\n\]*\n" { set x [expr $x+1] } | |
467 | -re " +\[0-9\]+ 0016 E923\[^\n\]*\n" { set x [expr $x+1] } | |
468 | -re " +\[0-9\]+ 0018 F4033412\[^\n\]*\n" { set x [expr $x+1] } | |
469 | -re " +\[0-9\]+ 001c E4033412\[^\n\]*\n" { set x [expr $x+1] } | |
470 | -re " +\[0-9\]+ 0020 A4033412\[^\n\]*\n" { set x [expr $x+1] } | |
471 | -re " +\[0-9\]+ 0024 A403FFEE\[^\n\]*\n" { set x [expr $x+1] } | |
472 | -re " +\[0-9\]+ 0028 B4033412\[^\n\]*\n" { set x [expr $x+1] } | |
473 | -re " +\[0-9\]+ 002c F3F01200\[^\n\]*\n" { set x [expr $x+1] } | |
474 | -re " +\[0-9\]+ 0030 F7F01200\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 475 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
476 | eof { break } |
477 | } | |
478 | } | |
479 | ||
480 | # This was intended to do any cleanup necessary. It kinda looks like it | |
481 | # isn't needed, but just in case, please keep it in for now. | |
482 | gas_finish | |
483 | ||
484 | # Did we find what we were looking for? If not, flunk it. | |
485 | if [expr $x == 16] then { pass $testname } else { fail $testname } | |
486 | } | |
487 | ||
488 | proc do_xc16x_movbs {} { | |
489 | set testname "movbs.s: xc16x mov byte tests" | |
490 | set x 0 | |
491 | ||
492 | gas_start "movbs.s" "-al" | |
493 | ||
494 | # Check each instruction bit pattern to verify it got | |
495 | # assembled correctly. | |
496 | while 1 { | |
497 | expect { | |
498 | -re " +\[0-9\]+ 0000 D020\[^\n\]*\n" { set x [expr $x+1] } | |
499 | -re " +\[0-9\]+ 0002 D2F0FF00\[^\n\]*\n" { set x [expr $x+1] } | |
500 | -re " +\[0-9\]+ 0006 D5F0CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 501 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
502 | eof { break } |
503 | } | |
504 | } | |
505 | ||
506 | # This was intended to do any cleanup necessary. It kinda looks like it | |
507 | # isn't needed, but just in case, please keep it in for now. | |
508 | gas_finish | |
509 | ||
510 | # Did we find what we were looking for? If not, flunk it. | |
511 | if [expr $x == 3] then { pass $testname } else { fail $testname } | |
512 | } | |
513 | ||
514 | proc do_xc16x_movbz {} { | |
515 | set testname "movbz.s: xc16x movbz tests" | |
516 | set x 0 | |
517 | ||
518 | gas_start "movbz.s" "-al" | |
519 | ||
520 | # Check each instruction bit pattern to verify it got | |
521 | # assembled correctly. | |
522 | while 1 { | |
523 | expect { | |
524 | -re " +\[0-9\]+ 0000 C002\[^\n\]*\n" { set x [expr $x+1] } | |
525 | -re " +\[0-9\]+ 0002 C2F0DD23\[^\n\]*\n" { set x [expr $x+1] } | |
526 | -re " +\[0-9\]+ 0006 C5F02300\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 527 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
528 | eof { break } |
529 | } | |
530 | } | |
531 | ||
532 | # This was intended to do any cleanup necessary. It kinda looks like it | |
533 | # isn't needed, but just in case, please keep it in for now. | |
534 | gas_finish | |
535 | ||
536 | # Did we find what we were looking for? If not, flunk it. | |
537 | if [expr $x == 3] then { pass $testname } else { fail $testname } | |
538 | } | |
539 | ||
540 | proc do_xc16x_pushpop {} { | |
541 | set testname "pushpop.s: xc16x push/pop tests" | |
542 | set x 0 | |
543 | ||
544 | gas_start "pushpop.s" "-al" | |
545 | ||
546 | # Check each instruction bit pattern to verify it got | |
547 | # assembled correctly. | |
548 | while 1 { | |
549 | expect { | |
550 | -re " +\[0-9\]+ 0000 FCF0\[^\n\]*\n" { set x [expr $x+1] } | |
551 | -re " +\[0-9\]+ 0002 ECF0\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 552 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
553 | eof { break } |
554 | } | |
555 | } | |
556 | ||
557 | # This was intended to do any cleanup necessary. It kinda looks like it | |
558 | # isn't needed, but just in case, please keep it in for now. | |
559 | gas_finish | |
560 | ||
561 | # Did we find what we were looking for? If not, flunk it. | |
562 | if [expr $x == 2] then { pass $testname } else { fail $testname } | |
563 | } | |
564 | ||
565 | proc do_xc16x_shlrol {} { | |
566 | set testname "shlrol.s: xc16x shift and rotate tests" | |
567 | set x 0 | |
568 | ||
569 | gas_start "shlrol.s" "-al" | |
570 | ||
571 | # Check each instruction bit pattern to verify it got | |
572 | # assembled correctly. | |
573 | while 1 { | |
574 | expect { | |
575 | -re " +\[0-9\]+ 0000 4C01\[^\n\]*\n" { set x [expr $x+1] } | |
23f5dfcb | 576 | -re " +\[0-9\]+ 0002 5C40\[^\n\]*\n" { set x [expr $x+1] } |
d70c5fc7 | 577 | -re " +\[0-9\]+ 0004 6C01\[^\n\]*\n" { set x [expr $x+1] } |
23f5dfcb | 578 | -re " +\[0-9\]+ 0006 7C40\[^\n\]*\n" { set x [expr $x+1] } |
d70c5fc7 | 579 | -re " +\[0-9\]+ 0008 0C01\[^\n\]*\n" { set x [expr $x+1] } |
23f5dfcb | 580 | -re " +\[0-9\]+ 000a 1C40\[^\n\]*\n" { set x [expr $x+1] } |
d70c5fc7 | 581 | -re " +\[0-9\]+ 000c 2C01\[^\n\]*\n" { set x [expr $x+1] } |
23f5dfcb | 582 | -re " +\[0-9\]+ 000e 3C40\[^\n\]*\n" { set x [expr $x+1] } |
d70c5fc7 | 583 | -re " +\[0-9\]+ 0010 AC01\[^\n\]*\n" { set x [expr $x+1] } |
23f5dfcb | 584 | -re " +\[0-9\]+ 0012 BC40\[^\n\]*\n" { set x [expr $x+1] } |
e3ea77ac | 585 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
586 | eof { break } |
587 | } | |
588 | } | |
589 | ||
590 | # This was intended to do any cleanup necessary. It kinda looks like it | |
591 | # isn't needed, but just in case, please keep it in for now. | |
592 | gas_finish | |
593 | ||
594 | # Did we find what we were looking for? If not, flunk it. | |
595 | if [expr $x == 10] then { pass $testname } else { fail $testname } | |
596 | } | |
597 | ||
598 | proc do_xc16x_neg {} { | |
599 | set testname "neg.s: xc16x neg tests" | |
600 | set x 0 | |
601 | ||
602 | gas_start "neg.s" "-al" | |
603 | ||
604 | # Check each instruction bit pattern to verify it got | |
605 | # assembled correctly. | |
606 | while 1 { | |
607 | expect { | |
608 | -re " +\[0-9\]+ 0000 8100\[^\n\]*\n" { set x [expr $x+1] } | |
609 | -re " +\[0-9\]+ 0002 A100\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 610 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
611 | eof { break } |
612 | } | |
613 | } | |
614 | ||
615 | # This was intended to do any cleanup necessary. It kinda looks like it | |
616 | # isn't needed, but just in case, please keep it in for now. | |
617 | gas_finish | |
618 | ||
619 | # Did we find what we were looking for? If not, flunk it. | |
620 | if [expr $x == 2] then { pass $testname } else { fail $testname } | |
621 | } | |
622 | proc do_xc16x_mul {} { | |
623 | set testname "mul.s: xc16x multiply tests" | |
624 | set x 0 | |
625 | ||
626 | gas_start "mul.s" "-al" | |
627 | ||
628 | # Check each instruction bit pattern to verify it got | |
629 | # assembled correctly. | |
630 | while 1 { | |
631 | expect { | |
632 | -re " +\[0-9\]+ 0000 0B01\[^\n\]*\n" { set x [expr $x+1] } | |
633 | -re " +\[0-9\]+ 0002 1B01\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 634 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
635 | eof { break } |
636 | } | |
637 | } | |
638 | ||
639 | # This was intended to do any cleanup necessary. It kinda looks like it | |
640 | # isn't needed, but just in case, please keep it in for now. | |
641 | gas_finish | |
642 | ||
643 | # Did we find what we were looking for? If not, flunk it. | |
644 | if [expr $x == 2] then { pass $testname } else { fail $testname } | |
645 | } | |
646 | ||
647 | proc do_xc16x_div {} { | |
648 | set testname "div.s: xc16x division tests" | |
649 | set x 0 | |
650 | ||
651 | gas_start "div.s" "-al" | |
652 | ||
653 | # Check each instruction bit pattern to verify it got | |
654 | # assembled correctly. | |
655 | while 1 { | |
656 | expect { | |
657 | -re " +\[0-9\]+ 0000 4B00\[^\n\]*\n" { set x [expr $x+1] } | |
658 | -re " +\[0-9\]+ 0002 6B00\[^\n\]*\n" { set x [expr $x+1] } | |
659 | -re " +\[0-9\]+ 0004 7B00\[^\n\]*\n" { set x [expr $x+1] } | |
660 | -re " +\[0-9\]+ 0006 5B00\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 661 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
662 | eof { break } |
663 | } | |
664 | } | |
665 | ||
666 | # This was intended to do any cleanup necessary. It kinda looks like it | |
667 | # isn't needed, but just in case, please keep it in for now. | |
668 | gas_finish | |
669 | ||
670 | # Did we find what we were looking for? If not, flunk it. | |
671 | if [expr $x == 4] then { pass $testname } else { fail $testname } | |
672 | } | |
673 | ||
674 | proc do_xc16x_jmpa {} { | |
675 | set testname "jmpa.s: xc16x jump absolute test" | |
676 | set x 0 | |
677 | ||
678 | gas_start "jmpa.s" "-al" | |
679 | ||
680 | # Check each instruction bit pattern to verify it got | |
681 | # assembled correctly. | |
682 | while 1 { | |
683 | expect { | |
684 | -re " +\[0-9\]+ 0000 EA00AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
685 | -re " +\[0-9\]+ 0004 EA20AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
686 | -re " +\[0-9\]+ 0008 EA30AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
687 | -re " +\[0-9\]+ 000c EA40AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
688 | -re " +\[0-9\]+ 0010 EA50AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
689 | -re " +\[0-9\]+ 0014 EA60AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
690 | -re " +\[0-9\]+ 0018 EA70AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
691 | -re " +\[0-9\]+ 001c EA80AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
692 | -re " +\[0-9\]+ 0020 EA90AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
693 | -re " +\[0-9\]+ 0024 EA20AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
694 | -re " +\[0-9\]+ 0028 EA30AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
695 | -re " +\[0-9\]+ 002c EA80AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
696 | -re " +\[0-9\]+ 0030 EAF0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
697 | -re " +\[0-9\]+ 0034 EA90AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
698 | -re " +\[0-9\]+ 0038 EAE0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
699 | -re " +\[0-9\]+ 003c EAB0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
700 | -re " +\[0-9\]+ 0040 EAD0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
701 | -re " +\[0-9\]+ 0044 EAA0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
702 | -re " +\[0-9\]+ 0048 EA10AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 703 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
704 | eof { break } |
705 | } | |
706 | } | |
707 | ||
708 | # This was intended to do any cleanup necessary. It kinda looks like it | |
709 | # isn't needed, but just in case, please keep it in for now. | |
710 | gas_finish | |
711 | ||
712 | # Did we find what we were looking for? If not, flunk it. | |
713 | if [expr $x == 19] then { pass $testname } else { fail $testname } | |
714 | } | |
715 | ||
716 | proc do_xc16x_jmpi {} { | |
717 | set testname "jmpi.s: xc16x jmp immidiate tests " | |
718 | set x 0 | |
719 | ||
720 | gas_start "jmpi.s" "-al" | |
721 | ||
722 | # Check each instruction bit pattern to verify it got | |
723 | # assembled correctly. | |
724 | while 1 { | |
725 | expect { | |
726 | -re " +\[0-9\]+ 0000 9C07\[^\n\]*\n" { set x [expr $x+1] } | |
727 | -re " +\[0-9\]+ 0002 9C27\[^\n\]*\n" { set x [expr $x+1] } | |
728 | -re " +\[0-9\]+ 0004 9C37\[^\n\]*\n" { set x [expr $x+1] } | |
729 | -re " +\[0-9\]+ 0006 9C47\[^\n\]*\n" { set x [expr $x+1] } | |
730 | -re " +\[0-9\]+ 0008 9C57\[^\n\]*\n" { set x [expr $x+1] } | |
731 | -re " +\[0-9\]+ 000a 9C67\[^\n\]*\n" { set x [expr $x+1] } | |
732 | -re " +\[0-9\]+ 000c 9C77\[^\n\]*\n" { set x [expr $x+1] } | |
733 | -re " +\[0-9\]+ 000e 9C87\[^\n\]*\n" { set x [expr $x+1] } | |
734 | -re " +\[0-9\]+ 0010 9C97\[^\n\]*\n" { set x [expr $x+1] } | |
735 | -re " +\[0-9\]+ 0012 9C27\[^\n\]*\n" { set x [expr $x+1] } | |
736 | -re " +\[0-9\]+ 0014 9C37\[^\n\]*\n" { set x [expr $x+1] } | |
737 | -re " +\[0-9\]+ 0016 9C87\[^\n\]*\n" { set x [expr $x+1] } | |
738 | -re " +\[0-9\]+ 0018 9CF7\[^\n\]*\n" { set x [expr $x+1] } | |
739 | -re " +\[0-9\]+ 001a 9C97\[^\n\]*\n" { set x [expr $x+1] } | |
740 | -re " +\[0-9\]+ 001c 9CE7\[^\n\]*\n" { set x [expr $x+1] } | |
741 | -re " +\[0-9\]+ 001e 9CB7\[^\n\]*\n" { set x [expr $x+1] } | |
742 | -re " +\[0-9\]+ 0020 9CD7\[^\n\]*\n" { set x [expr $x+1] } | |
743 | -re " +\[0-9\]+ 0022 9CA7\[^\n\]*\n" { set x [expr $x+1] } | |
744 | -re " +\[0-9\]+ 0024 9C17\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 745 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
746 | eof { break } |
747 | } | |
748 | } | |
749 | ||
750 | # This was intended to do any cleanup necessary. It kinda looks like it | |
751 | # isn't needed, but just in case, please keep it in for now. | |
752 | gas_finish | |
753 | ||
754 | # Did we find what we were looking for? If not, flunk it. | |
755 | if [expr $x == 19] then { pass $testname } else { fail $testname } | |
756 | } | |
757 | ||
758 | ||
759 | proc do_xc16x_jmpr {} { | |
760 | set testname "jmpr.s: xc16x jump relative tests" | |
761 | set x 0 | |
762 | ||
763 | gas_start "jmpr.s" "-al" | |
764 | ||
765 | # Check each instruction bit pattern to verify it got | |
766 | # assembled correctly. | |
767 | while 1 { | |
768 | expect { | |
769 | -re " +\[0-9\]+ 0000 0DFF\[^\n\]*\n" { set x [expr $x+1] } | |
770 | -re " +\[0-9\]+ 0002 2DFE\[^\n\]*\n" { set x [expr $x+1] } | |
771 | -re " +\[0-9\]+ 0004 3DFD\[^\n\]*\n" { set x [expr $x+1] } | |
772 | -re " +\[0-9\]+ 0006 4DFC\[^\n\]*\n" { set x [expr $x+1] } | |
773 | -re " +\[0-9\]+ 0008 5DFB\[^\n\]*\n" { set x [expr $x+1] } | |
774 | -re " +\[0-9\]+ 000a 6DFA\[^\n\]*\n" { set x [expr $x+1] } | |
775 | -re " +\[0-9\]+ 000c 7DF9\[^\n\]*\n" { set x [expr $x+1] } | |
776 | -re " +\[0-9\]+ 000e 8DF8\[^\n\]*\n" { set x [expr $x+1] } | |
777 | -re " +\[0-9\]+ 0010 9DF7\[^\n\]*\n" { set x [expr $x+1] } | |
778 | -re " +\[0-9\]+ 0012 2DF6\[^\n\]*\n" { set x [expr $x+1] } | |
779 | -re " +\[0-9\]+ 0014 3DF5\[^\n\]*\n" { set x [expr $x+1] } | |
780 | -re " +\[0-9\]+ 0016 8DF4\[^\n\]*\n" { set x [expr $x+1] } | |
781 | -re " +\[0-9\]+ 0018 FDF3\[^\n\]*\n" { set x [expr $x+1] } | |
782 | -re " +\[0-9\]+ 001a 9DF2\[^\n\]*\n" { set x [expr $x+1] } | |
783 | -re " +\[0-9\]+ 001c EDF1\[^\n\]*\n" { set x [expr $x+1] } | |
784 | -re " +\[0-9\]+ 001e BDF0\[^\n\]*\n" { set x [expr $x+1] } | |
785 | -re " +\[0-9\]+ 0020 DDEF\[^\n\]*\n" { set x [expr $x+1] } | |
786 | -re " +\[0-9\]+ 0022 ADEE\[^\n\]*\n" { set x [expr $x+1] } | |
787 | -re " +\[0-9\]+ 0024 1DED\[^\n\]*\n" { set x [expr $x+1] } | |
788 | -re " +\[0-9\]+ 0026 CDEC\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 789 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
790 | eof { break } |
791 | } | |
792 | } | |
793 | ||
794 | # This was intended to do any cleanup necessary. It kinda looks like it | |
795 | # isn't needed, but just in case, please keep it in for now. | |
796 | gas_finish | |
797 | ||
798 | # Did we find what we were looking for? If not, flunk it. | |
799 | if [expr $x == 20] then { pass $testname } else { fail $testname } | |
800 | } | |
801 | ||
802 | proc do_xc16x_syscontrol1 {} { | |
803 | set testname "syscontrol1.s: xc16x system control insrutions tests" | |
804 | set x 0 | |
805 | ||
806 | gas_start "syscontrol1.s" "-al" | |
807 | ||
808 | # Check each instruction bit pattern to verify it got | |
809 | # assembled correctly. | |
810 | while 1 { | |
811 | expect { | |
812 | -re " +\[0-9\]+ 0000 B748B7B7\[^\n\]*\n" { set x [expr $x+1] } | |
813 | -re " +\[0-9\]+ 0004 8C00\[^\n\]*\n" { set x [expr $x+1] } | |
814 | -re " +\[0-9\]+ 0006 87788787\[^\n\]*\n" { set x [expr $x+1] } | |
815 | -re " +\[0-9\]+ 000a 97689797\[^\n\]*\n" { set x [expr $x+1] } | |
816 | -re " +\[0-9\]+ 000e A758A7A7\[^\n\]*\n" { set x [expr $x+1] } | |
817 | -re " +\[0-9\]+ 0012 A55AA5A5\[^\n\]*\n" { set x [expr $x+1] } | |
818 | -re " +\[0-9\]+ 0016 857A8585\[^\n\]*\n" { set x [expr $x+1] } | |
819 | -re " +\[0-9\]+ 001a B54AB5B5\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 820 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
821 | eof { break } |
822 | } | |
823 | } | |
824 | ||
825 | # This was intended to do any cleanup necessary. It kinda looks like it | |
826 | # isn't needed, but just in case, please keep it in for now. | |
827 | gas_finish | |
828 | ||
829 | # Did we find what we were looking for? If not, flunk it. | |
830 | if [expr $x == 8] then { pass $testname } else { fail $testname } | |
831 | } | |
832 | ||
833 | proc do_xc16x_syscontrol2 {} { | |
834 | set testname "syscontrol2.s: xc16x syscontrol2 tests" | |
835 | set x 0 | |
836 | ||
837 | gas_start "syscontrol2.s" "-al" | |
838 | ||
839 | # Check each instruction bit pattern to verify it got | |
840 | # assembled correctly. | |
841 | while 1 { | |
842 | expect { | |
843 | -re " +\[0-9\]+ 0000 D1B0\[^\n\]*\n" { set x [expr $x+1] } | |
844 | -re " +\[0-9\]+ 0002 D1A0\[^\n\]*\n" { set x [expr $x+1] } | |
845 | -re " +\[0-9\]+ 0004 D190\[^\n\]*\n" { set x [expr $x+1] } | |
846 | -re " +\[0-9\]+ 0006 D180\[^\n\]*\n" { set x [expr $x+1] } | |
847 | -re " +\[0-9\]+ 0008 D130\[^\n\]*\n" { set x [expr $x+1] } | |
848 | -re " +\[0-9\]+ 000a D120\[^\n\]*\n" { set x [expr $x+1] } | |
849 | -re " +\[0-9\]+ 000c D110\[^\n\]*\n" { set x [expr $x+1] } | |
850 | -re " +\[0-9\]+ 000e D100\[^\n\]*\n" { set x [expr $x+1] } | |
851 | -re " +\[0-9\]+ 0010 DC75\[^\n\]*\n" { set x [expr $x+1] } | |
852 | -re " +\[0-9\]+ 0012 D770FF03\[^\n\]*\n" { set x [expr $x+1] } | |
853 | -re " +\[0-9\]+ 0016 DCF5\[^\n\]*\n" { set x [expr $x+1] } | |
854 | -re " +\[0-9\]+ 0018 D7F0FF03\[^\n\]*\n" { set x [expr $x+1] } | |
855 | -re " +\[0-9\]+ 001c DC35\[^\n\]*\n" { set x [expr $x+1] } | |
856 | -re " +\[0-9\]+ 001e D7300100\[^\n\]*\n" { set x [expr $x+1] } | |
857 | -re " +\[0-9\]+ 0022 DCB5\[^\n\]*\n" { set x [expr $x+1] } | |
858 | -re " +\[0-9\]+ 0024 D7B00100\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 859 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
860 | eof { break } |
861 | } | |
862 | } | |
863 | ||
864 | # This was intended to do any cleanup necessary. It kinda looks like it | |
865 | # isn't needed, but just in case, please keep it in for now. | |
866 | gas_finish | |
867 | ||
868 | # Did we find what we were looking for? If not, flunk it. | |
869 | if [expr $x == 16] then { pass $testname } else { fail $testname } | |
870 | } | |
871 | ||
872 | proc do_xc16x_cpl {} { | |
873 | set testname "cpl.s: xc16x compliment tests" | |
874 | set x 0 | |
875 | ||
876 | gas_start "cpl.s" "-al" | |
877 | ||
878 | # Check each instruction bit pattern to verify it got | |
879 | # assembled correctly. | |
880 | while 1 { | |
881 | expect { | |
882 | -re " +\[0-9\]+ 0000 9100\[^\n\]*\n" { set x [expr $x+1] } | |
883 | -re " +\[0-9\]+ 0002 B100\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 884 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
885 | eof { break } |
886 | } | |
887 | } | |
888 | ||
889 | # This was intended to do any cleanup necessary. It kinda looks like it | |
890 | # isn't needed, but just in case, please keep it in for now. | |
891 | gas_finish | |
892 | ||
893 | # Did we find what we were looking for? If not, flunk it. | |
894 | if [expr $x == 2] then { pass $testname } else { fail $testname } | |
895 | } | |
896 | ||
897 | proc do_xc16x_cmp {} { | |
898 | set testname "cmp.s: xc16x misc tests" | |
899 | set x 0 | |
900 | ||
901 | gas_start "cmp.s" "-al" | |
902 | ||
903 | # Check each instruction bit pattern to verify it got | |
904 | # assembled correctly. | |
905 | while 1 { | |
906 | expect { | |
907 | -re " +\[0-9\]+ 0000 4001\[^\n\]*\n" { set x [expr $x+1] } | |
908 | -re " +\[0-9\]+ 0002 4809\[^\n\]*\n" { set x [expr $x+1] } | |
909 | -re " +\[0-9\]+ 0004 480D\[^\n\]*\n" { set x [expr $x+1] } | |
910 | -re " +\[0-9\]+ 0006 4803\[^\n\]*\n" { set x [expr $x+1] } | |
911 | -re " +\[0-9\]+ 0008 46F03402\[^\n\]*\n" { set x [expr $x+1] } | |
912 | -re " +\[0-9\]+ 000c 42F05234\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 913 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
914 | eof { break } |
915 | } | |
916 | } | |
917 | ||
918 | # This was intended to do any cleanup necessary. It kinda looks like it | |
919 | # isn't needed, but just in case, please keep it in for now. | |
920 | gas_finish | |
921 | ||
922 | # Did we find what we were looking for? If not, flunk it. | |
923 | if [expr $x == 6] then { pass $testname } else { fail $testname } | |
924 | } | |
925 | ||
926 | proc do_xc16x_cmpb {} { | |
927 | set testname "cmpb.s: xc16x cmp byte tests" | |
928 | set x 0 | |
929 | ||
930 | gas_start "cmpb.s" "-al" | |
931 | ||
932 | # Check each instruction bit pattern to verify it got | |
933 | # assembled correctly. | |
934 | while 1 { | |
935 | expect { | |
936 | -re " +\[0-9\]+ 0000 4102\[^\n\]*\n" { set x [expr $x+1] } | |
937 | -re " +\[0-9\]+ 0002 4909\[^\n\]*\n" { set x [expr $x+1] } | |
938 | -re " +\[0-9\]+ 0004 490D\[^\n\]*\n" { set x [expr $x+1] } | |
939 | -re " +\[0-9\]+ 0006 4903\[^\n\]*\n" { set x [expr $x+1] } | |
940 | -re " +\[0-9\]+ 0008 47F02200\[^\n\]*\n" { set x [expr $x+1] } | |
941 | -re " +\[0-9\]+ 000c 43F03402\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 942 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
943 | eof { break } |
944 | } | |
945 | } | |
946 | ||
947 | # This was intended to do any cleanup necessary. It kinda looks like it | |
948 | # isn't needed, but just in case, please keep it in for now. | |
949 | gas_finish | |
950 | ||
951 | # Did we find what we were looking for? If not, flunk it. | |
952 | if [expr $x == 6] then { pass $testname } else { fail $testname } | |
953 | } | |
954 | ||
955 | proc do_xc16x_cmpi {} { | |
956 | set testname "cmpi.s: xc16x cmpi tests" | |
957 | set x 0 | |
958 | ||
959 | gas_start "cmpi.s" "-al" | |
960 | ||
961 | # Check each instruction bit pattern to verify it got | |
962 | # assembled correctly. | |
963 | while 1 { | |
964 | expect { | |
965 | -re " +\[0-9\]+ 0000 A0F0\[^\n\]*\n" { set x [expr $x+1] } | |
966 | -re " +\[0-9\]+ 0002 A6F0CBFC\[^\n\]*\n" { set x [expr $x+1] } | |
967 | -re " +\[0-9\]+ 0006 A2F0CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
968 | -re " +\[0-9\]+ 000a B0F0\[^\n\]*\n" { set x [expr $x+1] } | |
969 | -re " +\[0-9\]+ 000c B6F0CBFC\[^\n\]*\n" { set x [expr $x+1] } | |
970 | -re " +\[0-9\]+ 0010 B2F0CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
971 | -re " +\[0-9\]+ 0014 80F0\[^\n\]*\n" { set x [expr $x+1] } | |
972 | -re " +\[0-9\]+ 0016 86F0CBFC\[^\n\]*\n" { set x [expr $x+1] } | |
973 | -re " +\[0-9\]+ 001a 82F0CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
974 | -re " +\[0-9\]+ 001e 90F0\[^\n\]*\n" { set x [expr $x+1] } | |
975 | -re " +\[0-9\]+ 0020 96F0CBFC\[^\n\]*\n" { set x [expr $x+1] } | |
976 | -re " +\[0-9\]+ 0024 92F0CBFF\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 977 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
978 | eof { break } |
979 | } | |
980 | } | |
981 | ||
982 | # This was intended to do any cleanup necessary. It kinda looks like it | |
983 | # isn't needed, but just in case, please keep it in for now. | |
984 | gas_finish | |
985 | ||
986 | # Did we find what we were looking for? If not, flunk it. | |
987 | if [expr $x == 12] then { pass $testname } else { fail $testname } | |
988 | } | |
989 | ||
990 | proc do_xc16x_calli {} { | |
991 | set testname "calli.s: xc16x call tests" | |
992 | set x 0 | |
993 | ||
994 | gas_start "calli.s" "-al" | |
995 | ||
996 | # Check each instruction bit pattern to verify it got | |
997 | # assembled correctly. | |
998 | while 1 { | |
999 | expect { | |
1000 | -re " +\[0-9\]+ 0000 AB01\[^\n\]*\n" { set x [expr $x+1] } | |
1001 | -re " +\[0-9\]+ 0002 AB21\[^\n\]*\n" { set x [expr $x+1] } | |
1002 | -re " +\[0-9\]+ 0004 AB31\[^\n\]*\n" { set x [expr $x+1] } | |
1003 | -re " +\[0-9\]+ 0006 AB41\[^\n\]*\n" { set x [expr $x+1] } | |
1004 | -re " +\[0-9\]+ 0008 AB51\[^\n\]*\n" { set x [expr $x+1] } | |
1005 | -re " +\[0-9\]+ 000a AB61\[^\n\]*\n" { set x [expr $x+1] } | |
1006 | -re " +\[0-9\]+ 000c AB71\[^\n\]*\n" { set x [expr $x+1] } | |
1007 | -re " +\[0-9\]+ 000e AB81\[^\n\]*\n" { set x [expr $x+1] } | |
1008 | -re " +\[0-9\]+ 0010 AB91\[^\n\]*\n" { set x [expr $x+1] } | |
1009 | -re " +\[0-9\]+ 0012 AB21\[^\n\]*\n" { set x [expr $x+1] } | |
1010 | -re " +\[0-9\]+ 0014 AB31\[^\n\]*\n" { set x [expr $x+1] } | |
1011 | -re " +\[0-9\]+ 0016 AB81\[^\n\]*\n" { set x [expr $x+1] } | |
1012 | -re " +\[0-9\]+ 0018 ABF1\[^\n\]*\n" { set x [expr $x+1] } | |
1013 | -re " +\[0-9\]+ 001a AB91\[^\n\]*\n" { set x [expr $x+1] } | |
1014 | -re " +\[0-9\]+ 001c ABE1\[^\n\]*\n" { set x [expr $x+1] } | |
1015 | -re " +\[0-9\]+ 001e ABB1\[^\n\]*\n" { set x [expr $x+1] } | |
1016 | -re " +\[0-9\]+ 0020 ABD1\[^\n\]*\n" { set x [expr $x+1] } | |
1017 | -re " +\[0-9\]+ 0022 AB11\[^\n\]*\n" { set x [expr $x+1] } | |
1018 | -re " +\[0-9\]+ 0024 ABC1\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 1019 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
1020 | eof { break } |
1021 | } | |
1022 | } | |
1023 | ||
1024 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1025 | # isn't needed, but just in case, please keep it in for now. | |
1026 | gas_finish | |
1027 | ||
1028 | # Did we find what we were looking for? If not, flunk it. | |
1029 | if [expr $x == 19] then { pass $testname } else { fail $testname } | |
1030 | } | |
1031 | ||
1032 | proc do_xc16x_calla {} { | |
1033 | set testname "calla.s: xc16x call tests" | |
1034 | set x 0 | |
1035 | ||
1036 | gas_start "calla.s" "-al" | |
1037 | ||
1038 | # Check each instruction bit pattern to verify it got | |
1039 | # assembled correctly. | |
1040 | while 1 { | |
1041 | expect { | |
1042 | -re " +\[0-9\]+ 0000 CA00AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1043 | -re " +\[0-9\]+ 0004 CA20AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1044 | -re " +\[0-9\]+ 0008 CA30AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1045 | -re " +\[0-9\]+ 000c CA40AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1046 | -re " +\[0-9\]+ 0010 CA50AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1047 | -re " +\[0-9\]+ 0014 CA60AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1048 | -re " +\[0-9\]+ 0018 CA70AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1049 | -re " +\[0-9\]+ 001c CA80AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1050 | -re " +\[0-9\]+ 0020 CA90AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1051 | -re " +\[0-9\]+ 0024 CA20AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1052 | -re " +\[0-9\]+ 0028 CA30AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1053 | -re " +\[0-9\]+ 002c CA80AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1054 | -re " +\[0-9\]+ 0030 CAF0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1055 | -re " +\[0-9\]+ 0034 CA90AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1056 | -re " +\[0-9\]+ 0038 CAE0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1057 | -re " +\[0-9\]+ 003c CAB0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1058 | -re " +\[0-9\]+ 0040 CAD0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1059 | -re " +\[0-9\]+ 0044 CAA0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1060 | -re " +\[0-9\]+ 0048 CA10AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
1061 | -re " +\[0-9\]+ 004c CAC0AAAA\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 1062 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
1063 | eof { break } |
1064 | } | |
1065 | } | |
1066 | ||
1067 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1068 | # isn't needed, but just in case, please keep it in for now. | |
1069 | gas_finish | |
1070 | ||
1071 | # Did we find what we were looking for? If not, flunk it. | |
1072 | if [expr $x == 20] then { pass $testname } else { fail $testname } | |
1073 | } | |
1074 | ||
1075 | ||
1076 | proc do_xc16x_bit {} { | |
1077 | set testname "bit.s: xc16x bit manipulation tests" | |
1078 | set x 0 | |
1079 | ||
1080 | gas_start "bit.s" "-al" | |
1081 | ||
1082 | # Check each instruction bit pattern to verify it got | |
1083 | # assembled correctly. | |
1084 | while 1 { | |
1085 | expect { | |
1086 | -re " +\[0-9\]+ 0000 1EF0\[^\n\]*\n" { set x [expr $x+1] } | |
1087 | -re " +\[0-9\]+ 0002 1FF0\[^\n\]*\n" { set x [expr $x+1] } | |
1088 | -re " +\[0-9\]+ 0004 4AF0F012\[^\n\]*\n" { set x [expr $x+1] } | |
1089 | -re " +\[0-9\]+ 0008 3AF0F023\[^\n\]*\n" { set x [expr $x+1] } | |
1090 | -re " +\[0-9\]+ 000c 6AF0F041\[^\n\]*\n" { set x [expr $x+1] } | |
1091 | -re " +\[0-9\]+ 0010 5AF0F021\[^\n\]*\n" { set x [expr $x+1] } | |
1092 | -re " +\[0-9\]+ 0014 7AF0F021\[^\n\]*\n" { set x [expr $x+1] } | |
1093 | -re " +\[0-9\]+ 0018 2AF0F021\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 1094 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
1095 | eof { break } |
1096 | } | |
1097 | } | |
1098 | ||
1099 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1100 | # isn't needed, but just in case, please keep it in for now. | |
1101 | gas_finish | |
1102 | ||
1103 | # Did we find what we were looking for? If not, flunk it. | |
1104 | if [expr $x == 8] then { pass $testname } else { fail $testname } | |
1105 | } | |
1106 | ||
1107 | proc do_xc16x_bfldl {} { | |
1108 | set testname "bfldl.s: xc16x bitwise modify masked data tests" | |
1109 | set x 0 | |
1110 | ||
1111 | gas_start "bfldl.s" "-al" | |
1112 | ||
1113 | # Check each instruction bit pattern to verify it got | |
1114 | # assembled correctly. | |
1115 | while 1 { | |
1116 | expect { | |
1117 | -re " +\[0-9\]+ 0000 0AF0870E\[^\n\]*\n" { set x [expr $x+1] } | |
1118 | -re " +\[0-9\]+ 0004 1AF00EFF\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 1119 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
1120 | eof { break } |
1121 | } | |
1122 | } | |
1123 | ||
1124 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1125 | # isn't needed, but just in case, please keep it in for now. | |
1126 | gas_finish | |
1127 | ||
1128 | # Did we find what we were looking for? If not, flunk it. | |
1129 | if [expr $x == 2] then { pass $testname } else { fail $testname } | |
1130 | } | |
1131 | ||
1132 | proc do_xc16x_ret {} { | |
1133 | set testname "ret.s: xc16x ret tests" | |
1134 | set x 0 | |
1135 | ||
1136 | gas_start "ret.s" "-al" | |
1137 | ||
1138 | # Check each instruction bit pattern to verify it got | |
1139 | # assembled correctly. | |
1140 | while 1 { | |
1141 | expect { | |
1142 | -re " +\[0-9\]+ 0000 CB00\[^\n\]*\n" { set x [expr $x+1] } | |
1143 | -re " +\[0-9\]+ 0002 FB88\[^\n\]*\n" { set x [expr $x+1] } | |
1144 | -re " +\[0-9\]+ 0004 DB00\[^\n\]*\n" { set x [expr $x+1] } | |
1145 | -re " +\[0-9\]+ 0006 EBF5\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 1146 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
1147 | eof { break } |
1148 | } | |
1149 | } | |
1150 | ||
1151 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1152 | # isn't needed, but just in case, please keep it in for now. | |
1153 | gas_finish | |
1154 | ||
1155 | # Did we find what we were looking for? If not, flunk it. | |
1156 | if [expr $x == 4] then { pass $testname } else { fail $testname } | |
1157 | } | |
1158 | ||
1159 | proc do_xc16x_trap {} { | |
1160 | set testname "trap.s: xc16x add/sub tests" | |
1161 | set x 0 | |
1162 | ||
1163 | gas_start "trap.s" "-al" | |
1164 | ||
1165 | # Check each instruction bit pattern to verify it got | |
1166 | # assembled correctly. | |
1167 | while 1 { | |
1168 | expect { | |
1169 | -re " +\[0-9\]+ 0000 9B04\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 1170 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
1171 | eof { break } |
1172 | } | |
1173 | } | |
1174 | ||
1175 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1176 | # isn't needed, but just in case, please keep it in for now. | |
1177 | gas_finish | |
1178 | ||
1179 | # Did we find what we were looking for? If not, flunk it. | |
1180 | if [expr $x == 1] then { pass $testname } else { fail $testname } | |
1181 | } | |
1182 | ||
1183 | proc do_xc16x_orb {} { | |
1184 | set testname "orb.s: xc16x or byte instructions tests" | |
1185 | set x 0 | |
1186 | ||
1187 | gas_start "orb.s" "-al" | |
1188 | ||
1189 | # Check each instruction bit pattern to verify it got | |
1190 | # assembled correctly. | |
1191 | while 1 { | |
1192 | expect { | |
1193 | -re " +\[0-9\]+ 0000 7102\[^\n\]*\n" { set x [expr $x+1] } | |
1194 | -re " +\[0-9\]+ 0002 7909\[^\n\]*\n" { set x [expr $x+1] } | |
1195 | -re " +\[0-9\]+ 0004 790D\[^\n\]*\n" { set x [expr $x+1] } | |
1196 | -re " +\[0-9\]+ 0006 7903\[^\n\]*\n" { set x [expr $x+1] } | |
1197 | -re " +\[0-9\]+ 0008 77F02300\[^\n\]*\n" { set x [expr $x+1] } | |
1198 | -re " +\[0-9\]+ 000c 73F03402\[^\n\]*\n" { set x [expr $x+1] } | |
1199 | -re " +\[0-9\]+ 0010 75F03402\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 1200 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
1201 | eof { break } |
1202 | } | |
1203 | } | |
1204 | ||
1205 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1206 | # isn't needed, but just in case, please keep it in for now. | |
1207 | gas_finish | |
1208 | ||
1209 | # Did we find what we were looking for? If not, flunk it. | |
1210 | if [expr $x == 7] then { pass $testname } else { fail $testname } | |
1211 | } | |
1212 | ||
1213 | ||
1214 | proc do_xc16x_prior {} { | |
1215 | set testname "prior.s: Determine no shift cycles tests" | |
1216 | set x 0 | |
1217 | ||
1218 | gas_start "prior.s" "-al" | |
1219 | ||
1220 | # Check each instruction bit pattern to verify it got | |
1221 | # assembled correctly. | |
1222 | while 1 { | |
1223 | expect { | |
1224 | -re " +\[0-9\]+ 0000 2B01\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 1225 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
1226 | eof { break } |
1227 | } | |
1228 | } | |
1229 | ||
1230 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1231 | # isn't needed, but just in case, please keep it in for now. | |
1232 | gas_finish | |
1233 | ||
1234 | # Did we find what we were looking for? If not, flunk it. | |
1235 | if [expr $x == 1] then { pass $testname } else { fail $testname } | |
1236 | } | |
1237 | ||
1238 | proc do_xc16x_nop {} { | |
1239 | set testname "nop.s: no operation nop tests" | |
1240 | set x 0 | |
1241 | ||
1242 | gas_start "nop.s" "-al" | |
1243 | ||
1244 | # Check each instruction bit pattern to verify it got | |
1245 | # assembled correctly. | |
1246 | while 1 { | |
1247 | expect { | |
1248 | -re " +\[0-9\]+ 0000 CC00\[^\n\]*\n" { set x [expr $x+1] } | |
1249 | -re " +\[0-9\]+ 0002 CC00\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 1250 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
1251 | eof { break } |
1252 | } | |
1253 | } | |
1254 | ||
1255 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1256 | # isn't needed, but just in case, please keep it in for now. | |
1257 | gas_finish | |
1258 | ||
1259 | # Did we find what we were looking for? If not, flunk it. | |
1260 | if [expr $x == 2] then { pass $testname } else { fail $testname } | |
1261 | } | |
1262 | ||
1263 | ||
1264 | proc do_xc16x_scxt {} { | |
1265 | set testname "scxt.s: push direct word to system stack tests" | |
1266 | set x 0 | |
1267 | ||
1268 | gas_start "scxt.s" "-al" | |
1269 | ||
1270 | # Check each instruction bit pattern to verify it got | |
1271 | # assembled correctly. | |
1272 | while 1 { | |
1273 | expect { | |
1274 | -re " +\[0-9\]+ 0000 C6F0FFFF\[^\n\]*\n" { set x [expr $x+1] } | |
1275 | -re " +\[0-9\]+ 0004 D6F0FFFF\[^\n\]*\n" { set x [expr $x+1] } | |
e3ea77ac | 1276 | timeout { perror "timeout\n"; break } |
d70c5fc7 NC |
1277 | eof { break } |
1278 | } | |
1279 | } | |
1280 | ||
1281 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1282 | # isn't needed, but just in case, please keep it in for now. | |
1283 | gas_finish | |
1284 | ||
1285 | # Did we find what we were looking for? If not, flunk it. | |
1286 | if [expr $x == 2] then { pass $testname } else { fail $testname } | |
1287 | } | |
1288 | ||
1289 | ||
1290 | if [istarget xc16x*-*-*] then { | |
1291 | # Test the basic xc16x instruction parser | |
1292 | do_xc16x_add | |
1293 | do_xc16x_addb | |
1294 | do_xc16x_addc | |
1295 | do_xc16x_addcb | |
1296 | do_xc16x_sub | |
1297 | do_xc16x_subb | |
1298 | do_xc16x_subc | |
1299 | do_xc16x_subcb | |
1300 | do_xc16x_and | |
1301 | do_xc16x_andb | |
1302 | do_xc16x_or | |
1303 | do_xc16x_xor | |
1304 | do_xc16x_xorb | |
1305 | do_xc16x_mov | |
1306 | do_xc16x_movb | |
1307 | do_xc16x_movbs | |
1308 | do_xc16x_movbz | |
1309 | do_xc16x_shlrol | |
1310 | do_xc16x_neg | |
1311 | do_xc16x_mul | |
1312 | do_xc16x_div | |
1313 | do_xc16x_jmpa | |
1314 | do_xc16x_jmpi | |
1315 | do_xc16x_jmpr | |
1316 | do_xc16x_syscontrol1 | |
1317 | do_xc16x_syscontrol2 | |
1318 | do_xc16x_cpl | |
1319 | do_xc16x_cmp | |
1320 | do_xc16x_cmpb | |
1321 | do_xc16x_cmpi | |
1322 | do_xc16x_calla | |
1323 | do_xc16x_calli | |
1324 | do_xc16x_bit | |
1325 | do_xc16x_bfldl | |
1326 | do_xc16x_ret | |
1327 | do_xc16x_trap | |
1328 | do_xc16x_orb | |
1329 | do_xc16x_prior | |
1330 | do_xc16x_nop | |
1331 | do_xc16x_scxt | |
1332 | ||
1333 | } |