]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gas/testsuite/gas/h8300/h8300.exp
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update year range in copyright notice of binutils files
[thirdparty/binutils-gdb.git] / gas / testsuite / gas / h8300 / h8300.exp
CommitLineData
a2c58332 1# Copyright (C) 2012-2022 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
252b5132
RH		 17#
18# Some H8/300 tests
19#
20proc do_h8300_add_sub {} {
21 set testname "addsub.s: h8300 add/sub tests"
22 set x 0
23
24 gas_start "addsub.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 8910\[^\n\]*\n" { set x [expr $x+1] }
31 -re " +\[0-9\]+ 0002 0819\[^\n\]*\n" { set x [expr $x+1] }
32 -re " +\[0-9\]+ 0004 0912\[^\n\]*\n" { set x [expr $x+1] }
33 -re " +\[0-9\]+ 0006 0B04\[^\n\]*\n" { set x [expr $x+1] }
34 -re " +\[0-9\]+ 0008 0B85\[^\n\]*\n" { set x [expr $x+1] }
35 -re " +\[0-9\]+ 000a 0E89\[^\n\]*\n" { set x [expr $x+1] }
36 -re " +\[0-9\]+ 000c 9210\[^\n\]*\n" { set x [expr $x+1] }
37 -re " +\[0-9\]+ 000e 1889\[^\n\]*\n" { set x [expr $x+1] }
38 -re " +\[0-9\]+ 0010 1901\[^\n\]*\n" { set x [expr $x+1] }
39 -re " +\[0-9\]+ 0012 1B04\[^\n\]*\n" { set x [expr $x+1] }
40 -re " +\[0-9\]+ 0014 1B85\[^\n\]*\n" { set x [expr $x+1] }
41 -re " +\[0-9\]+ 0016 1E89\[^\n\]*\n" { set x [expr $x+1] }
42 -re " +\[0-9\]+ 0018 B210\[^\n\]*\n" { set x [expr $x+1] }
43 timeout { perror "timeout\n; break }
44 eof { break }
45 }
46 }
47
48 # This was intended to do any cleanup necessary. It kinda looks like it
49 # isn't needed, but just in case, please keep it in for now.
50 gas_finish
51
52 # Did we find what we were looking for? If not, flunk it.
53 if [expr $x == 13] then { pass $testname } else { fail $testname }
54}
55
56proc do_h8300_logical {} {
57 set testname "logical.s: h8300 logical tests"
58 set x 0
59
60 gas_start "logical.s" "-al"
61
62 # Check each instruction bit pattern to verify it got
63 # assembled correctly.
64 while 1 {
65 expect {
66 -re " +\[0-9\]+ 0000 E910\[^\n\]*\n" { set x [expr $x+1] }
67 -re " +\[0-9\]+ 0002 1691\[^\n\]*\n" { set x [expr $x+1] }
68 -re " +\[0-9\]+ 0004 0610\[^\n\]*\n" { set x [expr $x+1] }
69 -re " +\[0-9\]+ 0006 C810\[^\n\]*\n" { set x [expr $x+1] }
70 -re " +\[0-9\]+ 0008 1498\[^\n\]*\n" { set x [expr $x+1] }
71 -re " +\[0-9\]+ 000a 0410\[^\n\]*\n" { set x [expr $x+1] }
72 -re " +\[0-9\]+ 000c D810\[^\n\]*\n" { set x [expr $x+1] }
73 -re " +\[0-9\]+ 000e 1589\[^\n\]*\n" { set x [expr $x+1] }
74 -re " +\[0-9\]+ 0010 0510\[^\n\]*\n" { set x [expr $x+1] }
75 -re " +\[0-9\]+ 0012 1788\[^\n\]*\n" { set x [expr $x+1] }
76 -re " +\[0-9\]+ 0014 1708\[^\n\]*\n" { set x [expr $x+1] }
77 timeout { perror "timeout\n; break }
78 eof { break }
79 }
80 }
81
82 # This was intended to do any cleanup necessary. It kinda looks like it
83 # isn't needed, but just in case, please keep it in for now.
84 gas_finish
85
86 # Did we find what we were looking for? If not, flunk it.
87 if [expr $x == 11] then { pass $testname } else { fail $testname }
88}
89
90proc do_h8300_cbranch {} {
91 set testname "cbranch.s: h8300 conditional branch tests"
92 set x 0
93
94 gas_start "cbranch.s" "-al"
95
96 # Check each instruction bit pattern to verify it got
97 # assembled correctly.
98 while 1 {
99 expect {
100 -re " +\[0-9\]+ 0000 4000\[^\n\]*\n" { set x [expr $x+1] }
101 -re " +\[0-9\]+ 0002 4000\[^\n\]*\n" { set x [expr $x+1] }
102 -re " +\[0-9\]+ 0004 4100\[^\n\]*\n" { set x [expr $x+1] }
103 -re " +\[0-9\]+ 0006 4100\[^\n\]*\n" { set x [expr $x+1] }
104 -re " +\[0-9\]+ 0008 4200\[^\n\]*\n" { set x [expr $x+1] }
105 -re " +\[0-9\]+ 000a 4300\[^\n\]*\n" { set x [expr $x+1] }
106 -re " +\[0-9\]+ 000c 4400\[^\n\]*\n" { set x [expr $x+1] }
107 -re " +\[0-9\]+ 000e 4400\[^\n\]*\n" { set x [expr $x+1] }
108 -re " +\[0-9\]+ 0010 4500\[^\n\]*\n" { set x [expr $x+1] }
109 -re " +\[0-9\]+ 0012 4500\[^\n\]*\n" { set x [expr $x+1] }
110 -re " +\[0-9\]+ 0014 4600\[^\n\]*\n" { set x [expr $x+1] }
111 -re " +\[0-9\]+ 0016 4700\[^\n\]*\n" { set x [expr $x+1] }
112 -re " +\[0-9\]+ 0018 4800\[^\n\]*\n" { set x [expr $x+1] }
113 -re " +\[0-9\]+ 001a 4900\[^\n\]*\n" { set x [expr $x+1] }
114 -re " +\[0-9\]+ 001c 4A00\[^\n\]*\n" { set x [expr $x+1] }
115 -re " +\[0-9\]+ 001e 4B00\[^\n\]*\n" { set x [expr $x+1] }
116 -re " +\[0-9\]+ 0020 4C00\[^\n\]*\n" { set x [expr $x+1] }
117 -re " +\[0-9\]+ 0022 4D00\[^\n\]*\n" { set x [expr $x+1] }
118 -re " +\[0-9\]+ 0024 4E00\[^\n\]*\n" { set x [expr $x+1] }
119 -re " +\[0-9\]+ 0026 4F00\[^\n\]*\n" { set x [expr $x+1] }
120 timeout { perror "timeout\n; break }
121 eof { break }
122 }
123 }
124
125 # This was intended to do any cleanup necessary. It kinda looks like it
126 # isn't needed, but just in case, please keep it in for now.
127 gas_finish
128
129 # Did we find what we were looking for? If not, flunk it.
130 if [expr $x == 20] then { pass $testname } else { fail $testname }
131}
132
133proc do_h8300_bitops1 {} {
134 set testname "bitops1.s: h8300 bitops tests #1"
135 set x 0
136
137 gas_start "bitops1.s" "-al"
138
139 # Check each instruction bit pattern to verify it got
140 # assembled correctly.
141 while 1 {
142 expect {
143 -re " +\[0-9\]+ 0000 7608\[^\n\]*\n" { set x [expr $x+1] }
144 -re " +\[0-9\]+ 0002 7C007600\[^\n\]*\n" { set x [expr $x+1] }
145 -re " +\[0-9\]+ 0006 7E407600\[^\n\]*\n" { set x [expr $x+1] }
146 -re " +\[0-9\]+ 000a 7208\[^\n\]*\n" { set x [expr $x+1] }
147 -re " +\[0-9\]+ 000c 7D007200\[^\n\]*\n" { set x [expr $x+1] }
148 -re " +\[0-9\]+ 0010 7F407200\[^\n\]*\n" { set x [expr $x+1] }
149 -re " +\[0-9\]+ 0014 6298\[^\n\]*\n" { set x [expr $x+1] }
150 -re " +\[0-9\]+ 0016 7D006290\[^\n\]*\n" { set x [expr $x+1] }
151 -re " +\[0-9\]+ 001a 7F406290\[^\n\]*\n" { set x [expr $x+1] }
152 -re " +\[0-9\]+ 001e 7688\[^\n\]*\n" { set x [expr $x+1] }
153 -re " +\[0-9\]+ 0020 7C007680\[^\n\]*\n" { set x [expr $x+1] }
154 -re " +\[0-9\]+ 0024 7E407680\[^\n\]*\n" { set x [expr $x+1] }
155 -re " +\[0-9\]+ 0028 7788\[^\n\]*\n" { set x [expr $x+1] }
156 -re " +\[0-9\]+ 002a 7C007780\[^\n\]*\n" { set x [expr $x+1] }
157 -re " +\[0-9\]+ 002e 7E407780\[^\n\]*\n" { set x [expr $x+1] }
158 timeout { perror "timeout\n; break }
159 eof { break }
160 }
161 }
162
163 # This was intended to do any cleanup necessary. It kinda looks like it
164 # isn't needed, but just in case, please keep it in for now.
165 gas_finish
166
167 # Did we find what we were looking for? If not, flunk it.
168 if [expr $x == 15] then { pass $testname } else { fail $testname }
169}
170
171proc do_h8300_bitops2 {} {
172 set testname "bitops2.s: h8300 bitops tests #2"
173 set x 0
174
175 gas_start "bitops2.s" "-al"
176
177 # Check each instruction bit pattern to verify it got
178 # assembled correctly.
179 while 1 {
180 expect {
181 -re " +\[0-9\]+ 0000 7488\[^\n\]*\n" { set x [expr $x+1] }
182 -re " +\[0-9\]+ 0002 7C007480\[^\n\]*\n" { set x [expr $x+1] }
183 -re " +\[0-9\]+ 0006 7E407480\[^\n\]*\n" { set x [expr $x+1] }
184 -re " +\[0-9\]+ 000a 6788\[^\n\]*\n" { set x [expr $x+1] }
185 -re " +\[0-9\]+ 000c 7D006780\[^\n\]*\n" { set x [expr $x+1] }
186 -re " +\[0-9\]+ 0010 7F406780\[^\n\]*\n" { set x [expr $x+1] }
187 -re " +\[0-9\]+ 0014 7588\[^\n\]*\n" { set x [expr $x+1] }
188 -re " +\[0-9\]+ 0016 7C007580\[^\n\]*\n" { set x [expr $x+1] }
189 -re " +\[0-9\]+ 001a 7E407580\[^\n\]*\n" { set x [expr $x+1] }
190 -re " +\[0-9\]+ 001e 7708\[^\n\]*\n" { set x [expr $x+1] }
191 -re " +\[0-9\]+ 0020 7C007700\[^\n\]*\n" { set x [expr $x+1] }
192 -re " +\[0-9\]+ 0024 7E407700\[^\n\]*\n" { set x [expr $x+1] }
193 timeout { perror "timeout\n; break }
194 eof { break }
195 }
196 }
197
198 # This was intended to do any cleanup necessary. It kinda looks like it
199 # isn't needed, but just in case, please keep it in for now.
200 gas_finish
201
202 # Did we find what we were looking for? If not, flunk it.
203 if [expr $x == 12] then { pass $testname } else { fail $testname }
204}
205
206proc do_h8300_bitops3 {} {
207 set testname "bitops3.s: h8300 bitops tests #3"
208 set x 0
209
210 gas_start "bitops3.s" "-al"
211
212 # Check each instruction bit pattern to verify it got
213 # assembled correctly.
214 while 1 {
215 expect {
216 -re " +\[0-9\]+ 0000 7108\[^\n\]*\n" { set x [expr $x+1] }
217 -re " +\[0-9\]+ 0002 7D007100\[^\n\]*\n" { set x [expr $x+1] }
218 -re " +\[0-9\]+ 0006 7F407100\[^\n\]*\n" { set x [expr $x+1] }
219 -re " +\[0-9\]+ 000a 6198\[^\n\]*\n" { set x [expr $x+1] }
220 -re " +\[0-9\]+ 000c 7D006190\[^\n\]*\n" { set x [expr $x+1] }
221 -re " +\[0-9\]+ 0010 7F406190\[^\n\]*\n" { set x [expr $x+1] }
222 -re " +\[0-9\]+ 0014 7008\[^\n\]*\n" { set x [expr $x+1] }
223 -re " +\[0-9\]+ 0016 7D007000\[^\n\]*\n" { set x [expr $x+1] }
224 -re " +\[0-9\]+ 001a 7F407000\[^\n\]*\n" { set x [expr $x+1] }
225 -re " +\[0-9\]+ 001e 6098\[^\n\]*\n" { set x [expr $x+1] }
226 -re " +\[0-9\]+ 0020 7D006090\[^\n\]*\n" { set x [expr $x+1] }
227 -re " +\[0-9\]+ 0024 7F406090\[^\n\]*\n" { set x [expr $x+1] }
228 timeout { perror "timeout\n; break }
229 eof { break }
230 }
231 }
232
233 # This was intended to do any cleanup necessary. It kinda looks like it
234 # isn't needed, but just in case, please keep it in for now.
235 gas_finish
236
237 # Did we find what we were looking for? If not, flunk it.
238 if [expr $x == 12] then { pass $testname } else { fail $testname }
239}
240
241proc do_h8300_bitops4 {} {
242 set testname "bitops4.s: h8300 bitops tests #4"
243 set x 0
244
245 gas_start "bitops4.s" "-al"
246
247 # Check each instruction bit pattern to verify it got
248 # assembled correctly.
249 while 1 {
250 expect {
251 -re " +\[0-9\]+ 0000 7408\[^\n\]*\n" { set x [expr $x+1] }
252 -re " +\[0-9\]+ 0002 7C007400\[^\n\]*\n" { set x [expr $x+1] }
253 -re " +\[0-9\]+ 0006 7E407400\[^\n\]*\n" { set x [expr $x+1] }
254 -re " +\[0-9\]+ 000a 6708\[^\n\]*\n" { set x [expr $x+1] }
255 -re " +\[0-9\]+ 000c 7D006700\[^\n\]*\n" { set x [expr $x+1] }
256 -re " +\[0-9\]+ 0010 7F406700\[^\n\]*\n" { set x [expr $x+1] }
257 -re " +\[0-9\]+ 0014 7308\[^\n\]*\n" { set x [expr $x+1] }
258 -re " +\[0-9\]+ 0016 7C007300\[^\n\]*\n" { set x [expr $x+1] }
259 -re " +\[0-9\]+ 001a 7E407300\[^\n\]*\n" { set x [expr $x+1] }
260 -re " +\[0-9\]+ 001e 6398\[^\n\]*\n" { set x [expr $x+1] }
261 -re " +\[0-9\]+ 0020 7C006390\[^\n\]*\n" { set x [expr $x+1] }
262 -re " +\[0-9\]+ 0024 7E406390\[^\n\]*\n" { set x [expr $x+1] }
263 -re " +\[0-9\]+ 0028 7508\[^\n\]*\n" { set x [expr $x+1] }
264 -re " +\[0-9\]+ 002a 7C007500\[^\n\]*\n" { set x [expr $x+1] }
265 -re " +\[0-9\]+ 002e 7E407500\[^\n\]*\n" { set x [expr $x+1] }
266 timeout { perror "timeout\n; break }
267 eof { break }
268 }
269 }
270
271 # This was intended to do any cleanup necessary. It kinda looks like it
272 # isn't needed, but just in case, please keep it in for now.
273 gas_finish
274
275 # Did we find what we were looking for? If not, flunk it.
276 if [expr $x == 15] then { pass $testname } else { fail $testname }
277}
278
279proc do_h8300_branch {} {
280 set testname "branch.s: h8300 branch tests"
281 set x 0
282
283 gas_start "branch.s" "-al"
284
285 # Check each instruction bit pattern to verify it got
286 # assembled correctly.
287 while 1 {
288 expect {
289 -re " +\[0-9\]+ 0000 5500\[^\n\]*\n" { set x [expr $x+1] }
290 -re " +\[0-9\]+ 0002 5A000000\[^\n\]*\n" { set x [expr $x+1] }
291 -re " +\[0-9\]+ 0006 5900\[^\n\]*\n" { set x [expr $x+1] }
292 -re " +\[0-9\]+ 0008 5B00\[^\n\]*\n" { set x [expr $x+1] }
293 -re " +\[0-9\]+ 000a 5E000000\[^\n\]*\n" { set x [expr $x+1] }
294 -re " +\[0-9\]+ 000e 5D00\[^\n\]*\n" { set x [expr $x+1] }
295 -re " +\[0-9\]+ 0010 5F00\[^\n\]*\n" { set x [expr $x+1] }
296 timeout { perror "timeout\n; break }
297 eof { break }
298 }
299 }
300
301 # This was intended to do any cleanup necessary. It kinda looks like it
302 # isn't needed, but just in case, please keep it in for now.
303 gas_finish
304
305 # Did we find what we were looking for? If not, flunk it.
306 if [expr $x == 7] then { pass $testname } else { fail $testname }
307}
308
309proc do_h8300_compare {} {
310 set testname "compare.s: h8300 compare tests"
311 set x 0
312
313 gas_start "compare.s" "-al"
314
315 # Check each instruction bit pattern to verify it got
316 # assembled correctly.
317 while 1 {
318 expect {
319 -re " +\[0-9\]+ 0000 A800\[^\n\]*\n" { set x [expr $x+1] }
320 -re " +\[0-9\]+ 0002 1C08\[^\n\]*\n" { set x [expr $x+1] }
321 -re " +\[0-9\]+ 0004 1D01\[^\n\]*\n" { set x [expr $x+1] }
322 timeout { perror "timeout\n; break }
323 eof { break }
324 }
325 }
326
327 # This was intended to do any cleanup necessary. It kinda looks like it
328 # isn't needed, but just in case, please keep it in for now.
329 gas_finish
330
331 # Did we find what we were looking for? If not, flunk it.
332 if [expr $x == 3] then { pass $testname } else { fail $testname }
333}
334
335proc do_h8300_decimal {} {
336 set testname "decimal.s: h8300 decimal tests"
337 set x 0
338
339 gas_start "decimal.s" "-al"
340
341 # Check each instruction bit pattern to verify it got
342 # assembled correctly.
343 while 1 {
344 expect {
345 -re " +\[0-9\]+ 0000 0F08\[^\n\]*\n" { set x [expr $x+1] }
346 -re " +\[0-9\]+ 0002 1F08\[^\n\]*\n" { set x [expr $x+1] }
347 eof { break }
348 }
349 }
350
351 # This was intended to do any cleanup necessary. It kinda looks like it
352 # isn't needed, but just in case, please keep it in for now.
353 gas_finish
354
355 # Did we find what we were looking for? If not, flunk it.
356 if [expr $x == 2] then { pass $testname } else { fail $testname }
357}
358
359proc do_h8300_incdec {} {
360 set testname "incdec.s: h8300 incdec tests"
361 set x 0
362
363 gas_start "incdec.s" "-al"
364
365 # Check each instruction bit pattern to verify it got
366 # assembled correctly.
367 while 1 {
368 expect {
369 -re " +\[0-9\]+ 0000 1A08\[^\n\]*\n" { set x [expr $x+1] }
370 -re " +\[0-9\]+ 0002 0A08\[^\n\]*\n" { set x [expr $x+1] }
371 eof { break }
372 }
373 }
374
375 # This was intended to do any cleanup necessary. It kinda looks like it
376 # isn't needed, but just in case, please keep it in for now.
377 gas_finish
378
379 # Did we find what we were looking for? If not, flunk it.
380 if [expr $x == 2] then { pass $testname } else { fail $testname }
381}
382
383proc do_h8300_divmul {} {
384 set testname "divmul.s: h8300 divmul tests"
385 set x 0
386
387 gas_start "divmul.s" "-al"
388
389 # Check each instruction bit pattern to verify it got
390 # assembled correctly.
391 while 1 {
392 expect {
393 -re " +\[0-9\]+ 0000 5181\[^\n\]*\n" { set x [expr $x+1] }
394 -re " +\[0-9\]+ 0002 5081\[^\n\]*\n" { set x [expr $x+1] }
395 eof { break }
396 }
397 }
398
399 # This was intended to do any cleanup necessary. It kinda looks like it
400 # isn't needed, but just in case, please keep it in for now.
401 gas_finish
402
403 # Did we find what we were looking for? If not, flunk it.
404 if [expr $x == 2] then { pass $testname } else { fail $testname }
405}
406
407proc do_h8300_misc {} {
408 set testname "misc.s: h8300 misc tests"
409 set x 0
410
411 gas_start "misc.s" "-al"
412
413 # Check each instruction bit pattern to verify it got
414 # assembled correctly.
415 while 1 {
416 expect {
417 -re " +\[0-9\]+ 0000 7B5C598F\[^\n\]*\n" { set x [expr $x+1] }
418 -re " +\[0-9\]+ 0004 0700\[^\n\]*\n" { set x [expr $x+1] }
419 -re " +\[0-9\]+ 0006 0308\[^\n\]*\n" { set x [expr $x+1] }
8fb49c3c
YS		 420 -re " +\[0-9\]+ 0008 6A480010\[^\n\]*\n" { set x [expr $x+1] }
421 -re " +\[0-9\]+ 000c 6AC80010\[^\n\]*\n" { set x [expr $x+1] }
422 -re " +\[0-9\]+ 0010 0000\[^\n\]*\n" { set x [expr $x+1] }
423 -re " +\[0-9\]+ 0012 5670\[^\n\]*\n" { set x [expr $x+1] }
424 -re " +\[0-9\]+ 0014 5470\[^\n\]*\n" { set x [expr $x+1] }
425 -re " +\[0-9\]+ 0016 0180\[^\n\]*\n" { set x [expr $x+1] }
426 -re " +\[0-9\]+ 0018 0208\[^\n\]*\n" { set x [expr $x+1] }
252b5132
RH		 427 eof { break }
428 }
429 }
430
431 # This was intended to do any cleanup necessary. It kinda looks like it
432 # isn't needed, but just in case, please keep it in for now.
433 gas_finish
434
435 # Did we find what we were looking for? If not, flunk it.
8fb49c3c 436 if [expr $x == 10] then { pass $testname } else { fail $testname }
252b5132 437
252b5132
RH		 438}
439
440proc do_h8300_movb {} {
441 set testname "movb.s: h8300 movb tests"
442 set x 0
443
444 gas_start "movb.s" "-al"
445
446 # Check each instruction bit pattern to verify it got
447 # assembled correctly.
448 while 1 {
449 expect {
450 -re " +\[0-9\]+ 0000 0C89\[^\n\]*\n" { set x [expr $x+1] }
451 -re " +\[0-9\]+ 0002 F810\[^\n\]*\n" { set x [expr $x+1] }
452 -re " +\[0-9\]+ 0004 6818\[^\n\]*\n" { set x [expr $x+1] }
453 -re " +\[0-9\]+ 0006 6E180010\[^\n\]*\n" { set x [expr $x+1] }
454 -re " +\[0-9\]+ 000a 6C18\[^\n\]*\n" { set x [expr $x+1] }
455 -re " +\[0-9\]+ 000c 2810\[^\n\]*\n" { set x [expr $x+1] }
456 -re " +\[0-9\]+ 000e 6A080000\[^\n\]*\n" { set x [expr $x+1] }
457 -re " +\[0-9\]+ 0012 6898\[^\n\]*\n" { set x [expr $x+1] }
458 -re " +\[0-9\]+ 0014 6E980010\[^\n\]*\n" { set x [expr $x+1] }
459 -re " +\[0-9\]+ 0018 6C98\[^\n\]*\n" { set x [expr $x+1] }
460 -re " +\[0-9\]+ 001a 3810\[^\n\]*\n" { set x [expr $x+1] }
461 -re " +\[0-9\]+ 001c 6A880000\[^\n\]*\n" { set x [expr $x+1] }
462 eof { break }
463 }
464 }
465
466 # This was intended to do any cleanup necessary. It kinda looks like it
467 # isn't needed, but just in case, please keep it in for now.
468 gas_finish
469
470 # Did we find what we were looking for? If not, flunk it.
471 if [expr $x == 12] then { pass $testname } else { fail $testname }
472}
473
474proc do_h8300_movw {} {
475 set testname "movw.s: h8300 movw tests"
476 set x 0
477
478 gas_start "movw.s" "-al"
479
480 # Check each instruction bit pattern to verify it got
481 # assembled correctly.
482 while 1 {
483 expect {
484 -re " +\[0-9\]+ 0000 0D01\[^\n\]*\n" { set x [expr $x+1] }
485 -re " +\[0-9\]+ 0002 79000010\[^\n\]*\n" { set x [expr $x+1] }
486 -re " +\[0-9\]+ 0006 6910\[^\n\]*\n" { set x [expr $x+1] }
487 -re " +\[0-9\]+ 0008 6F100010\[^\n\]*\n" { set x [expr $x+1] }
488 -re " +\[0-9\]+ 000c 6D10\[^\n\]*\n" { set x [expr $x+1] }
489 -re " +\[0-9\]+ 000e 6B000000\[^\n\]*\n" { set x [expr $x+1] }
490 -re " +\[0-9\]+ 0012 6990\[^\n\]*\n" { set x [expr $x+1] }
491 -re " +\[0-9\]+ 0014 6F900010\[^\n\]*\n" { set x [expr $x+1] }
492 -re " +\[0-9\]+ 0018 6D90\[^\n\]*\n" { set x [expr $x+1] }
493 -re " +\[0-9\]+ 001a 6B800000\[^\n\]*\n" { set x [expr $x+1] }
494 eof { break }
495 }
496 }
497
498 # This was intended to do any cleanup necessary. It kinda looks like it
499 # isn't needed, but just in case, please keep it in for now.
500 gas_finish
501
502 # Did we find what we were looking for? If not, flunk it.
503 if [expr $x == 10] then { pass $testname } else { fail $testname }
504}
505
506proc do_h8300_pushpop {} {
507 set testname "pushpop.s: h8300 pushpop tests"
508 set x 0
509
510 gas_start "pushpop.s" "-al"
511
512 # Check each instruction bit pattern to verify it got
513 # assembled correctly.
514 while 1 {
515 expect {
516 -re " +\[0-9\]+ 0000 6D70\[^\n\]*\n" { set x [expr $x+1] }
517 -re " +\[0-9\]+ 0002 6DF0\[^\n\]*\n" { set x [expr $x+1] }
518 eof { break }
519 }
520 }
521
522 # This was intended to do any cleanup necessary. It kinda looks like it
523 # isn't needed, but just in case, please keep it in for now.
524 gas_finish
525
526 # Did we find what we were looking for? If not, flunk it.
527 if [expr $x == 2] then { pass $testname } else { fail $testname }
528}
529
530proc do_h8300_rotate_shift {} {
531 set testname "rotsh.s: h8300 rotate and shift tests"
532 set x 0
533
534 gas_start "rotsh.s" "-al"
535
536 # Check each instruction bit pattern to verify it got
537 # assembled correctly.
538 while 1 {
539 expect {
540 -re " +\[0-9\]+ 0000 1288\[^\n\]*\n" { set x [expr $x+1] }
541 -re " +\[0-9\]+ 0002 1388\[^\n\]*\n" { set x [expr $x+1] }
542 -re " +\[0-9\]+ 0004 1208\[^\n\]*\n" { set x [expr $x+1] }
543 -re " +\[0-9\]+ 0006 1308\[^\n\]*\n" { set x [expr $x+1] }
544 -re " +\[0-9\]+ 0008 1088\[^\n\]*\n" { set x [expr $x+1] }
545 -re " +\[0-9\]+ 000a 1188\[^\n\]*\n" { set x [expr $x+1] }
546 -re " +\[0-9\]+ 000c 1008\[^\n\]*\n" { set x [expr $x+1] }
547 -re " +\[0-9\]+ 000e 1108\[^\n\]*\n" { set x [expr $x+1] }
548 eof { break }
549 }
550 }
551
552 # This was intended to do any cleanup necessary. It kinda looks like it
553 # isn't needed, but just in case, please keep it in for now.
554 gas_finish
555
556 # Did we find what we were looking for? If not, flunk it.
557 if [expr $x == 8] then { pass $testname } else { fail $testname }
558}
559
560proc do_h8300h_add_sub {} {
561 set testname "addsubh.s: h8300h add/sub tests"
562 set x 0
563
564 gas_start "addsubh.s" "-al"
565
566 # Check each instruction bit pattern to verify it got
567 # assembled correctly.
568 while 1 {
569 expect {
570 -re " +\[0-9\]+ 0000 8910\[^\n\]*\n" { set x [expr $x+1] }
571 -re " +\[0-9\]+ 0002 0819\[^\n\]*\n" { set x [expr $x+1] }
572 -re " +\[0-9\]+ 0004 79110020\[^\n\]*\n" { set x [expr $x+1] }
573 -re " +\[0-9\]+ 0008 0912\[^\n\]*\n" { set x [expr $x+1] }
574 -re " +\[0-9\]+ 000a 7A110000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
575 -re " +\[0-9\]+ 0010 0A92\[^\n\]*\n" { set x [expr $x+1] }
576 -re " +\[0-9\]+ 0012 0B04\[^\n\]*\n" { set x [expr $x+1] }
577 -re " +\[0-9\]+ 0014 0B85\[^\n\]*\n" { set x [expr $x+1] }
578 -re " +\[0-9\]+ 0016 0B96\[^\n\]*\n" { set x [expr $x+1] }
579 -re " +\[0-9\]+ 0018 0E89\[^\n\]*\n" { set x [expr $x+1] }
580 -re " +\[0-9\]+ 001a 9210\[^\n\]*\n" { set x [expr $x+1] }
581 -re " +\[0-9\]+ 001c 1889\[^\n\]*\n" { set x [expr $x+1] }
582 -re " +\[0-9\]+ 001e 79310010\[^\n\]*\n" { set x [expr $x+1] }
583 -re " +\[0-9\]+ 0022 1901\[^\n\]*\n" { set x [expr $x+1] }
584 -re " +\[0-9\]+ 0024 7A310000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
585 -re " +\[0-9\]+ 002a 1A92\[^\n\]*\n" { set x [expr $x+1] }
586 -re " +\[0-9\]+ 002c 1B04\[^\n\]*\n" { set x [expr $x+1] }
587 -re " +\[0-9\]+ 002e 1B85\[^\n\]*\n" { set x [expr $x+1] }
588 -re " +\[0-9\]+ 0030 1B96\[^\n\]*\n" { set x [expr $x+1] }
589 -re " +\[0-9\]+ 0032 1E89\[^\n\]*\n" { set x [expr $x+1] }
590 -re " +\[0-9\]+ 0034 B210\[^\n\]*\n" { set x [expr $x+1] }
591 timeout { perror "timeout\n; break }
592 eof { break }
593 }
594 }
595
596 # This was intended to do any cleanup necessary. It kinda looks like it
597 # isn't needed, but just in case, please keep it in for now.
598 gas_finish
599
600 # Did we find what we were looking for? If not, flunk it.
601 if [expr $x == 21] then { pass $testname } else { fail $testname }
602}
603
604proc do_h8300h_logical {} {
605 set testname "logicalh.s: h8300h logical tests"
606 set x 0
607
608 gas_start "logicalh.s" "-al"
609
610 # Check each instruction bit pattern to verify it got
611 # assembled correctly.
612 while 1 {
613 expect {
614 -re " +\[0-9\]+ 0000 E910\[^\n\]*\n" { set x [expr $x+1] }
615 -re " +\[0-9\]+ 0002 1691\[^\n\]*\n" { set x [expr $x+1] }
616 -re " +\[0-9\]+ 0004 79610020\[^\n\]*\n" { set x [expr $x+1] }
617 -re " +\[0-9\]+ 0008 6611\[^\n\]*\n" { set x [expr $x+1] }
618 -re " +\[0-9\]+ 000a 7A610000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
619 -re " +\[0-9\]+ 0010 01F06611\[^\n\]*\n" { set x [expr $x+1] }
620 -re " +\[0-9\]+ 0014 0610\[^\n\]*\n" { set x [expr $x+1] }
621 -re " +\[0-9\]+ 0016 C810\[^\n\]*\n" { set x [expr $x+1] }
622 -re " +\[0-9\]+ 0018 1498\[^\n\]*\n" { set x [expr $x+1] }
623 -re " +\[0-9\]+ 001a 79410020\[^\n\]*\n" { set x [expr $x+1] }
624 -re " +\[0-9\]+ 001e 6411\[^\n\]*\n" { set x [expr $x+1] }
625 -re " +\[0-9\]+ 0020 7A410000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
626 -re " +\[0-9\]+ 0026 01F06411\[^\n\]*\n" { set x [expr $x+1] }
627 -re " +\[0-9\]+ 002a 0410\[^\n\]*\n" { set x [expr $x+1] }
628 -re " +\[0-9\]+ 002c D810\[^\n\]*\n" { set x [expr $x+1] }
629 -re " +\[0-9\]+ 002e 1589\[^\n\]*\n" { set x [expr $x+1] }
630 -re " +\[0-9\]+ 0030 79510020\[^\n\]*\n" { set x [expr $x+1] }
631 -re " +\[0-9\]+ 0034 6511\[^\n\]*\n" { set x [expr $x+1] }
632 -re " +\[0-9\]+ 0036 7A510000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
633 -re " +\[0-9\]+ 003c 01F06511\[^\n\]*\n" { set x [expr $x+1] }
634 -re " +\[0-9\]+ 0040 0510\[^\n\]*\n" { set x [expr $x+1] }
635 -re " +\[0-9\]+ 0042 1788\[^\n\]*\n" { set x [expr $x+1] }
636 -re " +\[0-9\]+ 0044 1790\[^\n\]*\n" { set x [expr $x+1] }
637 -re " +\[0-9\]+ 0046 17B0\[^\n\]*\n" { set x [expr $x+1] }
638 -re " +\[0-9\]+ 0048 1708\[^\n\]*\n" { set x [expr $x+1] }
639 -re " +\[0-9\]+ 004a 1710\[^\n\]*\n" { set x [expr $x+1] }
640 -re " +\[0-9\]+ 004c 1730\[^\n\]*\n" { set x [expr $x+1] }
641 timeout { perror "timeout\n; break }
642 eof { break }
643 }
644 }
645
646 # This was intended to do any cleanup necessary. It kinda looks like it
647 # isn't needed, but just in case, please keep it in for now.
648 gas_finish
649
650 # Did we find what we were looking for? If not, flunk it.
651 if [expr $x == 27] then { pass $testname } else { fail $testname }
652}
653
654proc do_h8300h_cbranch {} {
655 set testname "cbranchh.s: h8300h conditional branch tests"
656 set x 0
657
658 gas_start "cbranchh.s" "-al"
659
660 # Check each instruction bit pattern to verify it got
661 # assembled correctly.
662 while 1 {
663 expect {
664 -re " +\[0-9\]+ 0000 4000\[^\n\]*\n" { set x [expr $x+1] }
665 -re " +\[0-9\]+ 0002 4000\[^\n\]*\n" { set x [expr $x+1] }
666 -re " +\[0-9\]+ 0004 4100\[^\n\]*\n" { set x [expr $x+1] }
667 -re " +\[0-9\]+ 0006 4100\[^\n\]*\n" { set x [expr $x+1] }
668 -re " +\[0-9\]+ 0008 4200\[^\n\]*\n" { set x [expr $x+1] }
669 -re " +\[0-9\]+ 000a 4300\[^\n\]*\n" { set x [expr $x+1] }
670 -re " +\[0-9\]+ 000c 4400\[^\n\]*\n" { set x [expr $x+1] }
671 -re " +\[0-9\]+ 000e 4400\[^\n\]*\n" { set x [expr $x+1] }
672 -re " +\[0-9\]+ 0010 4500\[^\n\]*\n" { set x [expr $x+1] }
673 -re " +\[0-9\]+ 0012 4500\[^\n\]*\n" { set x [expr $x+1] }
674 -re " +\[0-9\]+ 0014 4600\[^\n\]*\n" { set x [expr $x+1] }
675 -re " +\[0-9\]+ 0016 4700\[^\n\]*\n" { set x [expr $x+1] }
676 -re " +\[0-9\]+ 0018 4800\[^\n\]*\n" { set x [expr $x+1] }
677 -re " +\[0-9\]+ 001a 4900\[^\n\]*\n" { set x [expr $x+1] }
678 -re " +\[0-9\]+ 001c 4A00\[^\n\]*\n" { set x [expr $x+1] }
679 -re " +\[0-9\]+ 001e 4B00\[^\n\]*\n" { set x [expr $x+1] }
680 -re " +\[0-9\]+ 0020 4C00\[^\n\]*\n" { set x [expr $x+1] }
681 -re " +\[0-9\]+ 0022 4D00\[^\n\]*\n" { set x [expr $x+1] }
682 -re " +\[0-9\]+ 0024 4E00\[^\n\]*\n" { set x [expr $x+1] }
683 -re " +\[0-9\]+ 0026 4F00\[^\n\]*\n" { set x [expr $x+1] }
684 -re " +\[0-9\]+ 0028 58000000\[^\n\]*\n" { set x [expr $x+1] }
685 -re " +\[0-9\]+ 002c 58000000\[^\n\]*\n" { set x [expr $x+1] }
686 -re " +\[0-9\]+ 0030 58100000\[^\n\]*\n" { set x [expr $x+1] }
687 -re " +\[0-9\]+ 0034 58100000\[^\n\]*\n" { set x [expr $x+1] }
688 -re " +\[0-9\]+ 0038 58200000\[^\n\]*\n" { set x [expr $x+1] }
689 -re " +\[0-9\]+ 003c 58300000\[^\n\]*\n" { set x [expr $x+1] }
690 -re " +\[0-9\]+ 0040 58400000\[^\n\]*\n" { set x [expr $x+1] }
691 -re " +\[0-9\]+ 0044 58400000\[^\n\]*\n" { set x [expr $x+1] }
692 -re " +\[0-9\]+ 0048 58500000\[^\n\]*\n" { set x [expr $x+1] }
693 -re " +\[0-9\]+ 004c 58500000\[^\n\]*\n" { set x [expr $x+1] }
694 -re " +\[0-9\]+ 0050 58600000\[^\n\]*\n" { set x [expr $x+1] }
695 -re " +\[0-9\]+ 0054 58700000\[^\n\]*\n" { set x [expr $x+1] }
696 -re " +\[0-9\]+ 0058 58800000\[^\n\]*\n" { set x [expr $x+1] }
697 -re " +\[0-9\]+ 005c 58900000\[^\n\]*\n" { set x [expr $x+1] }
698 -re " +\[0-9\]+ 0060 58A00000\[^\n\]*\n" { set x [expr $x+1] }
699 -re " +\[0-9\]+ 0064 58B00000\[^\n\]*\n" { set x [expr $x+1] }
700 -re " +\[0-9\]+ 0068 58C00000\[^\n\]*\n" { set x [expr $x+1] }
701 -re " +\[0-9\]+ 006c 58D00000\[^\n\]*\n" { set x [expr $x+1] }
702 -re " +\[0-9\]+ 0070 58E00000\[^\n\]*\n" { set x [expr $x+1] }
703 -re " +\[0-9\]+ 0074 58F00000\[^\n\]*\n" { set x [expr $x+1] }
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 == 40] then { pass $testname } else { fail $testname }
715}
716proc do_h8300h_bitops1 {} {
717 set testname "bitops1h.s: h8300h bitops tests #1"
718 set x 0
719
720 gas_start "bitops1h.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 7608\[^\n\]*\n" { set x [expr $x+1] }
727 -re " +\[0-9\]+ 0002 7C007600\[^\n\]*\n" { set x [expr $x+1] }
728 -re " +\[0-9\]+ 0006 7E407600\[^\n\]*\n" { set x [expr $x+1] }
729 -re " +\[0-9\]+ 000a 7208\[^\n\]*\n" { set x [expr $x+1] }
730 -re " +\[0-9\]+ 000c 7D007200\[^\n\]*\n" { set x [expr $x+1] }
731 -re " +\[0-9\]+ 0010 7F407200\[^\n\]*\n" { set x [expr $x+1] }
732 -re " +\[0-9\]+ 0014 6298\[^\n\]*\n" { set x [expr $x+1] }
733 -re " +\[0-9\]+ 0016 7D006290\[^\n\]*\n" { set x [expr $x+1] }
734 -re " +\[0-9\]+ 001a 7F406290\[^\n\]*\n" { set x [expr $x+1] }
735 -re " +\[0-9\]+ 001e 7688\[^\n\]*\n" { set x [expr $x+1] }
736 -re " +\[0-9\]+ 0020 7C007680\[^\n\]*\n" { set x [expr $x+1] }
737 -re " +\[0-9\]+ 0024 7E407680\[^\n\]*\n" { set x [expr $x+1] }
738 -re " +\[0-9\]+ 0028 7788\[^\n\]*\n" { set x [expr $x+1] }
739 -re " +\[0-9\]+ 002a 7C007780\[^\n\]*\n" { set x [expr $x+1] }
740 -re " +\[0-9\]+ 002e 7E407780\[^\n\]*\n" { set x [expr $x+1] }
741 timeout { perror "timeout\n; break }
742 eof { break }
743 }
744 }
745
746 # This was intended to do any cleanup necessary. It kinda looks like it
747 # isn't needed, but just in case, please keep it in for now.
748 gas_finish
749
750 # Did we find what we were looking for? If not, flunk it.
751 if [expr $x == 15] then { pass $testname } else { fail $testname }
752}
753
754proc do_h8300h_bitops2 {} {
755 set testname "bitops2h.s: h8300h bitops tests #2"
756 set x 0
757
758 gas_start "bitops2h.s" "-al"
759
760 # Check each instruction bit pattern to verify it got
761 # assembled correctly.
762 while 1 {
763 expect {
764 -re " +\[0-9\]+ 0000 7488\[^\n\]*\n" { set x [expr $x+1] }
765 -re " +\[0-9\]+ 0002 7C007480\[^\n\]*\n" { set x [expr $x+1] }
766 -re " +\[0-9\]+ 0006 7E407480\[^\n\]*\n" { set x [expr $x+1] }
767 -re " +\[0-9\]+ 000a 6788\[^\n\]*\n" { set x [expr $x+1] }
768 -re " +\[0-9\]+ 000c 7D006780\[^\n\]*\n" { set x [expr $x+1] }
769 -re " +\[0-9\]+ 0010 7F406780\[^\n\]*\n" { set x [expr $x+1] }
770 -re " +\[0-9\]+ 0014 7588\[^\n\]*\n" { set x [expr $x+1] }
771 -re " +\[0-9\]+ 0016 7C007580\[^\n\]*\n" { set x [expr $x+1] }
772 -re " +\[0-9\]+ 001a 7E407580\[^\n\]*\n" { set x [expr $x+1] }
773 -re " +\[0-9\]+ 001e 7708\[^\n\]*\n" { set x [expr $x+1] }
774 -re " +\[0-9\]+ 0020 7C007700\[^\n\]*\n" { set x [expr $x+1] }
775 -re " +\[0-9\]+ 0024 7E407700\[^\n\]*\n" { set x [expr $x+1] }
776 timeout { perror "timeout\n; break }
777 eof { break }
778 }
779 }
780
781 # This was intended to do any cleanup necessary. It kinda looks like it
782 # isn't needed, but just in case, please keep it in for now.
783 gas_finish
784
785 # Did we find what we were looking for? If not, flunk it.
786 if [expr $x == 12] then { pass $testname } else { fail $testname }
787}
788
789proc do_h8300h_bitops3 {} {
790 set testname "bitops3h.s: h8300h bitops tests #3"
791 set x 0
792
793 gas_start "bitops3h.s" "-al"
794
795 # Check each instruction bit pattern to verify it got
796 # assembled correctly.
797 while 1 {
798 expect {
799 -re " +\[0-9\]+ 0000 7108\[^\n\]*\n" { set x [expr $x+1] }
800 -re " +\[0-9\]+ 0002 7D007100\[^\n\]*\n" { set x [expr $x+1] }
801 -re " +\[0-9\]+ 0006 7F407100\[^\n\]*\n" { set x [expr $x+1] }
802 -re " +\[0-9\]+ 000a 6198\[^\n\]*\n" { set x [expr $x+1] }
803 -re " +\[0-9\]+ 000c 7D006190\[^\n\]*\n" { set x [expr $x+1] }
804 -re " +\[0-9\]+ 0010 7F406190\[^\n\]*\n" { set x [expr $x+1] }
805 -re " +\[0-9\]+ 0014 7008\[^\n\]*\n" { set x [expr $x+1] }
806 -re " +\[0-9\]+ 0016 7D007000\[^\n\]*\n" { set x [expr $x+1] }
807 -re " +\[0-9\]+ 001a 7F407000\[^\n\]*\n" { set x [expr $x+1] }
808 -re " +\[0-9\]+ 001e 6098\[^\n\]*\n" { set x [expr $x+1] }
809 -re " +\[0-9\]+ 0020 7D006090\[^\n\]*\n" { set x [expr $x+1] }
810 -re " +\[0-9\]+ 0024 7F406090\[^\n\]*\n" { set x [expr $x+1] }
811 timeout { perror "timeout\n; break }
812 eof { break }
813 }
814 }
815
816 # This was intended to do any cleanup necessary. It kinda looks like it
817 # isn't needed, but just in case, please keep it in for now.
818 gas_finish
819
820 # Did we find what we were looking for? If not, flunk it.
821 if [expr $x == 12] then { pass $testname } else { fail $testname }
822}
823
824proc do_h8300h_bitops4 {} {
825 set testname "bitops4h.s: h8300h bitops tests #4"
826 set x 0
827
828 gas_start "bitops4h.s" "-al"
829
830 # Check each instruction bit pattern to verify it got
831 # assembled correctly.
832 while 1 {
833 expect {
834 -re " +\[0-9\]+ 0000 7408\[^\n\]*\n" { set x [expr $x+1] }
835 -re " +\[0-9\]+ 0002 7C007400\[^\n\]*\n" { set x [expr $x+1] }
836 -re " +\[0-9\]+ 0006 7E407400\[^\n\]*\n" { set x [expr $x+1] }
837 -re " +\[0-9\]+ 000a 6708\[^\n\]*\n" { set x [expr $x+1] }
838 -re " +\[0-9\]+ 000c 7D006700\[^\n\]*\n" { set x [expr $x+1] }
839 -re " +\[0-9\]+ 0010 7F406700\[^\n\]*\n" { set x [expr $x+1] }
840 -re " +\[0-9\]+ 0014 7308\[^\n\]*\n" { set x [expr $x+1] }
841 -re " +\[0-9\]+ 0016 7C007300\[^\n\]*\n" { set x [expr $x+1] }
842 -re " +\[0-9\]+ 001a 7E407300\[^\n\]*\n" { set x [expr $x+1] }
843 -re " +\[0-9\]+ 001e 6398\[^\n\]*\n" { set x [expr $x+1] }
844 -re " +\[0-9\]+ 0020 7C006390\[^\n\]*\n" { set x [expr $x+1] }
845 -re " +\[0-9\]+ 0024 7E406390\[^\n\]*\n" { set x [expr $x+1] }
846 -re " +\[0-9\]+ 0028 7508\[^\n\]*\n" { set x [expr $x+1] }
847 -re " +\[0-9\]+ 002a 7C007500\[^\n\]*\n" { set x [expr $x+1] }
848 -re " +\[0-9\]+ 002e 7E407500\[^\n\]*\n" { set x [expr $x+1] }
849 timeout { perror "timeout\n; break }
850 eof { break }
851 }
852 }
853
854 # This was intended to do any cleanup necessary. It kinda looks like it
855 # isn't needed, but just in case, please keep it in for now.
856 gas_finish
857
858 # Did we find what we were looking for? If not, flunk it.
859 if [expr $x == 15] then { pass $testname } else { fail $testname }
860}
861
862proc do_h8300h_branch {} {
863 set testname "branchh.s: h8300h branch tests"
864 set x 0
865
866 gas_start "branchh.s" "-al"
867
868 # Check each instruction bit pattern to verify it got
869 # assembled correctly.
870 while 1 {
871 expect {
872 -re " +\[0-9\]+ 0000 5500\[^\n\]*\n" { set x [expr $x+1] }
873 -re " +\[0-9\]+ 0002 5C000000\[^\n\]*\n" { set x [expr $x+1] }
874 -re " +\[0-9\]+ 0006 5A000000\[^\n\]*\n" { set x [expr $x+1] }
875 -re " +\[0-9\]+ 000a 5900\[^\n\]*\n" { set x [expr $x+1] }
876 -re " +\[0-9\]+ 000c 5B00\[^\n\]*\n" { set x [expr $x+1] }
877 -re " +\[0-9\]+ 000e 5E000000\[^\n\]*\n" { set x [expr $x+1] }
878 -re " +\[0-9\]+ 0012 5D00\[^\n\]*\n" { set x [expr $x+1] }
879 -re " +\[0-9\]+ 0014 5F00\[^\n\]*\n" { set x [expr $x+1] }
880 timeout { perror "timeout\n; break }
881 eof { break }
882 }
883 }
884
885 # This was intended to do any cleanup necessary. It kinda looks like it
886 # isn't needed, but just in case, please keep it in for now.
887 gas_finish
888
889 # Did we find what we were looking for? If not, flunk it.
890 if [expr $x == 8] then { pass $testname } else { fail $testname }
891}
892
893proc do_h8300h_compare {} {
894 set testname "compareh.s: h8300h compare tests"
895 set x 0
896
897 gas_start "compareh.s" "-al"
898
899 # Check each instruction bit pattern to verify it got
900 # assembled correctly.
901 while 1 {
902 expect {
903 -re " +\[0-9\]+ 0000 A800\[^\n\]*\n" { set x [expr $x+1] }
904 -re " +\[0-9\]+ 0002 1C08\[^\n\]*\n" { set x [expr $x+1] }
905 -re " +\[0-9\]+ 0004 79200020\[^\n\]*\n" { set x [expr $x+1] }
906 -re " +\[0-9\]+ 0008 1D01\[^\n\]*\n" { set x [expr $x+1] }
907 -re " +\[0-9\]+ 000a 7A200000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
908 -re " +\[0-9\]+ 0010 1F81\[^\n\]*\n" { set x [expr $x+1] }
909 timeout { perror "timeout\n; break }
910 eof { break }
911 }
912 }
913
914 # This was intended to do any cleanup necessary. It kinda looks like it
915 # isn't needed, but just in case, please keep it in for now.
916 gas_finish
917
918 # Did we find what we were looking for? If not, flunk it.
919 if [expr $x == 6] then { pass $testname } else { fail $testname }
920}
921
922proc do_h8300h_decimal {} {
923 set testname "decimalh.s: h8300h decimal tests"
924 set x 0
925
926 gas_start "decimalh.s" "-al"
927
928 # Check each instruction bit pattern to verify it got
929 # assembled correctly.
930 while 1 {
931 expect {
932 -re " +\[0-9\]+ 0000 0F08\[^\n\]*\n" { set x [expr $x+1] }
933 -re " +\[0-9\]+ 0002 1F08\[^\n\]*\n" { set x [expr $x+1] }
934 eof { break }
935 }
936 }
937
938 # This was intended to do any cleanup necessary. It kinda looks like it
939 # isn't needed, but just in case, please keep it in for now.
940 gas_finish
941
942 # Did we find what we were looking for? If not, flunk it.
943 if [expr $x == 2] then { pass $testname } else { fail $testname }
944}
945
946proc do_h8300h_incdec {} {
947 set testname "incdech.s: h8300h incdec tests"
948 set x 0
949
950 gas_start "incdech.s" "-al"
951
952 # Check each instruction bit pattern to verify it got
953 # assembled correctly.
954 while 1 {
955 expect {
956 -re " +\[0-9\]+ 0000 1A08\[^\n\]*\n" { set x [expr $x+1] }
957 -re " +\[0-9\]+ 0002 1B50\[^\n\]*\n" { set x [expr $x+1] }
958 -re " +\[0-9\]+ 0004 1BD0\[^\n\]*\n" { set x [expr $x+1] }
959 -re " +\[0-9\]+ 0006 1B70\[^\n\]*\n" { set x [expr $x+1] }
960 -re " +\[0-9\]+ 0008 1BF0\[^\n\]*\n" { set x [expr $x+1] }
961 -re " +\[0-9\]+ 000a 0A08\[^\n\]*\n" { set x [expr $x+1] }
962 -re " +\[0-9\]+ 000c 0B50\[^\n\]*\n" { set x [expr $x+1] }
963 -re " +\[0-9\]+ 000e 0BD0\[^\n\]*\n" { set x [expr $x+1] }
964 -re " +\[0-9\]+ 0010 0B70\[^\n\]*\n" { set x [expr $x+1] }
965 -re " +\[0-9\]+ 0012 0BF0\[^\n\]*\n" { set x [expr $x+1] }
966 eof { break }
967 }
968 }
969
970 # This was intended to do any cleanup necessary. It kinda looks like it
971 # isn't needed, but just in case, please keep it in for now.
972 gas_finish
973
974 # Did we find what we were looking for? If not, flunk it.
975 if [expr $x == 10] then { pass $testname } else { fail $testname }
976}
977
978proc do_h8300h_divmul {} {
979 set testname "divmulh.s: h8300h divmul tests"
980 set x 0
981
982 gas_start "divmulh.s" "-al"
983
984 # Check each instruction bit pattern to verify it got
985 # assembled correctly.
986 while 1 {
987 expect {
988 -re " +\[0-9\]+ 0000 5181\[^\n\]*\n" { set x [expr $x+1] }
989 -re " +\[0-9\]+ 0002 5301\[^\n\]*\n" { set x [expr $x+1] }
990 -re " +\[0-9\]+ 0004 01D05181\[^\n\]*\n" { set x [expr $x+1] }
991 -re " +\[0-9\]+ 0008 01D05301\[^\n\]*\n" { set x [expr $x+1] }
992 -re " +\[0-9\]+ 000c 5081\[^\n\]*\n" { set x [expr $x+1] }
993 -re " +\[0-9\]+ 000e 5201\[^\n\]*\n" { set x [expr $x+1] }
994 -re " +\[0-9\]+ 0010 01C05081\[^\n\]*\n" { set x [expr $x+1] }
995 -re " +\[0-9\]+ 0014 01C05201\[^\n\]*\n" { set x [expr $x+1] }
996 eof { break }
997 }
998 }
999
1000 # This was intended to do any cleanup necessary. It kinda looks like it
1001 # isn't needed, but just in case, please keep it in for now.
1002 gas_finish
1003
1004 # Did we find what we were looking for? If not, flunk it.
1005 if [expr $x == 8] then { pass $testname } else { fail $testname }
1006}
1007
1008proc do_h8300h_misc {} {
1009 set testname "misch.s: h8300h misc tests"
1010 set x 0
1011
1012 gas_start "misch.s" "-al"
1013
1014 # Check each instruction bit pattern to verify it got
1015 # assembled correctly.
1016 while 1 {
1017 expect {
1018 -re " +\[0-9\]+ 0000 7B5C598F\[^\n\]*\n" { set x [expr $x+1] }
1019 -re " +\[0-9\]+ 0004 7BD4598F\[^\n\]*\n" { set x [expr $x+1] }
1020 -re " +\[0-9\]+ 0008 0700\[^\n\]*\n" { set x [expr $x+1] }
1021 -re " +\[0-9\]+ 000a 0308\[^\n\]*\n" { set x [expr $x+1] }
1022 -re " +\[0-9\]+ 000c 01406900\[^\n\]*\n" { set x [expr $x+1] }
1023 -re " +\[0-9\]+ 0010 01406F00\[^\n\]*\n +\[0-9\]+ +0010\[^\n\]*\n" { set x [expr $x+1] }
1024 -re " +\[0-9\]+ 0016 01407800\[^\n\]*\n +\[0-9\]+ +6B200000\[^\n\]*\n +\[0-9\]+ +0020\[^\n\]*\n" { set x [expr $x+1] }
1025 -re " +\[0-9\]+ 0020 01406D00\[^\n\]*\n" { set x [expr $x+1] }
1026 -re " +\[0-9\]+ 0024 01406B00\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1027 -re " +\[0-9\]+ 002a 01406B20\[^\n\]*\n +\[0-9\]+ +00000000\[^\n\]*\n" { set x [expr $x+1] }
8fb49c3c
YS		 1028 -re " +\[0-9\]+ 0032 6A480010\[^\n\]*\n" { set x [expr $x+1] }
1029 -re " +\[0-9\]+ 0036 6AC80010\[^\n\]*\n" { set x [expr $x+1] }
1030 -re " +\[0-9\]+ 003a 0000\[^\n\]*\n" { set x [expr $x+1] }
1031 -re " +\[0-9\]+ 003c 5670\[^\n\]*\n" { set x [expr $x+1] }
1032 -re " +\[0-9\]+ 003e 5470\[^\n\]*\n" { set x [expr $x+1] }
1033 -re " +\[0-9\]+ 0040 0180\[^\n\]*\n" { set x [expr $x+1] }
1034 -re " +\[0-9\]+ 0042 0208\[^\n\]*\n" { set x [expr $x+1] }
1035 -re " +\[0-9\]+ 0044 01406980\[^\n\]*\n" { set x [expr $x+1] }
1036 -re " +\[0-9\]+ 0048 01406F80\[^\n\]*\n +\[0-9\]+ +0010\[^\n\]*\n" { set x [expr $x+1] }
1037 -re " +\[0-9\]+ 004e 01407800\[^\n\]*\n +\[0-9\]+ +6BA00000\[^\n\]*\n +\[0-9\]+ +0020\[^\n\]*\n" { set x [expr $x+1] }
1038 -re " +\[0-9\]+ 0058 01406D80\[^\n\]*\n" { set x [expr $x+1] }
1039 -re " +\[0-9\]+ 005c 01406B80\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1040 -re " +\[0-9\]+ 0062 01406BA0\[^\n\]*\n +\[0-9\]+ +00000000\[^\n\]*\n" { set x [expr $x+1] }
252b5132
RH		 1041 eof { break }
1042 }
1043 }
1044
1045 # This was intended to do any cleanup necessary. It kinda looks like it
1046 # isn't needed, but just in case, please keep it in for now.
1047 gas_finish
1048
1049 # Did we find what we were looking for? If not, flunk it.
8fb49c3c 1050 if [expr $x == 23] then { pass $testname } else { fail $testname }
252b5132 1051
252b5132
RH		 1052}
1053
1054proc do_h8300h_movb {} {
1055 set testname "movbh.s: h8300h movb tests"
1056 set x 0
1057
1058 gas_start "movbh.s" "-al"
1059
1060 # Check each instruction bit pattern to verify it got
1061 # assembled correctly.
1062 while 1 {
1063 expect {
1064 -re " +\[0-9\]+ 0000 0C89\[^\n\]*\n" { set x [expr $x+1] }
1065 -re " +\[0-9\]+ 0002 F810\[^\n\]*\n" { set x [expr $x+1] }
1066 -re " +\[0-9\]+ 0004 6818\[^\n\]*\n" { set x [expr $x+1] }
1067 -re " +\[0-9\]+ 0006 6E180010\[^\n\]*\n" { set x [expr $x+1] }
1068 -re " +\[0-9\]+ 000a 78106A28\[^\n\]*\n +\[0-9\]+ +00000020\[^\n\]*\n" { set x [expr $x+1] }
1069 -re " +\[0-9\]+ 0012 6C18\[^\n\]*\n" { set x [expr $x+1] }
1070 -re " +\[0-9\]+ 0014 2810\[^\n\]*\n" { set x [expr $x+1] }
1071 -re " +\[0-9\]+ 0016 6A080000\[^\n\]*\n" { set x [expr $x+1] }
1072 -re " +\[0-9\]+ 001a 6A280000\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1073 -re " +\[0-9\]+ 0020 6898\[^\n\]*\n" { set x [expr $x+1] }
1074 -re " +\[0-9\]+ 0022 6E980010\[^\n\]*\n" { set x [expr $x+1] }
1075 -re " +\[0-9\]+ 0026 78106AA8\[^\n\]*\n +\[0-9\]+ +00000020\[^\n\]*\n" { set x [expr $x+1] }
1076 -re " +\[0-9\]+ 002e 6C98\[^\n\]*\n" { set x [expr $x+1] }
1077 -re " +\[0-9\]+ 0030 3810\[^\n\]*\n" { set x [expr $x+1] }
1078 -re " +\[0-9\]+ 0032 6A880000\[^\n\]*\n" { set x [expr $x+1] }
1079 -re " +\[0-9\]+ 0036 6AA80000\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1080 eof { break }
1081 }
1082 }
1083
1084 # This was intended to do any cleanup necessary. It kinda looks like it
1085 # isn't needed, but just in case, please keep it in for now.
1086 gas_finish
1087
1088 # Did we find what we were looking for? If not, flunk it.
1089 if [expr $x == 16] then { pass $testname } else { fail $testname }
1090}
1091
1092proc do_h8300h_movw {} {
1093 set testname "movwh.s: h8300h movw tests"
1094 set x 0
1095
1096 gas_start "movwh.s" "-al"
1097
1098 # Check each instruction bit pattern to verify it got
1099 # assembled correctly.
1100 while 1 {
1101 expect {
1102 -re " +\[0-9\]+ 0000 0D01\[^\n\]*\n" { set x [expr $x+1] }
1103 -re " +\[0-9\]+ 0002 79000010\[^\n\]*\n" { set x [expr $x+1] }
1104 -re " +\[0-9\]+ 0006 6910\[^\n\]*\n" { set x [expr $x+1] }
1105 -re " +\[0-9\]+ 0008 6F100010\[^\n\]*\n" { set x [expr $x+1] }
1106 -re " +\[0-9\]+ 000c 78106B20\[^\n\]*\n +\[0-9\]+ +00000020\[^\n\]*\n" { set x [expr $x+1] }
1107 -re " +\[0-9\]+ 0014 6D10\[^\n\]*\n" { set x [expr $x+1] }
1108 -re " +\[0-9\]+ 0016 6B000000\[^\n\]*\n" { set x [expr $x+1] }
1109 -re " +\[0-9\]+ 001a 6B200000\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1110 -re " +\[0-9\]+ 0020 6990\[^\n\]*\n" { set x [expr $x+1] }
1111 -re " +\[0-9\]+ 0022 6F900010\[^\n\]*\n" { set x [expr $x+1] }
1112 -re " +\[0-9\]+ 0026 78106BA0\[^\n\]*\n +\[0-9\]+ +00000020\[^\n\]*\n" { set x [expr $x+1] }
1113 -re " +\[0-9\]+ 002e 6D90\[^\n\]*\n" { set x [expr $x+1] }
1114 -re " +\[0-9\]+ 0030 6B800000\[^\n\]*\n" { set x [expr $x+1] }
1115 -re " +\[0-9\]+ 0034 6BA00000\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1116 eof { break }
1117 }
1118 }
1119
1120 # This was intended to do any cleanup necessary. It kinda looks like it
1121 # isn't needed, but just in case, please keep it in for now.
1122 gas_finish
1123
1124 # Did we find what we were looking for? If not, flunk it.
1125 if [expr $x == 14] then { pass $testname } else { fail $testname }
1126}
1127
1128proc do_h8300h_movl {} {
1129 set testname "movlh.s: h8300h movl tests"
1130 set x 0
1131
1132 gas_start "movlh.s" "-al"
1133
1134 # Check each instruction bit pattern to verify it got
1135 # assembled correctly.
1136 while 1 {
1137 expect {
1138 -re " +\[0-9\]+ 0000 0F81\[^\n\]*\n" { set x [expr $x+1] }
1139 -re " +\[0-9\]+ 0002 7A000000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
1140 -re " +\[0-9\]+ 0008 01006910\[^\n\]*\n" { set x [expr $x+1] }
1141 -re " +\[0-9\]+ 000c 01006F10\[^\n\]*\n +\[0-9\]+ +0010\[^\n\]*\n" { set x [expr $x+1] }
1142 -re " +\[0-9\]+ 0012 01007810\[^\n\]*\n +\[0-9\]+ +6B200000\[^\n\]*\n +\[0-9\]+ +0020\[^\n\]*\n" { set x [expr $x+1] }
1143 -re " +\[0-9\]+ 001c 01006D10\[^\n\]*\n" { set x [expr $x+1] }
1144 -re " +\[0-9\]+ 0020 01006B00\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1145 -re " +\[0-9\]+ 0026 01006B20\[^\n\]*\n +\[0-9\]+ +00000000\[^\n\]*\n" { set x [expr $x+1] }
1146 -re " +\[0-9\]+ 002e 01006990\[^\n\]*\n" { set x [expr $x+1] }
1147 -re " +\[0-9\]+ 0032 01006F90\[^\n\]*\n +\[0-9\]+ +0010\[^\n\]*\n" { set x [expr $x+1] }
1148 -re " +\[0-9\]+ 0038 01007890\[^\n\]*\n +\[0-9\]+ +6BA00000\[^\n\]*\n +\[0-9\]+ +0020\[^\n\]*\n" { set x [expr $x+1] }
1149 -re " +\[0-9\]+ 0042 01006D90\[^\n\]*\n" { set x [expr $x+1] }
1150 -re " +\[0-9\]+ 0046 01006B80\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1151 -re " +\[0-9\]+ 004c 01006BA0\[^\n\]*\n +\[0-9\]+ +00000000\[^\n\]*\n" { set x [expr $x+1] }
1152 eof { break }
1153 }
1154 }
1155
1156 # This was intended to do any cleanup necessary. It kinda looks like it
1157 # isn't needed, but just in case, please keep it in for now.
1158 gas_finish
1159
1160 # Did we find what we were looking for? If not, flunk it.
1161 if [expr $x == 14] then { pass $testname } else { fail $testname }
1162}
1163
1164proc do_h8300h_pushpop {} {
1165 set testname "pushpoph.s: h8300h pushpop tests"
1166 set x 0
1167
1168 gas_start "pushpoph.s" "-al"
1169
1170 # Check each instruction bit pattern to verify it got
1171 # assembled correctly.
1172 while 1 {
1173 expect {
1174 -re " +\[0-9\]+ 0000 6D70\[^\n\]*\n" { set x [expr $x+1] }
1175 -re " +\[0-9\]+ 0002 01006D70\[^\n\]*\n" { set x [expr $x+1] }
1176 -re " +\[0-9\]+ 0006 6DF0\[^\n\]*\n" { set x [expr $x+1] }
1177 -re " +\[0-9\]+ 0008 01006DF0\[^\n\]*\n" { set x [expr $x+1] }
1178 eof { break }
1179 }
1180 }
1181
1182 # This was intended to do any cleanup necessary. It kinda looks like it
1183 # isn't needed, but just in case, please keep it in for now.
1184 gas_finish
1185
1186 # Did we find what we were looking for? If not, flunk it.
1187 if [expr $x == 4] then { pass $testname } else { fail $testname }
1188}
1189
1190proc do_h8300h_rotate_shift {} {
1191 set testname "rotshh.s: h8300h rotate and shift tests"
1192 set x 0
1193
1194 gas_start "rotshh.s" "-al"
1195
1196 # Check each instruction bit pattern to verify it got
1197 # assembled correctly.
1198 while 1 {
1199 expect {
1200 -re " +\[0-9\]+ 0000 1288\[^\n\]*\n" { set x [expr $x+1] }
1201 -re " +\[0-9\]+ 0002 1290\[^\n\]*\n" { set x [expr $x+1] }
1202 -re " +\[0-9\]+ 0004 12B0\[^\n\]*\n" { set x [expr $x+1] }
1203 -re " +\[0-9\]+ 0006 1388\[^\n\]*\n" { set x [expr $x+1] }
1204 -re " +\[0-9\]+ 0008 1390\[^\n\]*\n" { set x [expr $x+1] }
1205 -re " +\[0-9\]+ 000a 13B0\[^\n\]*\n" { set x [expr $x+1] }
1206 -re " +\[0-9\]+ 000c 1208\[^\n\]*\n" { set x [expr $x+1] }
1207 -re " +\[0-9\]+ 000e 1210\[^\n\]*\n" { set x [expr $x+1] }
1208 -re " +\[0-9\]+ 0010 1230\[^\n\]*\n" { set x [expr $x+1] }
1209 -re " +\[0-9\]+ 0012 1308\[^\n\]*\n" { set x [expr $x+1] }
1210 -re " +\[0-9\]+ 0014 1310\[^\n\]*\n" { set x [expr $x+1] }
1211 -re " +\[0-9\]+ 0016 1330\[^\n\]*\n" { set x [expr $x+1] }
1212 -re " +\[0-9\]+ 0018 1088\[^\n\]*\n" { set x [expr $x+1] }
1213 -re " +\[0-9\]+ 001a 1090\[^\n\]*\n" { set x [expr $x+1] }
1214 -re " +\[0-9\]+ 001c 10B0\[^\n\]*\n" { set x [expr $x+1] }
1215 -re " +\[0-9\]+ 001e 1188\[^\n\]*\n" { set x [expr $x+1] }
1216 -re " +\[0-9\]+ 0020 1190\[^\n\]*\n" { set x [expr $x+1] }
1217 -re " +\[0-9\]+ 0022 11B0\[^\n\]*\n" { set x [expr $x+1] }
1218 -re " +\[0-9\]+ 0024 1008\[^\n\]*\n" { set x [expr $x+1] }
1219 -re " +\[0-9\]+ 0026 1010\[^\n\]*\n" { set x [expr $x+1] }
1220 -re " +\[0-9\]+ 0028 1030\[^\n\]*\n" { set x [expr $x+1] }
1221 -re " +\[0-9\]+ 002a 1108\[^\n\]*\n" { set x [expr $x+1] }
1222 -re " +\[0-9\]+ 002c 1110\[^\n\]*\n" { set x [expr $x+1] }
1223 -re " +\[0-9\]+ 002e 1130\[^\n\]*\n" { set x [expr $x+1] }
1224 eof { break }
1225 }
1226 }
1227
1228 # This was intended to do any cleanup necessary. It kinda looks like it
1229 # isn't needed, but just in case, please keep it in for now.
1230 gas_finish
1231
1232 # Did we find what we were looking for? If not, flunk it.
1233 if [expr $x == 24] then { pass $testname } else { fail $testname }
1234}
1235
1236proc do_h8300h_extend {} {
1237 set testname "extendh.s: h8300h extend tests"
1238 set x 0
1239
1240 gas_start "extendh.s" "-al"
1241
1242 # Check each instruction bit pattern to verify it got
1243 # assembled correctly.
1244 while 1 {
1245 expect {
1246 -re " +\[0-9\]+ 0000 17D0\[^\n\]*\n" { set x [expr $x+1] }
1247 -re " +\[0-9\]+ 0002 17F0\[^\n\]*\n" { set x [expr $x+1] }
1248 -re " +\[0-9\]+ 0004 1750\[^\n\]*\n" { set x [expr $x+1] }
1249 -re " +\[0-9\]+ 0006 1770\[^\n\]*\n" { set x [expr $x+1] }
1250 eof { break }
1251 }
1252 }
1253
1254 # This was intended to do any cleanup necessary. It kinda looks like it
1255 # isn't needed, but just in case, please keep it in for now.
1256 gas_finish
1257
1258 # Did we find what we were looking for? If not, flunk it.
1259 if [expr $x == 4] then { pass $testname } else { fail $testname }
1260}
1261
1262proc do_h8300s_add_sub {} {
1263 set testname "addsubs.s: h8300s add/sub tests"
1264 set x 0
1265
1266 gas_start "addsubs.s" "-al"
1267
1268 # Check each instruction bit pattern to verify it got
1269 # assembled correctly.
1270 while 1 {
1271 expect {
1272 -re " +\[0-9\]+ 0000 8910\[^\n\]*\n" { set x [expr $x+1] }
1273 -re " +\[0-9\]+ 0002 0819\[^\n\]*\n" { set x [expr $x+1] }
1274 -re " +\[0-9\]+ 0004 79110020\[^\n\]*\n" { set x [expr $x+1] }
1275 -re " +\[0-9\]+ 0008 0912\[^\n\]*\n" { set x [expr $x+1] }
1276 -re " +\[0-9\]+ 000a 7A110000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
1277 -re " +\[0-9\]+ 0010 0A92\[^\n\]*\n" { set x [expr $x+1] }
1278 -re " +\[0-9\]+ 0012 0B04\[^\n\]*\n" { set x [expr $x+1] }
1279 -re " +\[0-9\]+ 0014 0B85\[^\n\]*\n" { set x [expr $x+1] }
1280 -re " +\[0-9\]+ 0016 0B96\[^\n\]*\n" { set x [expr $x+1] }
1281 -re " +\[0-9\]+ 0018 0E89\[^\n\]*\n" { set x [expr $x+1] }
1282 -re " +\[0-9\]+ 001a 9210\[^\n\]*\n" { set x [expr $x+1] }
1283 -re " +\[0-9\]+ 001c 1889\[^\n\]*\n" { set x [expr $x+1] }
1284 -re " +\[0-9\]+ 001e 79310010\[^\n\]*\n" { set x [expr $x+1] }
1285 -re " +\[0-9\]+ 0022 1901\[^\n\]*\n" { set x [expr $x+1] }
1286 -re " +\[0-9\]+ 0024 7A310000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
1287 -re " +\[0-9\]+ 002a 1A92\[^\n\]*\n" { set x [expr $x+1] }
1288 -re " +\[0-9\]+ 002c 1B04\[^\n\]*\n" { set x [expr $x+1] }
1289 -re " +\[0-9\]+ 002e 1B85\[^\n\]*\n" { set x [expr $x+1] }
1290 -re " +\[0-9\]+ 0030 1B96\[^\n\]*\n" { set x [expr $x+1] }
1291 -re " +\[0-9\]+ 0032 1E89\[^\n\]*\n" { set x [expr $x+1] }
1292 -re " +\[0-9\]+ 0034 B210\[^\n\]*\n" { set x [expr $x+1] }
1293 timeout { perror "timeout\n; break }
1294 eof { break }
1295 }
1296 }
1297
1298 # This was intended to do any cleanup necessary. It kinda looks like it
1299 # isn't needed, but just in case, please keep it in for now.
1300 gas_finish
1301
1302 # Did we find what we were looking for? If not, flunk it.
1303 if [expr $x == 21] then { pass $testname } else { fail $testname }
1304}
1305
1306proc do_h8300s_logical {} {
1307 set testname "logicals.s: h8300s logical tests"
1308 set x 0
1309
1310 gas_start "logicals.s" "-al"
1311
1312 # Check each instruction bit pattern to verify it got
1313 # assembled correctly.
1314 while 1 {
1315 expect {
1316 -re " +\[0-9\]+ 0000 E910\[^\n\]*\n" { set x [expr $x+1] }
1317 -re " +\[0-9\]+ 0002 1691\[^\n\]*\n" { set x [expr $x+1] }
1318 -re " +\[0-9\]+ 0004 79610020\[^\n\]*\n" { set x [expr $x+1] }
1319 -re " +\[0-9\]+ 0008 6611\[^\n\]*\n" { set x [expr $x+1] }
1320 -re " +\[0-9\]+ 000a 7A610000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
1321 -re " +\[0-9\]+ 0010 01F06611\[^\n\]*\n" { set x [expr $x+1] }
1322 -re " +\[0-9\]+ 0014 0610\[^\n\]*\n" { set x [expr $x+1] }
1323 -re " +\[0-9\]+ 0016 01410610\[^\n\]*\n" { set x [expr $x+1] }
1324 -re " +\[0-9\]+ 001a C810\[^\n\]*\n" { set x [expr $x+1] }
1325 -re " +\[0-9\]+ 001c 1498\[^\n\]*\n" { set x [expr $x+1] }
1326 -re " +\[0-9\]+ 001e 79410020\[^\n\]*\n" { set x [expr $x+1] }
1327 -re " +\[0-9\]+ 0022 6411\[^\n\]*\n" { set x [expr $x+1] }
1328 -re " +\[0-9\]+ 0024 7A410000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
1329 -re " +\[0-9\]+ 002a 01F06411\[^\n\]*\n" { set x [expr $x+1] }
1330 -re " +\[0-9\]+ 002e 0410\[^\n\]*\n" { set x [expr $x+1] }
1331 -re " +\[0-9\]+ 0030 01410410\[^\n\]*\n" { set x [expr $x+1] }
1332
1333 -re " +\[0-9\]+ 0034 D810\[^\n\]*\n" { set x [expr $x+1] }
1334 -re " +\[0-9\]+ 0036 1589\[^\n\]*\n" { set x [expr $x+1] }
1335 -re " +\[0-9\]+ 0038 79510020\[^\n\]*\n" { set x [expr $x+1] }
1336 -re " +\[0-9\]+ 003c 6511\[^\n\]*\n" { set x [expr $x+1] }
1337 -re " +\[0-9\]+ 003e 7A510000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
1338 -re " +\[0-9\]+ 0044 01F06511\[^\n\]*\n" { set x [expr $x+1] }
1339 -re " +\[0-9\]+ 0048 0510\[^\n\]*\n" { set x [expr $x+1] }
1340 -re " +\[0-9\]+ 004a 01410510\[^\n\]*\n" { set x [expr $x+1] }
1341 -re " +\[0-9\]+ 004e 1788\[^\n\]*\n" { set x [expr $x+1] }
1342 -re " +\[0-9\]+ 0050 1790\[^\n\]*\n" { set x [expr $x+1] }
1343 -re " +\[0-9\]+ 0052 17B0\[^\n\]*\n" { set x [expr $x+1] }
1344 -re " +\[0-9\]+ 0054 1708\[^\n\]*\n" { set x [expr $x+1] }
1345 -re " +\[0-9\]+ 0056 1710\[^\n\]*\n" { set x [expr $x+1] }
1346 -re " +\[0-9\]+ 0058 1730\[^\n\]*\n" { set x [expr $x+1] }
1347 timeout { perror "timeout\n; break }
1348 eof { break }
1349 }
1350 }
1351
1352 # This was intended to do any cleanup necessary. It kinda looks like it
1353 # isn't needed, but just in case, please keep it in for now.
1354 gas_finish
1355
1356 # Did we find what we were looking for? If not, flunk it.
1357 if [expr $x == 30] then { pass $testname } else { fail $testname }
1358}
1359
1360proc do_h8300s_cbranch {} {
1361 set testname "cbranchs.s: h8300s conditional branch tests"
1362 set x 0
1363
1364 gas_start "cbranchs.s" "-al"
1365
1366 # Check each instruction bit pattern to verify it got
1367 # assembled correctly.
1368 while 1 {
1369 expect {
1370 -re " +\[0-9\]+ 0000 4000\[^\n\]*\n" { set x [expr $x+1] }
1371 -re " +\[0-9\]+ 0002 4000\[^\n\]*\n" { set x [expr $x+1] }
1372 -re " +\[0-9\]+ 0004 4100\[^\n\]*\n" { set x [expr $x+1] }
1373 -re " +\[0-9\]+ 0006 4100\[^\n\]*\n" { set x [expr $x+1] }
1374 -re " +\[0-9\]+ 0008 4200\[^\n\]*\n" { set x [expr $x+1] }
1375 -re " +\[0-9\]+ 000a 4300\[^\n\]*\n" { set x [expr $x+1] }
1376 -re " +\[0-9\]+ 000c 4400\[^\n\]*\n" { set x [expr $x+1] }
1377 -re " +\[0-9\]+ 000e 4400\[^\n\]*\n" { set x [expr $x+1] }
1378 -re " +\[0-9\]+ 0010 4500\[^\n\]*\n" { set x [expr $x+1] }
1379 -re " +\[0-9\]+ 0012 4500\[^\n\]*\n" { set x [expr $x+1] }
1380 -re " +\[0-9\]+ 0014 4600\[^\n\]*\n" { set x [expr $x+1] }
1381 -re " +\[0-9\]+ 0016 4700\[^\n\]*\n" { set x [expr $x+1] }
1382 -re " +\[0-9\]+ 0018 4800\[^\n\]*\n" { set x [expr $x+1] }
1383 -re " +\[0-9\]+ 001a 4900\[^\n\]*\n" { set x [expr $x+1] }
1384 -re " +\[0-9\]+ 001c 4A00\[^\n\]*\n" { set x [expr $x+1] }
1385 -re " +\[0-9\]+ 001e 4B00\[^\n\]*\n" { set x [expr $x+1] }
1386 -re " +\[0-9\]+ 0020 4C00\[^\n\]*\n" { set x [expr $x+1] }
1387 -re " +\[0-9\]+ 0022 4D00\[^\n\]*\n" { set x [expr $x+1] }
1388 -re " +\[0-9\]+ 0024 4E00\[^\n\]*\n" { set x [expr $x+1] }
1389 -re " +\[0-9\]+ 0026 4F00\[^\n\]*\n" { set x [expr $x+1] }
1390 -re " +\[0-9\]+ 0028 58000000\[^\n\]*\n" { set x [expr $x+1] }
1391 -re " +\[0-9\]+ 002c 58000000\[^\n\]*\n" { set x [expr $x+1] }
1392 -re " +\[0-9\]+ 0030 58100000\[^\n\]*\n" { set x [expr $x+1] }
1393 -re " +\[0-9\]+ 0034 58100000\[^\n\]*\n" { set x [expr $x+1] }
1394 -re " +\[0-9\]+ 0038 58200000\[^\n\]*\n" { set x [expr $x+1] }
1395 -re " +\[0-9\]+ 003c 58300000\[^\n\]*\n" { set x [expr $x+1] }
1396 -re " +\[0-9\]+ 0040 58400000\[^\n\]*\n" { set x [expr $x+1] }
1397 -re " +\[0-9\]+ 0044 58400000\[^\n\]*\n" { set x [expr $x+1] }
1398 -re " +\[0-9\]+ 0048 58500000\[^\n\]*\n" { set x [expr $x+1] }
1399 -re " +\[0-9\]+ 004c 58500000\[^\n\]*\n" { set x [expr $x+1] }
1400 -re " +\[0-9\]+ 0050 58600000\[^\n\]*\n" { set x [expr $x+1] }
1401 -re " +\[0-9\]+ 0054 58700000\[^\n\]*\n" { set x [expr $x+1] }
1402 -re " +\[0-9\]+ 0058 58800000\[^\n\]*\n" { set x [expr $x+1] }
1403 -re " +\[0-9\]+ 005c 58900000\[^\n\]*\n" { set x [expr $x+1] }
1404 -re " +\[0-9\]+ 0060 58A00000\[^\n\]*\n" { set x [expr $x+1] }
1405 -re " +\[0-9\]+ 0064 58B00000\[^\n\]*\n" { set x [expr $x+1] }
1406 -re " +\[0-9\]+ 0068 58C00000\[^\n\]*\n" { set x [expr $x+1] }
1407 -re " +\[0-9\]+ 006c 58D00000\[^\n\]*\n" { set x [expr $x+1] }
1408 -re " +\[0-9\]+ 0070 58E00000\[^\n\]*\n" { set x [expr $x+1] }
1409 -re " +\[0-9\]+ 0074 58F00000\[^\n\]*\n" { set x [expr $x+1] }
1410 timeout { perror "timeout\n; break }
1411 eof { break }
1412 }
1413 }
1414
1415 # This was intended to do any cleanup necessary. It kinda looks like it
1416 # isn't needed, but just in case, please keep it in for now.
1417 gas_finish
1418
1419 # Did we find what we were looking for? If not, flunk it.
1420 if [expr $x == 40] then { pass $testname } else { fail $testname }
1421}
1422proc do_h8300s_bitops1 {} {
1423 set testname "bitops1s.s: h8300s bitops tests #1"
1424 set x 0
1425
1426 gas_start "bitops1s.s" "-al"
1427
1428 # Check each instruction bit pattern to verify it got
1429 # assembled correctly.
1430 while 1 {
1431 expect {
1432 -re " +\[0-9\]+ 0000 7608\[^\n\]*\n" { set x [expr $x+1] }
1433 -re " +\[0-9\]+ 0002 7C007600\[^\n\]*\n" { set x [expr $x+1] }
1434 -re " +\[0-9\]+ 0006 7E407600\[^\n\]*\n" { set x [expr $x+1] }
1435 -re " +\[0-9\]+ 000a 6A100080\[^\n\]*\n +\[0-9\]+ +7600" { set x [expr $x+1] }
1436 -re " +\[0-9\]+ 0010 6A300001\[^\n\]*\n +\[0-9\]+ +00007600" { set x [expr $x+1] }
1437 -re " +\[0-9\]+ 0018 7208\[^\n\]*\n" { set x [expr $x+1] }
1438 -re " +\[0-9\]+ 001a 7D007200\[^\n\]*\n" { set x [expr $x+1] }
1439 -re " +\[0-9\]+ 001e 7F407200\[^\n\]*\n" { set x [expr $x+1] }
1440 -re " +\[0-9\]+ 0022 6A180080\[^\n\]*\n +\[0-9\]+ +7200" { set x [expr $x+1] }
1441 -re " +\[0-9\]+ 0028 6A380001\[^\n\]*\n +\[0-9\]+ +00007200" { set x [expr $x+1] }
1442 -re " +\[0-9\]+ 0030 6298\[^\n\]*\n" { set x [expr $x+1] }
1443 -re " +\[0-9\]+ 0032 7D006290\[^\n\]*\n" { set x [expr $x+1] }
1444 -re " +\[0-9\]+ 0036 7F406290\[^\n\]*\n" { set x [expr $x+1] }
1445 -re " +\[0-9\]+ 003a 6A180080\[^\n\]*\n +\[0-9\]+ +6290" { set x [expr $x+1] }
1446 -re " +\[0-9\]+ 0040 6A380001\[^\n\]*\n +\[0-9\]+ +00006290" { set x [expr $x+1] }
1447 -re " +\[0-9\]+ 0048 7688\[^\n\]*\n" { set x [expr $x+1] }
1448 -re " +\[0-9\]+ 004a 7C007680\[^\n\]*\n" { set x [expr $x+1] }
1449 -re " +\[0-9\]+ 004e 7E407680\[^\n\]*\n" { set x [expr $x+1] }
1450 -re " +\[0-9\]+ 0052 6A100080\[^\n\]*\n +\[0-9\]+ +7680" { set x [expr $x+1] }
1451 -re " +\[0-9\]+ 0058 6A300001\[^\n\]*\n +\[0-9\]+ +00007680" { set x [expr $x+1] }
1452 -re " +\[0-9\]+ 0060 7788\[^\n\]*\n" { set x [expr $x+1] }
1453 -re " +\[0-9\]+ 0062 7C007780\[^\n\]*\n" { set x [expr $x+1] }
1454 -re " +\[0-9\]+ 0066 7E407780\[^\n\]*\n" { set x [expr $x+1] }
1455 -re " +\[0-9\]+ 006a 6A100080\[^\n\]*\n +\[0-9\]+ +7780" { set x [expr $x+1] }
1456 -re " +\[0-9\]+ 0070 6A300001\[^\n\]*\n +\[0-9\]+ +00007780" { set x [expr $x+1] }
1457 timeout { perror "timeout\n; break }
1458 eof { break }
1459 }
1460 }
1461
1462 # This was intended to do any cleanup necessary. It kinda looks like it
1463 # isn't needed, but just in case, please keep it in for now.
1464 gas_finish
1465
1466 # Did we find what we were looking for? If not, flunk it.
1467 if [expr $x == 25] then { pass $testname } else { fail $testname }
1468}
1469
1470proc do_h8300s_bitops2 {} {
1471 set testname "bitops2s.s: h8300s bitops tests #2"
1472 set x 0
1473
1474 gas_start "bitops2s.s" "-al"
1475
1476 # Check each instruction bit pattern to verify it got
1477 # assembled correctly.
1478 while 1 {
1479 expect {
1480 -re " +\[0-9\]+ 0000 7488\[^\n\]*\n" { set x [expr $x+1] }
1481 -re " +\[0-9\]+ 0002 7C007480\[^\n\]*\n" { set x [expr $x+1] }
1482 -re " +\[0-9\]+ 0006 7E407480\[^\n\]*\n" { set x [expr $x+1] }
1483 -re " +\[0-9\]+ 000a 6A100080\[^\n\]*\n +\[0-9\]+ +7480" { set x [expr $x+1] }
1484 -re " +\[0-9\]+ 0010 6A300001\[^\n\]*\n +\[0-9\]+ +00007480" { set x [expr $x+1] }
1485 -re " +\[0-9\]+ 0018 6788\[^\n\]*\n" { set x [expr $x+1] }
1486 -re " +\[0-9\]+ 001a 7D006780\[^\n\]*\n" { set x [expr $x+1] }
1487 -re " +\[0-9\]+ 001e 7F406780\[^\n\]*\n" { set x [expr $x+1] }
1488 -re " +\[0-9\]+ 0022 6A180080\[^\n\]*\n +\[0-9\]+ +6780" { set x [expr $x+1] }
1489 -re " +\[0-9\]+ 0028 6A380001\[^\n\]*\n +\[0-9\]+ +00006780" { set x [expr $x+1] }
1490
1491 -re " +\[0-9\]+ 0030 7588\[^\n\]*\n" { set x [expr $x+1] }
1492 -re " +\[0-9\]+ 0032 7C007580\[^\n\]*\n" { set x [expr $x+1] }
1493 -re " +\[0-9\]+ 0036 7E407580\[^\n\]*\n" { set x [expr $x+1] }
1494 -re " +\[0-9\]+ 003a 6A100080\[^\n\]*\n +\[0-9\]+ +7580" { set x [expr $x+1] }
1495 -re " +\[0-9\]+ 0040 6A300001\[^\n\]*\n +\[0-9\]+ +00007580" { set x [expr $x+1] }
1496 -re " +\[0-9\]+ 0048 7708\[^\n\]*\n" { set x [expr $x+1] }
1497 -re " +\[0-9\]+ 004a 7C007700\[^\n\]*\n" { set x [expr $x+1] }
1498 -re " +\[0-9\]+ 004e 7E407700\[^\n\]*\n" { set x [expr $x+1] }
1499 -re " +\[0-9\]+ 0052 6A100080\[^\n\]*\n +\[0-9\]+ +7700" { set x [expr $x+1] }
1500 -re " +\[0-9\]+ 0058 6A300001\[^\n\]*\n +\[0-9\]+ +00007700" { set x [expr $x+1] }
1501 timeout { perror "timeout\n; break }
1502 eof { break }
1503 }
1504 }
1505
1506 # This was intended to do any cleanup necessary. It kinda looks like it
1507 # isn't needed, but just in case, please keep it in for now.
1508 gas_finish
1509
1510 # Did we find what we were looking for? If not, flunk it.
1511 if [expr $x == 20] then { pass $testname } else { fail $testname }
1512}
1513
1514proc do_h8300s_bitops3 {} {
1515 set testname "bitops3s.s: h8300s bitops tests #3"
1516 set x 0
1517
1518 gas_start "bitops3s.s" "-al"
1519
1520 # Check each instruction bit pattern to verify it got
1521 # assembled correctly.
1522 while 1 {
1523 expect {
1524 -re " +\[0-9\]+ 0000 7108\[^\n\]*\n" { set x [expr $x+1] }
1525 -re " +\[0-9\]+ 0002 7D007100\[^\n\]*\n" { set x [expr $x+1] }
1526 -re " +\[0-9\]+ 0006 7F407100\[^\n\]*\n" { set x [expr $x+1] }
1527 -re " +\[0-9\]+ 000a 6A180080\[^\n\]*\n +\[0-9\]+ +7100" { set x [expr $x+1] }
1528 -re " +\[0-9\]+ 0010 6A380001\[^\n\]*\n +\[0-9\]+ +00007100" { set x [expr $x+1] }
1529 -re " +\[0-9\]+ 0018 6198\[^\n\]*\n" { set x [expr $x+1] }
1530 -re " +\[0-9\]+ 001a 7D006190\[^\n\]*\n" { set x [expr $x+1] }
1531 -re " +\[0-9\]+ 001e 7F406190\[^\n\]*\n" { set x [expr $x+1] }
1532 -re " +\[0-9\]+ 0022 6A180080\[^\n\]*\n +\[0-9\]+ +6190" { set x [expr $x+1] }
1533 -re " +\[0-9\]+ 0028 6A380001\[^\n\]*\n +\[0-9\]+ +00006190" { set x [expr $x+1] }
1534 -re " +\[0-9\]+ 0030 7008\[^\n\]*\n" { set x [expr $x+1] }
1535 -re " +\[0-9\]+ 0032 7D007000\[^\n\]*\n" { set x [expr $x+1] }
1536 -re " +\[0-9\]+ 0036 7F407000\[^\n\]*\n" { set x [expr $x+1] }
1537 -re " +\[0-9\]+ 003a 6A180080\[^\n\]*\n +\[0-9\]+ +7000" { set x [expr $x+1] }
1538 -re " +\[0-9\]+ 0040 6A380001\[^\n\]*\n +\[0-9\]+ +00007000" { set x [expr $x+1] }
1539 -re " +\[0-9\]+ 0048 6098\[^\n\]*\n" { set x [expr $x+1] }
1540 -re " +\[0-9\]+ 004a 7D006090\[^\n\]*\n" { set x [expr $x+1] }
1541 -re " +\[0-9\]+ 004e 7F406090\[^\n\]*\n" { set x [expr $x+1] }
1542 -re " +\[0-9\]+ 0052 6A180080\[^\n\]*\n +\[0-9\]+ +6090" { set x [expr $x+1] }
1543 -re " +\[0-9\]+ 0058 6A380001\[^\n\]*\n +\[0-9\]+ +00006090" { set x [expr $x+1] }
1544 timeout { perror "timeout\n; break }
1545 eof { break }
1546 }
1547 }
1548
1549 # This was intended to do any cleanup necessary. It kinda looks like it
1550 # isn't needed, but just in case, please keep it in for now.
1551 gas_finish
1552
1553 # Did we find what we were looking for? If not, flunk it.
1554 if [expr $x == 20] then { pass $testname } else { fail $testname }
1555}
1556
1557proc do_h8300s_bitops4 {} {
1558 set testname "bitops4s.s: h8300s bitops tests #4"
1559 set x 0
1560
1561 gas_start "bitops4s.s" "-al"
1562
1563 # Check each instruction bit pattern to verify it got
1564 # assembled correctly.
1565 while 1 {
1566 expect {
1567 -re " +\[0-9\]+ 0000 7408\[^\n\]*\n" { set x [expr $x+1] }
1568 -re " +\[0-9\]+ 0002 7C007400\[^\n\]*\n" { set x [expr $x+1] }
1569 -re " +\[0-9\]+ 0006 7E407400\[^\n\]*\n" { set x [expr $x+1] }
1570 -re " +\[0-9\]+ 000a 6A100080\[^\n\]*\n +\[0-9\]+ +7400" { set x [expr $x+1] }
1571 -re " +\[0-9\]+ 0010 6A300001\[^\n\]*\n +\[0-9\]+ +00007400" { set x [expr $x+1] }
1572 -re " +\[0-9\]+ 0018 6708\[^\n\]*\n" { set x [expr $x+1] }
1573 -re " +\[0-9\]+ 001a 7D006700\[^\n\]*\n" { set x [expr $x+1] }
1574 -re " +\[0-9\]+ 001e 7F406700\[^\n\]*\n" { set x [expr $x+1] }
1575 -re " +\[0-9\]+ 0022 6A180080\[^\n\]*\n +\[0-9\]+ +6700" { set x [expr $x+1] }
1576 -re " +\[0-9\]+ 0028 6A380001\[^\n\]*\n +\[0-9\]+ +00006700" { set x [expr $x+1] }
1577 -re " +\[0-9\]+ 0030 7308\[^\n\]*\n" { set x [expr $x+1] }
1578 -re " +\[0-9\]+ 0032 7C007300\[^\n\]*\n" { set x [expr $x+1] }
1579 -re " +\[0-9\]+ 0036 7E407300\[^\n\]*\n" { set x [expr $x+1] }
1580 -re " +\[0-9\]+ 003a 6A100080\[^\n\]*\n +\[0-9\]+ +7300" { set x [expr $x+1] }
1581 -re " +\[0-9\]+ 0040 6A300001\[^\n\]*\n +\[0-9\]+ +00007300" { set x [expr $x+1] }
1582 -re " +\[0-9\]+ 0048 6398\[^\n\]*\n" { set x [expr $x+1] }
1583 -re " +\[0-9\]+ 004a 7C006390\[^\n\]*\n" { set x [expr $x+1] }
1584 -re " +\[0-9\]+ 004e 7E406390\[^\n\]*\n" { set x [expr $x+1] }
1585 -re " +\[0-9\]+ 0052 6A100080\[^\n\]*\n +\[0-9\]+ +6390" { set x [expr $x+1] }
1586 -re " +\[0-9\]+ 0058 6A300001\[^\n\]*\n +\[0-9\]+ +00006390" { set x [expr $x+1] }
1587 -re " +\[0-9\]+ 0060 7508\[^\n\]*\n" { set x [expr $x+1] }
1588 -re " +\[0-9\]+ 0062 7C007500\[^\n\]*\n" { set x [expr $x+1] }
1589 -re " +\[0-9\]+ 0066 7E407500\[^\n\]*\n" { set x [expr $x+1] }
1590 -re " +\[0-9\]+ 006a 6A100080\[^\n\]*\n +\[0-9\]+ +7500" { set x [expr $x+1] }
1591 -re " +\[0-9\]+ 0070 6A300001\[^\n\]*\n +\[0-9\]+ +00007500" { set x [expr $x+1] }
1592 timeout { perror "timeout\n; break }
1593 eof { break }
1594 }
1595 }
1596
1597 # This was intended to do any cleanup necessary. It kinda looks like it
1598 # isn't needed, but just in case, please keep it in for now.
1599 gas_finish
1600
1601 # Did we find what we were looking for? If not, flunk it.
1602 if [expr $x == 25] then { pass $testname } else { fail $testname }
1603}
1604
1605proc do_h8300s_branch {} {
1606 set testname "branchs.s: h8300s branch tests"
1607 set x 0
1608
1609 gas_start "branchs.s" "-al"
1610
1611 # Check each instruction bit pattern to verify it got
1612 # assembled correctly.
1613 while 1 {
1614 expect {
1615 -re " +\[0-9\]+ 0000 5500\[^\n\]*\n" { set x [expr $x+1] }
1616 -re " +\[0-9\]+ 0002 5C000000\[^\n\]*\n" { set x [expr $x+1] }
1617 -re " +\[0-9\]+ 0006 5A000000\[^\n\]*\n" { set x [expr $x+1] }
1618 -re " +\[0-9\]+ 000a 5900\[^\n\]*\n" { set x [expr $x+1] }
1619 -re " +\[0-9\]+ 000c 5B00\[^\n\]*\n" { set x [expr $x+1] }
1620 -re " +\[0-9\]+ 000e 5E000000\[^\n\]*\n" { set x [expr $x+1] }
1621 -re " +\[0-9\]+ 0012 5D00\[^\n\]*\n" { set x [expr $x+1] }
1622 -re " +\[0-9\]+ 0014 5F00\[^\n\]*\n" { set x [expr $x+1] }
1623 timeout { perror "timeout\n; break }
1624 eof { break }
1625 }
1626 }
1627
1628 # This was intended to do any cleanup necessary. It kinda looks like it
1629 # isn't needed, but just in case, please keep it in for now.
1630 gas_finish
1631
1632 # Did we find what we were looking for? If not, flunk it.
1633 if [expr $x == 8] then { pass $testname } else { fail $testname }
1634}
1635
1636proc do_h8300s_compare {} {
1637 set testname "compares.s: h8300s compare tests"
1638 set x 0
1639
1640 gas_start "compares.s" "-al"
1641
1642 # Check each instruction bit pattern to verify it got
1643 # assembled correctly.
1644 while 1 {
1645 expect {
1646 -re " +\[0-9\]+ 0000 A800\[^\n\]*\n" { set x [expr $x+1] }
1647 -re " +\[0-9\]+ 0002 1C08\[^\n\]*\n" { set x [expr $x+1] }
1648 -re " +\[0-9\]+ 0004 79200020\[^\n\]*\n" { set x [expr $x+1] }
1649 -re " +\[0-9\]+ 0008 1D01\[^\n\]*\n" { set x [expr $x+1] }
1650 -re " +\[0-9\]+ 000a 7A200000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
1651 -re " +\[0-9\]+ 0010 1F81\[^\n\]*\n" { set x [expr $x+1] }
1652 timeout { perror "timeout\n; break }
1653 eof { break }
1654 }
1655 }
1656
1657 # This was intended to do any cleanup necessary. It kinda looks like it
1658 # isn't needed, but just in case, please keep it in for now.
1659 gas_finish
1660
1661 # Did we find what we were looking for? If not, flunk it.
1662 if [expr $x == 6] then { pass $testname } else { fail $testname }
1663}
1664
1665proc do_h8300s_decimal {} {
1666 set testname "decimals.s: h8300s decimal tests"
1667 set x 0
1668
1669 gas_start "decimals.s" "-al"
1670
1671 # Check each instruction bit pattern to verify it got
1672 # assembled correctly.
1673 while 1 {
1674 expect {
1675 -re " +\[0-9\]+ 0000 0F08\[^\n\]*\n" { set x [expr $x+1] }
1676 -re " +\[0-9\]+ 0002 1F08\[^\n\]*\n" { set x [expr $x+1] }
1677 eof { break }
1678 }
1679 }
1680
1681 # This was intended to do any cleanup necessary. It kinda looks like it
1682 # isn't needed, but just in case, please keep it in for now.
1683 gas_finish
1684
1685 # Did we find what we were looking for? If not, flunk it.
1686 if [expr $x == 2] then { pass $testname } else { fail $testname }
1687}
1688
1689proc do_h8300s_incdec {} {
1690 set testname "incdecs.s: h8300s incdec tests"
1691 set x 0
1692
1693 gas_start "incdecs.s" "-al"
1694
1695 # Check each instruction bit pattern to verify it got
1696 # assembled correctly.
1697 while 1 {
1698 expect {
1699 -re " +\[0-9\]+ 0000 1A08\[^\n\]*\n" { set x [expr $x+1] }
1700 -re " +\[0-9\]+ 0002 1B50\[^\n\]*\n" { set x [expr $x+1] }
1701 -re " +\[0-9\]+ 0004 1BD0\[^\n\]*\n" { set x [expr $x+1] }
1702 -re " +\[0-9\]+ 0006 1B70\[^\n\]*\n" { set x [expr $x+1] }
1703 -re " +\[0-9\]+ 0008 1BF0\[^\n\]*\n" { set x [expr $x+1] }
1704 -re " +\[0-9\]+ 000a 0A08\[^\n\]*\n" { set x [expr $x+1] }
1705 -re " +\[0-9\]+ 000c 0B50\[^\n\]*\n" { set x [expr $x+1] }
1706 -re " +\[0-9\]+ 000e 0BD0\[^\n\]*\n" { set x [expr $x+1] }
1707 -re " +\[0-9\]+ 0010 0B70\[^\n\]*\n" { set x [expr $x+1] }
1708 -re " +\[0-9\]+ 0012 0BF0\[^\n\]*\n" { set x [expr $x+1] }
1709 eof { break }
1710 }
1711 }
1712
1713 # This was intended to do any cleanup necessary. It kinda looks like it
1714 # isn't needed, but just in case, please keep it in for now.
1715 gas_finish
1716
1717 # Did we find what we were looking for? If not, flunk it.
1718 if [expr $x == 10] then { pass $testname } else { fail $testname }
1719}
1720
1721proc do_h8300s_divmul {} {
1722 set testname "divmuls.s: h8300s divmul tests"
1723 set x 0
1724
1725 gas_start "divmuls.s" "-al"
1726
1727 # Check each instruction bit pattern to verify it got
1728 # assembled correctly.
1729 while 1 {
1730 expect {
1731 -re " +\[0-9\]+ 0000 5181\[^\n\]*\n" { set x [expr $x+1] }
1732 -re " +\[0-9\]+ 0002 5301\[^\n\]*\n" { set x [expr $x+1] }
1733 -re " +\[0-9\]+ 0004 01D05181\[^\n\]*\n" { set x [expr $x+1] }
1734 -re " +\[0-9\]+ 0008 01D05301\[^\n\]*\n" { set x [expr $x+1] }
1735 -re " +\[0-9\]+ 000c 5081\[^\n\]*\n" { set x [expr $x+1] }
1736 -re " +\[0-9\]+ 000e 5201\[^\n\]*\n" { set x [expr $x+1] }
1737 -re " +\[0-9\]+ 0010 01C05081\[^\n\]*\n" { set x [expr $x+1] }
1738 -re " +\[0-9\]+ 0014 01C05201\[^\n\]*\n" { set x [expr $x+1] }
1739 eof { break }
1740 }
1741 }
1742
1743 # This was intended to do any cleanup necessary. It kinda looks like it
1744 # isn't needed, but just in case, please keep it in for now.
1745 gas_finish
1746
1747 # Did we find what we were looking for? If not, flunk it.
1748 if [expr $x == 8] then { pass $testname } else { fail $testname }
1749}
1750
1751proc do_h8300s_misc {} {
1752 set testname "miscs.s: h8300s misc tests"
1753 set x 0
1754
1755 gas_start "miscs.s" "-al"
1756
1757 # Check each instruction bit pattern to verify it got
1758 # assembled correctly.
1759 while 1 {
1760 expect {
1761 -re " +\[0-9\]+ 0000 7B5C598F\[^\n\]*\n" { set x [expr $x+1] }
1762 -re " +\[0-9\]+ 0004 7BD4598F\[^\n\]*\n" { set x [expr $x+1] }
1763 -re " +\[0-9\]+ 0008 0700\[^\n\]*\n" { set x [expr $x+1] }
1764 -re " +\[0-9\]+ 000a 0308\[^\n\]*\n" { set x [expr $x+1] }
1765 -re " +\[0-9\]+ 000c 01410700\[^\n\]*\n" { set x [expr $x+1] }
1766 -re " +\[0-9\]+ 0010 0318\[^\n\]*\n" { set x [expr $x+1] }
1767 -re " +\[0-9\]+ 0012 01406900\[^\n\]*\n" { set x [expr $x+1] }
1768 -re " +\[0-9\]+ 0016 01406F00\[^\n\]*\n +\[0-9\]+ +0010\[^\n\]*\n" { set x [expr $x+1] }
1769 -re " +\[0-9\]+ 001c 01407800\[^\n\]*\n +\[0-9\]+ +6B200000\[^\n\]*\n +\[0-9\]+ +0020\[^\n\]*\n" { set x [expr $x+1] }
1770 -re " +\[0-9\]+ 0026 01406D00\[^\n\]*\n" { set x [expr $x+1] }
1771 -re " +\[0-9\]+ 002a 01406B00\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1772 -re " +\[0-9\]+ 0030 01406B20\[^\n\]*\n +\[0-9\]+ +00000000\[^\n\]*\n" { set x [expr $x+1] }
1773 -re " +\[0-9\]+ 0038 01416900\[^\n\]*\n" { set x [expr $x+1] }
1774 -re " +\[0-9\]+ 003c 01416F00\[^\n\]*\n +\[0-9\]+ +0010\[^\n\]*\n" { set x [expr $x+1] }
1775 -re " +\[0-9\]+ 0042 01417800\[^\n\]*\n +\[0-9\]+ +6B200000\[^\n\]*\n +\[0-9\]+ +0020\[^\n\]*\n" { set x [expr $x+1] }
1776 -re " +\[0-9\]+ 004c 01416D00\[^\n\]*\n" { set x [expr $x+1] }
1777 -re " +\[0-9\]+ 0050 01416B00\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1778 -re " +\[0-9\]+ 0056 01416B20\[^\n\]*\n +\[0-9\]+ +00000000\[^\n\]*\n" { set x [expr $x+1] }
8fb49c3c
YS		 1779 -re " +\[0-9\]+ 005e 6A480010\[^\n\]*\n" { set x [expr $x+1] }
1780 -re " +\[0-9\]+ 0062 6AC80010\[^\n\]*\n" { set x [expr $x+1] }
1781 -re " +\[0-9\]+ 0066 0000\[^\n\]*\n" { set x [expr $x+1] }
1782 -re " +\[0-9\]+ 0068 5670\[^\n\]*\n" { set x [expr $x+1] }
1783 -re " +\[0-9\]+ 006a 5470\[^\n\]*\n" { set x [expr $x+1] }
1784 -re " +\[0-9\]+ 006c 0180\[^\n\]*\n" { set x [expr $x+1] }
1785 -re " +\[0-9\]+ 006e 0208\[^\n\]*\n" { set x [expr $x+1] }
1786 -re " +\[0-9\]+ 0070 0218\[^\n\]*\n" { set x [expr $x+1] }
1787 -re " +\[0-9\]+ 0072 01406980\[^\n\]*\n" { set x [expr $x+1] }
1788 -re " +\[0-9\]+ 0076 01406F80\[^\n\]*\n +\[0-9\]+ +0010\[^\n\]*\n" { set x [expr $x+1] }
1789 -re " +\[0-9\]+ 007c 01407800\[^\n\]*\n +\[0-9\]+ +6BA00000\[^\n\]*\n +\[0-9\]+ +0020\[^\n\]*\n" { set x [expr $x+1] }
1790 -re " +\[0-9\]+ 0086 01406D80\[^\n\]*\n" { set x [expr $x+1] }
1791 -re " +\[0-9\]+ 008a 01406B80\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1792 -re " +\[0-9\]+ 0090 01406BA0\[^\n\]*\n +\[0-9\]+ +00000000\[^\n\]*\n" { set x [expr $x+1] }
1793 -re " +\[0-9\]+ 0098 01416980\[^\n\]*\n" { set x [expr $x+1] }
1794 -re " +\[0-9\]+ 009c 01416F80\[^\n\]*\n +\[0-9\]+ +0010\[^\n\]*\n" { set x [expr $x+1] }
1795 -re " +\[0-9\]+ 00a2 01417800\[^\n\]*\n +\[0-9\]+ +6BA00000\[^\n\]*\n +\[0-9\]+ +0020\[^\n\]*\n" { set x [expr $x+1] }
1796 -re " +\[0-9\]+ 00ac 01416D80\[^\n\]*\n" { set x [expr $x+1] }
1797 -re " +\[0-9\]+ 00b0 01416B80\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1798 -re " +\[0-9\]+ 00b6 01416BA0\[^\n\]*\n +\[0-9\]+ +00000000\[^\n\]*\n" { set x [expr $x+1] }
252b5132
RH		 1799 eof { break }
1800 }
1801 }
1802
1803 # This was intended to do any cleanup necessary. It kinda looks like it
1804 # isn't needed, but just in case, please keep it in for now.
1805 gas_finish
1806
1807 # Did we find what we were looking for? If not, flunk it.
8fb49c3c 1808 if [expr $x == 38] then { pass $testname } else { fail $testname }
252b5132
RH		 1809}
1810
1811proc do_h8300s_movb {} {
1812 set testname "movbs.s: h8300s movb tests"
1813 set x 0
1814
1815 gas_start "movbs.s" "-al"
1816
1817 # Check each instruction bit pattern to verify it got
1818 # assembled correctly.
1819 while 1 {
1820 expect {
1821 -re " +\[0-9\]+ 0000 0C89\[^\n\]*\n" { set x [expr $x+1] }
1822 -re " +\[0-9\]+ 0002 F810\[^\n\]*\n" { set x [expr $x+1] }
1823 -re " +\[0-9\]+ 0004 6818\[^\n\]*\n" { set x [expr $x+1] }
1824 -re " +\[0-9\]+ 0006 6E180010\[^\n\]*\n" { set x [expr $x+1] }
1825 -re " +\[0-9\]+ 000a 78106A28\[^\n\]*\n +\[0-9\]+ +00000020\[^\n\]*\n" { set x [expr $x+1] }
1826 -re " +\[0-9\]+ 0012 6C18\[^\n\]*\n" { set x [expr $x+1] }
1827 -re " +\[0-9\]+ 0014 2810\[^\n\]*\n" { set x [expr $x+1] }
1828 -re " +\[0-9\]+ 0016 6A080000\[^\n\]*\n" { set x [expr $x+1] }
1829 -re " +\[0-9\]+ 001a 6A280000\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1830 -re " +\[0-9\]+ 0020 6898\[^\n\]*\n" { set x [expr $x+1] }
1831 -re " +\[0-9\]+ 0022 6E980010\[^\n\]*\n" { set x [expr $x+1] }
1832 -re " +\[0-9\]+ 0026 78106AA8\[^\n\]*\n +\[0-9\]+ +00000020\[^\n\]*\n" { set x [expr $x+1] }
1833 -re " +\[0-9\]+ 002e 6C98\[^\n\]*\n" { set x [expr $x+1] }
1834 -re " +\[0-9\]+ 0030 3810\[^\n\]*\n" { set x [expr $x+1] }
1835 -re " +\[0-9\]+ 0032 6A880000\[^\n\]*\n" { set x [expr $x+1] }
1836 -re " +\[0-9\]+ 0036 6AA80000\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1837 eof { break }
1838 }
1839 }
1840
1841 # This was intended to do any cleanup necessary. It kinda looks like it
1842 # isn't needed, but just in case, please keep it in for now.
1843 gas_finish
1844
1845 # Did we find what we were looking for? If not, flunk it.
1846 if [expr $x == 16] then { pass $testname } else { fail $testname }
1847}
1848
1849proc do_h8300s_movw {} {
1850 set testname "movws.s: h8300s movw tests"
1851 set x 0
1852
1853 gas_start "movws.s" "-al"
1854
1855 # Check each instruction bit pattern to verify it got
1856 # assembled correctly.
1857 while 1 {
1858 expect {
1859 -re " +\[0-9\]+ 0000 0D01\[^\n\]*\n" { set x [expr $x+1] }
1860 -re " +\[0-9\]+ 0002 79000010\[^\n\]*\n" { set x [expr $x+1] }
1861 -re " +\[0-9\]+ 0006 6910\[^\n\]*\n" { set x [expr $x+1] }
1862 -re " +\[0-9\]+ 0008 6F100010\[^\n\]*\n" { set x [expr $x+1] }
1863 -re " +\[0-9\]+ 000c 78106B20\[^\n\]*\n +\[0-9\]+ +00000020\[^\n\]*\n" { set x [expr $x+1] }
1864 -re " +\[0-9\]+ 0014 6D10\[^\n\]*\n" { set x [expr $x+1] }
1865 -re " +\[0-9\]+ 0016 6B000000\[^\n\]*\n" { set x [expr $x+1] }
1866 -re " +\[0-9\]+ 001a 6B200000\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1867 -re " +\[0-9\]+ 0020 6990\[^\n\]*\n" { set x [expr $x+1] }
1868 -re " +\[0-9\]+ 0022 6F900010\[^\n\]*\n" { set x [expr $x+1] }
1869 -re " +\[0-9\]+ 0026 78106BA0\[^\n\]*\n +\[0-9\]+ +00000020\[^\n\]*\n" { set x [expr $x+1] }
1870 -re " +\[0-9\]+ 002e 6D90\[^\n\]*\n" { set x [expr $x+1] }
1871 -re " +\[0-9\]+ 0030 6B800000\[^\n\]*\n" { set x [expr $x+1] }
1872 -re " +\[0-9\]+ 0034 6BA00000\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1873 eof { break }
1874 }
1875 }
1876
1877 # This was intended to do any cleanup necessary. It kinda looks like it
1878 # isn't needed, but just in case, please keep it in for now.
1879 gas_finish
1880
1881 # Did we find what we were looking for? If not, flunk it.
1882 if [expr $x == 14] then { pass $testname } else { fail $testname }
1883}
1884
1885
1886proc do_h8300s_movl {} {
1887 set testname "movls.s: h8300s movl tests"
1888 set x 0
1889
1890 gas_start "movls.s" "-al"
1891
1892 # Check each instruction bit pattern to verify it got
1893 # assembled correctly.
1894 while 1 {
1895 expect {
1896 -re " +\[0-9\]+ 0000 0F81\[^\n\]*\n" { set x [expr $x+1] }
1897 -re " +\[0-9\]+ 0002 7A000000\[^\n\]*\n +\[0-9\]+ +0040\[^\n\]*\n" { set x [expr $x+1] }
1898 -re " +\[0-9\]+ 0008 01006910\[^\n\]*\n" { set x [expr $x+1] }
1899 -re " +\[0-9\]+ 000c 01006F10\[^\n\]*\n +\[0-9\]+ +0010\[^\n\]*\n" { set x [expr $x+1] }
1900 -re " +\[0-9\]+ 0012 01007810\[^\n\]*\n +\[0-9\]+ +6B200000\[^\n\]*\n +\[0-9\]+ +0020\[^\n\]*\n" { set x [expr $x+1] }
1901 -re " +\[0-9\]+ 001c 01006D10\[^\n\]*\n" { set x [expr $x+1] }
1902 -re " +\[0-9\]+ 0020 01006B00\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1903 -re " +\[0-9\]+ 0026 01006B20\[^\n\]*\n +\[0-9\]+ +00000000\[^\n\]*\n" { set x [expr $x+1] }
1904 -re " +\[0-9\]+ 002e 01006990\[^\n\]*\n" { set x [expr $x+1] }
1905 -re " +\[0-9\]+ 0032 01006F90\[^\n\]*\n +\[0-9\]+ +0010\[^\n\]*\n" { set x [expr $x+1] }
1906 -re " +\[0-9\]+ 0038 01007890\[^\n\]*\n +\[0-9\]+ +6BA00000\[^\n\]*\n +\[0-9\]+ +0020\[^\n\]*\n" { set x [expr $x+1] }
1907 -re " +\[0-9\]+ 0042 01006D90\[^\n\]*\n" { set x [expr $x+1] }
1908 -re " +\[0-9\]+ 0046 01006B80\[^\n\]*\n +\[0-9\]+ +0000\[^\n\]*\n" { set x [expr $x+1] }
1909 -re " +\[0-9\]+ 004c 01006BA0\[^\n\]*\n +\[0-9\]+ +00000000\[^\n\]*\n" { set x [expr $x+1] }
1910 eof { break }
1911 }
1912 }
1913
1914 # This was intended to do any cleanup necessary. It kinda looks like it
1915 # isn't needed, but just in case, please keep it in for now.
1916 gas_finish
1917
1918 # Did we find what we were looking for? If not, flunk it.
1919 if [expr $x == 14] then { pass $testname } else { fail $testname }
1920}
1921
1922proc do_h8300s_pushpop {} {
1923 set testname "pushpops.s: h8300s pushpop tests"
1924 set x 0
1925
1926 gas_start "pushpops.s" "-al"
1927
1928 # Check each instruction bit pattern to verify it got
1929 # assembled correctly.
1930 while 1 {
1931 expect {
1932 -re " +\[0-9\]+ 0000 6D70\[^\n\]*\n" { set x [expr $x+1] }
1933 -re " +\[0-9\]+ 0002 01006D70\[^\n\]*\n" { set x [expr $x+1] }
1934 -re " +\[0-9\]+ 0006 6DF0\[^\n\]*\n" { set x [expr $x+1] }
1935 -re " +\[0-9\]+ 0008 01006DF0\[^\n\]*\n" { set x [expr $x+1] }
1936 eof { break }
1937 }
1938 }
1939
1940 # This was intended to do any cleanup necessary. It kinda looks like it
1941 # isn't needed, but just in case, please keep it in for now.
1942 gas_finish
1943
1944 # Did we find what we were looking for? If not, flunk it.
1945 if [expr $x == 4] then { pass $testname } else { fail $testname }
1946}
1947
1948proc do_h8300s_rotate_shift {} {
1949 set testname "rotshs.s: h8300s rotate and shift tests"
1950 set x 0
1951
1952 gas_start "rotshs.s" "-al"
1953
1954 # Check each instruction bit pattern to verify it got
1955 # assembled correctly.
1956 while 1 {
1957 expect {
1958 -re " +\[0-9\]+ 0000 1288\[^\n\]*\n" { set x [expr $x+1] }
1959 -re " +\[0-9\]+ 0002 12C8\[^\n\]*\n" { set x [expr $x+1] }
1960 -re " +\[0-9\]+ 0004 1290\[^\n\]*\n" { set x [expr $x+1] }
1961 -re " +\[0-9\]+ 0006 12D0\[^\n\]*\n" { set x [expr $x+1] }
1962 -re " +\[0-9\]+ 0008 12B0\[^\n\]*\n" { set x [expr $x+1] }
1963 -re " +\[0-9\]+ 000a 12F0\[^\n\]*\n" { set x [expr $x+1] }
1964 -re " +\[0-9\]+ 000c 1388\[^\n\]*\n" { set x [expr $x+1] }
1965 -re " +\[0-9\]+ 000e 13C8\[^\n\]*\n" { set x [expr $x+1] }
1966 -re " +\[0-9\]+ 0010 1390\[^\n\]*\n" { set x [expr $x+1] }
1967 -re " +\[0-9\]+ 0012 13D0\[^\n\]*\n" { set x [expr $x+1] }
1968 -re " +\[0-9\]+ 0014 13B0\[^\n\]*\n" { set x [expr $x+1] }
1969 -re " +\[0-9\]+ 0016 13F0\[^\n\]*\n" { set x [expr $x+1] }
1970 -re " +\[0-9\]+ 0018 1208\[^\n\]*\n" { set x [expr $x+1] }
1971 -re " +\[0-9\]+ 001a 1248\[^\n\]*\n" { set x [expr $x+1] }
1972 -re " +\[0-9\]+ 001c 1210\[^\n\]*\n" { set x [expr $x+1] }
1973 -re " +\[0-9\]+ 001e 1250\[^\n\]*\n" { set x [expr $x+1] }
1974 -re " +\[0-9\]+ 0020 1230\[^\n\]*\n" { set x [expr $x+1] }
1975 -re " +\[0-9\]+ 0022 1270\[^\n\]*\n" { set x [expr $x+1] }
1976 -re " +\[0-9\]+ 0024 1308\[^\n\]*\n" { set x [expr $x+1] }
1977 -re " +\[0-9\]+ 0026 1348\[^\n\]*\n" { set x [expr $x+1] }
1978 -re " +\[0-9\]+ 0028 1310\[^\n\]*\n" { set x [expr $x+1] }
1979 -re " +\[0-9\]+ 002a 1350\[^\n\]*\n" { set x [expr $x+1] }
1980 -re " +\[0-9\]+ 002c 1330\[^\n\]*\n" { set x [expr $x+1] }
1981 -re " +\[0-9\]+ 002e 1370\[^\n\]*\n" { set x [expr $x+1] }
1982 -re " +\[0-9\]+ 0030 1088\[^\n\]*\n" { set x [expr $x+1] }
1983 -re " +\[0-9\]+ 0032 10C8\[^\n\]*\n" { set x [expr $x+1] }
1984 -re " +\[0-9\]+ 0034 1090\[^\n\]*\n" { set x [expr $x+1] }
1985 -re " +\[0-9\]+ 0036 10D0\[^\n\]*\n" { set x [expr $x+1] }
1986 -re " +\[0-9\]+ 0038 10B0\[^\n\]*\n" { set x [expr $x+1] }
1987 -re " +\[0-9\]+ 003a 10F0\[^\n\]*\n" { set x [expr $x+1] }
1988 -re " +\[0-9\]+ 003c 1188\[^\n\]*\n" { set x [expr $x+1] }
1989 -re " +\[0-9\]+ 003e 11C8\[^\n\]*\n" { set x [expr $x+1] }
1990 -re " +\[0-9\]+ 0040 1190\[^\n\]*\n" { set x [expr $x+1] }
1991 -re " +\[0-9\]+ 0042 11D0\[^\n\]*\n" { set x [expr $x+1] }
1992 -re " +\[0-9\]+ 0044 11B0\[^\n\]*\n" { set x [expr $x+1] }
1993 -re " +\[0-9\]+ 0046 11F0\[^\n\]*\n" { set x [expr $x+1] }
1994 -re " +\[0-9\]+ 0048 1008\[^\n\]*\n" { set x [expr $x+1] }
1995 -re " +\[0-9\]+ 004a 1048\[^\n\]*\n" { set x [expr $x+1] }
1996 -re " +\[0-9\]+ 004c 1010\[^\n\]*\n" { set x [expr $x+1] }
1997 -re " +\[0-9\]+ 004e 1050\[^\n\]*\n" { set x [expr $x+1] }
1998 -re " +\[0-9\]+ 0050 1030\[^\n\]*\n" { set x [expr $x+1] }
1999 -re " +\[0-9\]+ 0052 1070\[^\n\]*\n" { set x [expr $x+1] }
2000 -re " +\[0-9\]+ 0054 1108\[^\n\]*\n" { set x [expr $x+1] }
2001 -re " +\[0-9\]+ 0056 1148\[^\n\]*\n" { set x [expr $x+1] }
2002 -re " +\[0-9\]+ 0058 1110\[^\n\]*\n" { set x [expr $x+1] }
2003 -re " +\[0-9\]+ 005a 1150\[^\n\]*\n" { set x [expr $x+1] }
2004 -re " +\[0-9\]+ 005c 1130\[^\n\]*\n" { set x [expr $x+1] }
2005 -re " +\[0-9\]+ 005e 1170\[^\n\]*\n" { set x [expr $x+1] }
2006 eof { break }
2007 }
2008 }
2009
2010 # This was intended to do any cleanup necessary. It kinda looks like it
2011 # isn't needed, but just in case, please keep it in for now.
2012 gas_finish
2013
2014 # Did we find what we were looking for? If not, flunk it.
2015 if [expr $x == 48] then { pass $testname } else { fail $testname }
2016}
2017
2018proc do_h8300s_extend {} {
2019 set testname "extends.s: h8300s extend tests"
2020 set x 0
2021
2022 gas_start "extends.s" "-al"
2023
2024 # Check each instruction bit pattern to verify it got
2025 # assembled correctly.
2026 while 1 {
2027 expect {
2028 -re " +\[0-9\]+ 0000 17D0\[^\n\]*\n" { set x [expr $x+1] }
2029 -re " +\[0-9\]+ 0002 17F0\[^\n\]*\n" { set x [expr $x+1] }
2030 -re " +\[0-9\]+ 0004 1750\[^\n\]*\n" { set x [expr $x+1] }
2031 -re " +\[0-9\]+ 0006 1770\[^\n\]*\n" { set x [expr $x+1] }
2032 eof { break }
2033 }
2034 }
2035
2036 # This was intended to do any cleanup necessary. It kinda looks like it
2037 # isn't needed, but just in case, please keep it in for now.
2038 gas_finish
2039
2040 # Did we find what we were looking for? If not, flunk it.
2041 if [expr $x == 4] then { pass $testname } else { fail $testname }
2042}
2043
2044proc do_h8300s_mac {} {
2045 set testname "macs.s: h8300s mac tests"
2046 set x 0
2047
2048 gas_start "macs.s" "-al"
2049
2050 # Check each instruction bit pattern to verify it got
2051 # assembled correctly.
2052 while 1 {
2053 expect {
fbe1e41f
NC		 2054 -re " +\[0-9\]+ 0000 01A0\[^\n\]*\n" { set x [expr $x+1] }
2055 -re " +\[0-9\]+ 0002 0324\[^\n\]*\n" { set x [expr $x+1] }
2056 -re " +\[0-9\]+ 0004 0335\[^\n\]*\n" { set x [expr $x+1] }
2057 -re " +\[0-9\]+ 0006 01606D45\[^\n\]*\n" { set x [expr $x+1] }
2058 -re " +\[0-9\]+ 000a 0224\[^\n\]*\n" { set x [expr $x+1] }
2059 -re " +\[0-9\]+ 000c 0235\[^\n\]*\n" { set x [expr $x+1] }
252b5132
RH		 2060 eof { break }
2061 }
2062 }
2063
2064 # This was intended to do any cleanup necessary. It kinda looks like it
2065 # isn't needed, but just in case, please keep it in for now.
2066 gas_finish
2067
2068 # Did we find what we were looking for? If not, flunk it.
2069 if [expr $x == 6] then { pass $testname } else { fail $testname }
2070}
2071
2072proc do_h8300s_multiple {} {
2073 set testname "multiples.s: h8300s multiple tests"
2074 set x 0
2075
2076 gas_start "multiples.s" "-al"
2077
2078 # Check each instruction bit pattern to verify it got
2079 # assembled correctly.
2080 while 1 {
2081 expect {
2082 -re " +\[0-9\]+ 0000 01106D71\[^\n\]*\n" { set x [expr $x+1] }
2083 -re " +\[0-9\]+ 0004 01206D72\[^\n\]*\n" { set x [expr $x+1] }
2084 -re " +\[0-9\]+ 0008 01306D73\[^\n\]*\n" { set x [expr $x+1] }
2085 -re " +\[0-9\]+ 000c 01106DF0\[^\n\]*\n" { set x [expr $x+1] }
2086 -re " +\[0-9\]+ 0010 01206DF0\[^\n\]*\n" { set x [expr $x+1] }
2087 -re " +\[0-9\]+ 0014 01306DF0\[^\n\]*\n" { set x [expr $x+1] }
4892e510
NC		 2088 -re " +\[0-9\]+ 0018 01106D73\[^\n\]*\n" { set x [expr $x+1] }
2089 -re " +\[0-9\]+ 001c 01106DF2\[^\n\]*\n" { set x [expr $x+1] }
2090 -re " +\[0-9\]+ 0020 01106D75\[^\n\]*\n" { set x [expr $x+1] }
2091 -re " +\[0-9\]+ 0024 01206D76\[^\n\]*\n" { set x [expr $x+1] }
2092 -re " +\[0-9\]+ 0028 01106DF4\[^\n\]*\n" { set x [expr $x+1] }
2093 -re " +\[0-9\]+ 002c 01206DF4\[^\n\]*\n" { set x [expr $x+1] }
2094
252b5132
RH		 2095 eof { break }
2096 }
2097 }
2098
2099 # This was intended to do any cleanup necessary. It kinda looks like it
2100 # isn't needed, but just in case, please keep it in for now.
2101 gas_finish
2102
2103 # Did we find what we were looking for? If not, flunk it.
4892e510 2104 if [expr $x == 12] then { pass $testname } else { fail $testname }
252b5132
RH		 2105}
2106
2107proc do_h8300h_mov32bug {} {
2108 set testname "mov32bug.s: h8300h mov32bug test"
2109 set x 0
2110
2111 if [gas_test_old "mov32bug.s" "" "Proper relocation for mov.l (part 1)"] then {
2112 objdump_start_no_subdir "a.out" "-r"
2113
2114 while 1 {
2115 expect {
046e56f7 2116 -re "00000002\[^\n\]*32\[^\n\]*_a-0x77359400\[^\n\]*\n"
252b5132
RH		 2117 { set x [expr $x+1] }
2118 timeout { perror "timeout\n; break }
2119 eof { break }
2120 }
2121 }
2122 }
2123
2124 # This was intended to do any cleanup necessary. It kinda looks like it
2125 # isn't needed, but just in case, please keep it in for now.
2126 objdump_finish
2127
2128 # Did we find what we were looking for? If not, flunk it.
2129 if [expr $x == 1] then { pass $testname } else { fail $testname }
2130}
2131
aff16937
NC		 2132proc do_h8300hn_addressgen {} {
2133 set testname "symaddgen.s: h8300hn symbol address generation"
2134 set x 0
2135
2136 gas_start "symaddgen.s" "-al"
2137
2138 # Check each instruction bit pattern to verify it got
2139 # assembled correctly.
2140 while 1 {
2141 expect {
2142 -re " +\[0-9\]+ .* 01006DF6\[^\n\]*\n" { set x [expr $x+1] }
2143 -re " +\[0-9\]+ .* 0D76\[^\n\]*\n" { set x [expr $x+1] }
2144 -re " +\[0-9\]+ .* 790207D0\[^\n\]*\n" { set x [expr $x+1] }
2145 -re " +\[0-9\]+ .* 6B82F020\[^\n\]*\n" { set x [expr $x+1] }
2146 -re " +\[0-9\]+ .* 79022710\[^\n\]*\n" { set x [expr $x+1] }
2147 -re " +\[0-9\]+ .* 6B820000\[^\n\]*\n" { set x [expr $x+1] }
2148 -re " +\[0-9\]+ .* 01006D76\[^\n\]*\n" { set x [expr $x+1] }
2149 -re " +\[0-9\]+ .* 5470\[^\n\]*\n" { set x [expr $x+1] }
2150
2151 eof { break }
2152 }
2153 }
2154 # This was intended to do any cleanup necessary. It kinda looks like it
2155 # isn't needed, but just in case, please keep it in for now.
2156 gas_finish
2157 # Did we find what we were looking for? If not, flunk it.
2158 if [expr $x == 8] then { pass $testname } else { fail $testname }
2159}
2160
92868b6e
NC		 2161proc do_h8300_addsubrxcheck {} {
2162 set testname "addsubrxcheck.s: h8300 check rx generation for adds subs instructions"
2163 set x 0
2164
2165 gas_start "addsubrxcheck.s" "-al"
2166
2167 # Check each instruction bit pattern to verify it got
2168 # assembled correctly.
2169 while 1 {
2170 expect {
2171 -re " +\[0-9\]+ .* 6DF6\[^\n\]*\n" { set x [expr $x+1] }
2172 -re " +\[0-9\]+ .* 0D76\[^\n\]*\n" { set x [expr $x+1] }
2173 -re " +\[0-9\]+ .* 1B87\[^\n\]*\n" { set x [expr $x+1] }
2174 -re " +\[0-9\]+ .* 6F62FFFE\[^\n\]*\n" { set x [expr $x+1] }
2175 -re " +\[0-9\]+ .* 1B82\[^\n\]*\n" { set x [expr $x+1] }
2176 -re " +\[0-9\]+ .* 6FE2FFFE\[^\n\]*\n" { set x [expr $x+1] }
2177 -re " +\[0-9\]+ .* 1922\[^\n\]*\n" { set x [expr $x+1] }
2178 -re " +\[0-9\]+ .* 0D20\[^\n\]*\n" { set x [expr $x+1] }
2179 -re " +\[0-9\]+ .* 0B87\[^\n\]*\n" { set x [expr $x+1] }
2180 -re " +\[0-9\]+ .* 6D76\[^\n\]*\n" { set x [expr $x+1] }
2181 -re " +\[0-9\]+ .* 5470\[^\n\]*\n" { set x [expr $x+1] }
2182
2183 eof { break }
2184 }
2185 }
2186 # This was intended to do any cleanup necessary. It kinda looks like it
2187 # isn't needed, but just in case, please keep it in for now.
2188 gas_finish
2189 # Did we find what we were looking for? If not, flunk it.
2190 if [expr $x == 11] then { pass $testname } else { fail $testname }
2191}
2192
252b5132
RH		 2193if [istarget h8300*-*-*] then {
2194 # Test the basic h8300 instruction parser
2195 do_h8300_add_sub
2196 do_h8300_logical
252b5132
RH		 2197 do_h8300_bitops1
2198 do_h8300_bitops2
2199 do_h8300_bitops3
2200 do_h8300_bitops4
252b5132
RH		 2201 do_h8300_compare
2202 do_h8300_decimal
2203 do_h8300_incdec
2204 do_h8300_divmul
2205 do_h8300_misc
2206 do_h8300_movb
2207 do_h8300_movw
2208 do_h8300_pushpop
2209 do_h8300_rotate_shift
aff16937 2210 do_h8300hn_addressgen
252b5132 2211
92868b6e
NC		 2212 do_h8300_addsubrxcheck
2213
252b5132
RH		 2214 # Now test the h8300h instruction parser
2215 do_h8300h_add_sub
2216 do_h8300h_logical
252b5132
RH		 2217 do_h8300h_bitops1
2218 do_h8300h_bitops2
2219 do_h8300h_bitops3
2220 do_h8300h_bitops4
252b5132
RH		 2221 do_h8300h_compare
2222 do_h8300h_decimal
2223 do_h8300h_incdec
2224 do_h8300h_divmul
2225 do_h8300h_misc
2226 do_h8300h_movb
2227 do_h8300h_movw
2228 do_h8300h_movl
2229 do_h8300_pushpop
2230 do_h8300h_rotate_shift
2231 do_h8300h_extend
2232
2233 # Now test the h8300s instruction parser
2234 do_h8300s_add_sub
2235 do_h8300s_logical
252b5132
RH		 2236 do_h8300s_bitops1
2237 do_h8300s_bitops2
2238 do_h8300s_bitops3
2239 do_h8300s_bitops4
252b5132
RH		 2240 do_h8300s_compare
2241 do_h8300s_decimal
2242 do_h8300s_incdec
2243 do_h8300s_divmul
2244 do_h8300s_misc
2245 do_h8300s_movb
2246 do_h8300s_movw
2247 do_h8300s_movl
2248 do_h8300_pushpop
2249 do_h8300s_rotate_shift
2250 do_h8300s_extend
2251 do_h8300s_mac
2252 do_h8300s_multiple
2253
2254 do_h8300h_mov32bug
2255
2256 # Now some random tests
252b5132 2257 gas_test "cmpsi2.s" "" "" "cmpsi2.s"
af7329f0
NC		 2258
2259 run_dump_test "pr3134"
252b5132 2260}
A mirror of the official binutils-gdb repository